GuilleSQL :: Microsoft SQL Server, SSIS, y más !!

¿Cómo proteger SQL Server y una Aplicación Web (o de otro tipo) de ataques SQL Injection?

Volver a: [SQL Injection]


Este capítulo introduce el concepto de Cadenas Peligrosas en el contexto de SQL Injection, para seguidamente centrarse en el estudio de alternativas de protección frente a ataques SQL Injection: Utilizar Procedimientos Almacenados o Consultas SQL de forma parametrizada, evitar SQL Dinámico en el interior de Procedimientos Almacenados, Validar los datos de Usuario utilizando validaciones de servidor y adicionalmente (si se quiere) también de cliente, sustituir o eliminar cadenas peligrosas (comentarios, delimitadores de cadena, palabras reservadas, etc.), minimizar los permisos de acceso a base de datos, evitar revelar información de errores de base de datos (correcta Gestión de Errores), etc.

Ahora que ya comprendemos qué es SQL Injection y cuáles son las principales formas en que nos pueden realizar un ataque de SQL Injection, estamos en situación de definir diferentes alternativas (que no tienen porque ser únicas ni exclusivas) para protegerse de ataques SQL Injection. Recordemos que los daños producidos por un Ataque SQL Injection pueden ser plurales: daños técnicos (ej: caídas del servicio por ataques de Denegación de Servicio a través de SQL Injection), daños de imagen (ej: pérdida de confianza por parte de los Usuarios con el correspondiente impacto económico), daños económicos (ej: costes de reparación de daños físicos, como pueda ser borrados o modificaciones de datos), etc.

Antes de empezar la enumeración y descripción de las diferentes alternativas existentes para protegerse de SQL Injection, es importante introducir el concepto de cadenas peligrosas ¿A qué podemos denominar una cadena peligrosa en términos de SQL Injection? Pues a cualquier cadena que potencialmente pueda alterar el comportamiento de la consulta SQL que deseamos ejecutar, como es el caso (entre otros) de:

  • Comentarios.
  • Delimitadores de Cadena (ej: comillas simples y/o dobles).
  • Delimitadores de línea (ej: punto y coma).
  • Palabras reservadas como DELETE, UPDATE, ALTER, DROP, etc.
  • Llamadas a Procedimientos Almacenados del Sistema.

Y ahora, si que estamos en situación de estudiar las diferentes alternativas que tenemos para protegernos de ataques SQL Injection, como resultado de las pruebas realizadas en el Laboratorio de GuilleSQL:

  • Utilizar Procedimientos Almacenados (o en su defecto Consultas SQL) de forma parametrizada y evitar la utilización de consultas SQL al vuelo y de SQL Dinámico. Esta es la opción más recomendable, y requiere en consecuencia utilizar Procedimientos Almacenados para el acceso a la base de datos, los cuales deben ser invocados de forma parametrizada (llamar a Procedimientos Almacenados desde consultas SQL al vuelo o desde código SQL Dinámico, sigue siendo una operación de riesgo para SQL Injection). También es posible utilizar parámetros con consultas SQL construidas dinámicamente. La utilización de Parámetros, permite además la realización implícita de comprobaciones de tipo de dato y de longitud.

  • Validar los datos introducidos por el Usuario (QueryStrings, Campos de Formularios, valores almacenados en el Registro de Windows o en ficheros de configuración, etc.). Validar el tipo de dato, longitud, formato y rango, y además, comprobar la existencia de cadenas peligrosas en las entradas de la aplicación (ej: cajas de texto, QueryStrings, valores del Registro de Windows, etc.). En caso de detectar cadenas peligrosas en las entradas de la aplicación, mostrar un mensaje informativo, y no realizar ningún acceso a base de datos. Es una buena práctica identificar una lista con los caracteres de entrada permitidos, y utilizar Expresiones Regulares (Regular Expressions) para validar la entrada.

    En el caso de Aplicaciones Web (ej: Aplicaciones ASP y Aplicaciones ASP.Net), utilizar siempre validaciones de servidor (server-side validations), empleando validaciones de cliente (client-side validations) para minimizar las recargas de página (round trips) y mejorar la experiencia del Usuario.

    En el caso de Aplicaciones ASP.Net, pueden utilizarse controles como el RegularExpressionValidator y el RangeValidator, así como la clase Regex para la utilización de Expresiones Regulares por código (ej: en el evento OnClick de un botón de servidor, como parte de una validación personalizada de un control CustomValidator, etc.). Hemos evaluado la utilización de estos Controles de ASP.Net en el Laboratorio de GuilleSQL, y el resultado ha sido satisfactorio (evidentemente).

  • Sustituir o eliminar cadenas peligrosas al construir consultas SQL al vuelo (o SQL Dinámico). Antes de construir una consulta SQL al vuelo, sustituir o eliminar las cadenas peligrosas que puedan encontrarse en las entradas de la aplicación, y seguidamente construir la correspondiente consulta SQL, ejecutándola contra la base de datos. Como vimos antes, la cantidad de cadenas peligrosas existentes es muy alta, pero el hecho de al menos eliminar los delimitadores de cadena (las comillas simples o comillas dobles, dependiendo del caso) y también eliminar los delimitadores de comentarios, resulta relativamente sencillo y evita bastantes riesgos.

  • Minimizar los permisos concedidos al usuario utilizado para acceder a base de datos. Es decir, en la medida de lo posible evitar que el usuario utilizado para acceder a SQL Server sea miembro de sysadmin, evitar conceder permisos directos sobre las tablas (conceder permisos sólo sobre los Procedimientos Almacenados que se necesiten utilizar), etc. También lo hemos probado en el Laboratorio de GuilleSQL, evidentemente con éxito.

  • Evitar revelar información de errores de base de datos (correcta Gestión de Errores), ya que dicha información podría ser utilizada por el atacante (Hacker) para averiguar o revelar parcial o totalmente el esquema (nombres de campos, nombres de tablas, etc.) de la base de datos fruto de su ataque SQL Injection, lo cual nos hace aún más vulnerables.

  • Utilizar dispositivos cortafuegos (Firewall) que trabajen al nivel OSI de Aplicación. Algunos fabricantes de cortafuegos (Firewall) introducen en sus productos (sean firewalls por hardware o por software) funciones de seguridad a nivel de Aplicación, de tal modo que son capaces de recolectar y reconstruir paquetes y tramas de red para inspeccionar su contenido en busca de intentos de ataques de naturalezas dispares, incluyendo SQL Injection. Por desgracia no hemos podido evaluar esta alternativa en el Laboratorio de GuilleSQL, pero quería introducirlo aquí para quién le pueda resultar de interés, pueda plantearse su evaluación (para muchos, el hecho de poder adquirir un dispositivo hardware que una vez enchufado puedan olvidarse de él, es una comodidad por la que están dispuestos a pagar dinero).

Es probable que alguien pueda conocer otras alternativas adicionales para proteger una aplicación de ataques SQL Injection, pero lo que si es seguro, es que con las alternativas anteriores, es posible dejar suficientemente securizada una aplicación de base de datos SQL Server frente a posibles ataques SQL Injection.

Volver a: [SQL Injection]




Miembros de
Miembros de GITCA (Global IT Community Association)

Menu de Usuario
  Iniciar Sesión
  Registrarse
  Restablecer Contraseña
  Ventajas de Registrarse

Acerca de
  Contigo desde Oct 2007
  771 usuarios registrados
  86146 pageloads/mes
  Ranking Alexa 498160

Social Networks
Sigue a Portal GuilleSQL en Linkedin !!
Sigue a Portal GuilleSQL en Twitter !!



Archivo

Junio de 2016 (1)
Mayo de 2016 (2)
Abril de 2016 (2)
Septiembre de 2015 (2)
Agosto de 2015 (2)
Junio de 2015 (10)
Mayo de 2015 (4)
Abril de 2015 (8)
Marzo de 2015 (11)
Octubre de 2014 (3)
Septiembre de 2014 (7)
Agosto de 2014 (5)
Julio de 2014 (2)
Mayo de 2014 (4)
Abril de 2014 (4)
Marzo de 2014 (4)
Febrero de 2014 (1)
Enero de 2014 (5)
Diciembre de 2013 (8)
Noviembre de 2013 (2)
Octubre de 2013 (7)
Septiembre de 2013 (6)
Agosto de 2013 (1)
Julio de 2013 (6)
Junio de 2013 (11)
Mayo de 2013 (7)
Abril de 2013 (6)
Febrero de 2013 (5)
Enero de 2013 (7)
Diciembre de 2012 (12)
Noviembre de 2012 (13)
Octubre de 2012 (5)
Septiembre de 2012 (3)
Agosto de 2012 (6)
Julio de 2012 (4)
Junio de 2012 (1)
Mayo de 2012 (2)
Abril de 2012 (7)
Marzo de 2012 (16)
Febrero de 2012 (9)
Enero de 2012 (5)
Diciembre de 2011 (10)
Noviembre de 2011 (10)
Octubre de 2011 (4)
Septiembre de 2011 (5)
Agosto de 2011 (2)
Julio de 2011 (2)
Junio de 2011 (4)
Mayo de 2011 (2)
Abril de 2011 (6)
Marzo de 2011 (4)
Febrero de 2011 (10)
Enero de 2011 (5)
Diciembre de 2010 (6)
Noviembre de 2010 (4)
Octubre de 2010 (8)
Septiembre de 2010 (4)
Agosto de 2010 (1)
Julio de 2010 (3)
Mayo de 2010 (5)
Abril de 2010 (6)
Marzo de 2010 (8)
Febrero de 2010 (3)
Enero de 2010 (1)
Diciembre de 2009 (9)
Noviembre de 2009 (14)
Octubre de 2009 (2)
Septiembre de 2009 (8)
Agosto de 2009 (2)
Julio de 2009 (10)
Junio de 2009 (9)
Mayo de 2009 (10)
Abril de 2009 (9)
Marzo de 2009 (3)
Febrero de 2009 (2)
Enero de 2009 (3)
Noviembre de 2008 (2)
Octubre de 2008 (2)
Septiembre de 2008 (2)
Agosto de 2008 (5)
Julio de 2008 (5)
Junio de 2008 (1)
Mayo de 2008 (3)
Abril de 2008 (2)
Marzo de 2008 (2)
Febrero de 2008 (2)
Enero de 2008 (5)
Noviembre de 2007 (2)
Octubre de 2007 (2)






Copyright © 2007 GuilleSQL, todos los derechos reservados.