Cracking Contraseñas
con Hashcat
Laboratorio práctico para aprender a identificar, seleccionar el modo correcto y crackear hashes reales usando diccionario, fuerza bruta, máscaras y reglas.
Dictionary attack
Brute-force
Mask attack
Rule-based
Hybrid
00 — Referencia rápida
Tipos de ataque disponibles en hashcat:
0
Wordlist
Diccionario puro. Cada línea es una contraseña candidata.
1
Combination
Combina dos diccionarios concatenando palabras.
3
Brute-force
Genera todas las combinaciones de una máscara dada.
6
Hybrid W+M
Wordlist con sufijo de máscara.
7
Hybrid M+W
Máscara con sufijo de wordlist.
Modos de hash más comunes (-m):
0
MD5
5f4dcc3b5aa765d...
100
SHA1
5baa61e4c9b93f3f...
1400
SHA-256
5e884898da28047...
1800
sha512crypt
$6$salt$hash...
1000
NTLM
8846f7eaee8fb117...
3200
bcrypt
$2a$12$...
2500
WPA-EAPOL-PBKDF2
*.hccapx
500
md5crypt
$1$salt$hash
Caracteres de máscara más usados:
| Char | Juego de caracteres | Descripción |
|---|---|---|
| ?l | abcdefghijklmnopqrstuvwxyz | Minúsculas |
| ?u | ABCDEFGHIJKLMNOPQRSTUVWXYZ | Mayúsculas |
| ?d | 0123456789 | Dígitos |
| ?s | !@#$%^&*()... | Especiales |
| ?a | ?l?u?d?s | Todos los anteriores |
| ?h | 0-9 + a-f | Hex minúsculas |
| ?H | 0-9 + A-F | Hex mayúsculas |
Flags esenciales:
| Flag | Valor ejemplo | Descripción |
|---|---|---|
| -m | 0, 100, 1000… | Tipo de hash |
| -a | 0, 3, 6… | Modo de ataque |
| -o | cracked.txt | Guardar resultados en fichero |
| --show | — | Mostrar contraseñas ya crackeadas del potfile |
| -r | best64.rule | Aplicar reglas de mutación |
| --increment | — | Incrementar longitud de máscara automáticamente |
| --increment-min | 4 | Longitud mínima en modo incremento |
| --increment-max | 8 | Longitud máxima en modo incremento |
| -w | 3 | Nivel de carga de trabajo (1-4) |
| --force | — | Forzar ejecución (útil en VMs) |
| --potfile-disable | — | No usar/guardar el potfile |
01 — Preparación del entorno
ℹ️ Requisitos
Kali Linux con hashcat instalado. Si no está disponible: sudo apt install hashcat. Para mejores resultados usa GPU, pero con --force funciona en CPU/VM.
Crea la estructura de ficheros del laboratorio:
Crear directorio de trabajo
$ mkdir -p ~/hashcat-lab/{hashes,wordlists,rules,output}
$ cd ~/hashcat-lab
Wordlists recomendadas
/usr/share/wordlists/rockyou.txt
/usr/share/wordlists/fasttrack.txt
/usr/share/seclists/Passwords/
Reglas disponibles en Kali
/usr/share/hashcat/rules/best64.rule
/usr/share/hashcat/rules/rockyou-30000.rule
/usr/share/hashcat/rules/d3ad0ne.rule
Verificar instalación y ver versión
$ hashcat --version
$ hashcat --help | head -50
# Identificar si tienes GPU disponible:
$ hashcat -I
⚠ Potfile
Hashcat guarda resultados en ~/.local/share/hashcat/hashcat.potfile. Si repites un ejercicio, usa --potfile-disable o borra el potfile para volver a crackear el mismo hash.
Ejercicios
✓
01
▾
Identificar y crackear tres hashes MD5 usando el diccionario rockyou.txt. Aprenderás a crear un fichero de hashes múltiple y a interpretar la salida de hashcat.
Hashes a crackear — guárdalos en
hashes/md5.txt5f4dcc3b5aa765d61d8327deb882cf99
7c6a180b36896a0a8c02787eeafb0e4c
d8578edf8458ce06fbc5bb76a58c5ca4
1 — Crear el fichero de hashes
$ cat >> hashes/md5.txt <<EOF
5f4dcc3b5aa765d61d8327deb882cf99
7c6a180b36896a0a8c02787eeafb0e4c
d8578edf8458ce06fbc5bb76a58c5ca4
EOF
2 — Lanzar el ataque con diccionario
$ hashcat -m 0 -a 0 hashes/md5.txt /usr/share/wordlists/rockyou.txt -o output/md5_cracked.txt --force
3 — Ver resultados
$ hashcat -m 0 hashes/md5.txt --show
# o simplemente:
$ cat output/md5_cracked.txt
PISTA
Los tres hashes son contraseñas muy comunes que aparecen en casi cualquier diccionario. Son palabras de 4-8 caracteres presentes en el top 100 de contraseñas más usadas. Rockyou.txt las tiene todas.
RESPUESTAS
5f4dcc3b5aa765d61d8327deb882cf99 → password
7c6a180b36896a0a8c02787eeafb0e4c → password1
d8578edf8458ce06fbc5bb76a58c5ca4 → qwerty
✓
02
▾
Crackear un hash SHA1. Además aprenderás a crear tu propia wordlist personalizada para un objetivo y a combinarla con rockyou.
Hash SHA1 — guárdalo en
hashes/sha1.txtaaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d
Identificar el tipo de hash antes de atacar
$ hashid aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d
# SHA1 = 40 hex chars, MD5 = 32 hex chars, SHA256 = 64 hex chars
# Regla de oro: longitud del hash → modo hashcat
Ataque con rockyou.txt
$ hashcat -m 100 -a 0 hashes/sha1.txt /usr/share/wordlists/rockyou.txt --force
Alternativa: crear wordlist personalizada basada en el objetivo
$ cewl http://target.example.com -m 5 -w wordlists/custom.txt
# Combinar ambas wordlists:
$ cat wordlists/custom.txt /usr/share/wordlists/rockyou.txt > wordlists/combined.txt
$ hashcat -m 100 -a 0 hashes/sha1.txt wordlists/combined.txt --force
Es una letra sola. El hash SHA1 de caracteres individuales es muy rápido de crackear incluso por fuerza bruta.
aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d → h
✓
03
▾
Crackear varios hashes SHA-256 a la vez. Hashcat es más eficiente cuando procesa múltiples hashes en una sola ejecución — aprende a organizar el fichero de entrada.
Hashes SHA-256 — guárdalos en
hashes/sha256.txt5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8
8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92
ef92b778bafe771e89245b89ecbc08a44a4e166c06659911881f383d4473e94f
Ataque con diccionario
$ hashcat -m 1400 -a 0 hashes/sha256.txt /usr/share/wordlists/rockyou.txt -o output/sha256_cracked.txt --force
💡 Consejo
Hashcat puede crackear miles de hashes simultáneamente casi con el mismo tiempo que uno solo, ya que el cuello de botella es generar las contraseñas candidatas, no el hashing. Junta todos los hashes del mismo tipo en un solo fichero.
Son contraseñas numéricas muy simples. Prueba también con ataque de máscara:
-a 3 ?d?d?d?d?d?d5e884898da... → password
8d969eef6e... → 123456
ef92b778ba... → password123
✓
04
▾
Los hashes NTLM se extraen del SAM o del NTDS.DIT en entornos Windows. Aprende a crackearlos, a distinguir LM vs NTLM y a usar reglas para mejorar la tasa de éxito.
ℹ️ Contexto — NTLM en pentesting
Tras volcar el SAM (secretsdump.py, mimikatz) obtienes líneas como:Administrator:500:aad3b435b51404eeaad3b435b51404ee:8846f7eaee8fb117ad06bdd830b7586c:::El hash NTLM es la parte después del tercer
: (32 chars).
Hashes NTLM — guárdalos en
hashes/ntlm.txt8846f7eaee8fb117ad06bdd830b7586c
31d6cfe0d16ae931b73c59d7e0c089c0
7a21990fcd3d759941e45c490f143d5f
Ataque diccionario con reglas best64
$ hashcat -m 1000 -a 0 hashes/ntlm.txt /usr/share/wordlists/rockyou.txt -r /usr/share/hashcat/rules/best64.rule --force
Ataque brute-force máscara (para el hash vacío)
# 31d6cfe0... es el hash NTLM de contraseña vacía!
$ hashcat -m 1000 -a 3 hashes/ntlm.txt "" --force
Uno de los hashes es especial:
31d6cfe0d16ae931b73c59d7e0c089c0 es el hash NTLM conocido de la contraseña vacía (cuenta deshabilitada o sin contraseña). Los otros dos están en rockyou.
8846f7eaee8fb117ad06bdd830b7586c → password
31d6cfe0d16ae931b73c59d7e0c089c0 → (vacía)
7a21990fcd3d759941e45c490f143d5f → 12345
✓
05
▾
bcrypt es deliberadamente lento. No se puede usar rockyou completo de forma práctica. Aprende a usar listas pequeñas y optimizadas para este tipo de hash.
⚠ bcrypt es muy lento
Con CPU, hashcat puede procesar ~100 hashes/seg con bcrypt cost 12. Rockyou tiene 14M contraseñas → ~40 horas. La estrategia es usar listas pequeñas y específicas.
Hash bcrypt — guárdalo en
hashes/bcrypt.txt$2a$05$LhayLxezLhK1LhWvKxCyLOj0j1u11cNgnkSpeSmfbznYSCJIYFEAu
Crear wordlist reducida de contraseñas comunes
$ head -n 1000 /usr/share/wordlists/rockyou.txt > wordlists/top1000.txt
# Alternativa: usar fasttrack.txt (~220 contraseñas muy comunes)
$ cat /usr/share/wordlists/fasttrack.txt
Ataque bcrypt con lista reducida
$ hashcat -m 3200 -a 0 hashes/bcrypt.txt wordlists/top1000.txt --force -w 1
Está en el top 10 de contraseñas más usadas del mundo. Aparece en las primeras líneas de cualquier diccionario.
$2a$05$LhayLxez... → password
✓
06
▾
Los usuarios suelen transformar palabras base añadiendo números, mayúsculas o caracteres especiales. Las reglas automatizan estas mutaciones. El ataque híbrido combina wordlist con máscara.
Hashes MD5 mutados — guárdalos en
hashes/mutados.txt3fc0a7acf087f549ac2b266baf94b8b1
4ef6a9c2a9f3e7e9d5b3dba6d1f5e4b2
f25a2fc72690b780b2a14e140ef6a9c2
Ataque con reglas best64 (mutaciones estándar)
$ hashcat -m 0 -a 0 hashes/mutados.txt /usr/share/wordlists/rockyou.txt -r /usr/share/hashcat/rules/best64.rule --force
Crear regla personalizada
$ cat >> rules/custom.rule <<EOF
# Añadir número al final
$1
$2
$123
$2024
$!
# Capitalizar primera letra
c
# Capitalizar + añadir número
c $1
c $123
EOF
Ataque híbrido: wordlist + máscara de dígitos (Modo -a 6)
# Wordlist + sufijo de 2 dígitos: palabra01, palabra23, etc.
$ hashcat -m 0 -a 6 hashes/mutados.txt /usr/share/wordlists/rockyou.txt ?d?d --force
# Wordlist + sufijo de 4 dígitos: password1234, admin2023, etc.
$ hashcat -m 0 -a 6 hashes/mutados.txt /usr/share/wordlists/rockyou.txt ?d?d?d?d --force
Las contraseñas son mutaciones de palabras comunes: una tiene un número al final, otra empieza con mayúscula, la tercera combina ambas.
3fc0a7acf087f549... → dragon1
4ef6a9c2a9f3e7e9... → Letmein
f25a2fc72690b780... → Admin123
✓
07
▾
Dado un handshake WPA2 capturado con airodump-ng, conviértelo al formato hccapx y atácalo con hashcat. Aprende el flujo completo de ataque Wi-Fi.
⚠ Aviso legal
Solo practica contra redes propias o en entornos de laboratorio autorizados. Capturar handshakes de redes ajenas es ilegal en la mayoría de jurisdicciones.
Paso 1 — Capturar handshake (para referencia)
# Poner la interfaz en modo monitor
$ airmon-ng start wlan0
# Capturar tráfico del AP objetivo
$ airodump-ng -c 6 --bssid AA:BB:CC:DD:EE:FF -w captura wlan0mon
# Desautenticar un cliente para forzar el handshake
$ aireplay-ng -0 1 -a AA:BB:CC:DD:EE:FF -c 11:22:33:44:55:66 wlan0mon
Paso 2 — Convertir .cap a .hccapx
# Método 1: herramienta cap2hccapx (incluida en hashcat-utils)
$ cap2hccapx captura.cap handshake.hccapx
# Método 2: online (para laboratorio)
# https://hashcat.net/cap2hashcat/
# Método 3: hcxtools (más moderno, genera .hc22000)
$ hcxpcapngtool -o handshake.hc22000 captura.pcapng
Paso 3 — Crackear el handshake
# Formato antiguo (.hccapx) → -m 2500
$ hashcat -m 2500 -a 0 handshake.hccapx /usr/share/wordlists/rockyou.txt --force
# Formato nuevo (.hc22000) → -m 22000
$ hashcat -m 22000 -a 0 handshake.hc22000 /usr/share/wordlists/rockyou.txt --force
# Con reglas para mayor cobertura
$ hashcat -m 22000 -a 0 handshake.hc22000 /usr/share/wordlists/rockyou.txt -r /usr/share/hashcat/rules/best64.rule --force
ℹ️ Para practicar sin capturar
Descarga handshakes de práctica de: github.com/brannondorsey/wifi-cracking o de los repositorios de CTF de HackTheBox/TryHackMe.
✓
08
▾
Los sistemas Linux almacenan contraseñas en /etc/shadow en formato sha512crypt ($6$). Aprende a extraerlas con unshadow y atacarlas con hashcat.
Extraer y preparar hashes del sistema (post-explotación)
# Una vez con acceso root o volcado del sistema:
$ unshadow /etc/passwd /etc/shadow > hashes/unshadowed.txt
# O extraer solo los hashes sha512crypt:
$ cat /etc/shadow | grep '\$6\$' | awk -F: '{print $2}' > hashes/shadow_hashes.txt
Hash sha512crypt de ejemplo — guárdalo en
hashes/shadow.txt$6$rounds=5000$usesomesillysalt$D4IrlXatmP7rx3P3InaxtnwvyN6bLHNVJmHMnhIcCCrTHJKbt7CfPKBCYvMDAmjB7QX5TMxmZ9MWrJ4IYFiO41
Ataque con rockyou.txt
$ hashcat -m 1800 -a 0 hashes/shadow.txt /usr/share/wordlists/rockyou.txt --force -w 3
Con fichero unshadow completo
$ hashcat -m 1800 -a 0 hashes/unshadowed.txt /usr/share/wordlists/rockyou.txt -r /usr/share/hashcat/rules/best64.rule --force
Este hash sha512crypt de ejemplo tiene una contraseña muy sencilla. La "salt" es visible:
usesomesillysalt. La contraseña es corta.$6$rounds=5000$usesomesillysalt$... → password
✓
09
▾
Cuando conoces la política de contraseñas (p.ej. "exactamente 8 caracteres, primera mayúscula, termina en 2 dígitos") puedes diseñar una máscara precisa y eficiente.
Hash MD5 — guárdalo en
hashes/mask_target.txte10adc3949ba59abbe56e057f20f883e
Máscara específica: 1 mayúscula + 5 minúsculas + 2 dígitos
# Formato: ?u?l?l?l?l?l?d?d
$ hashcat -m 0 -a 3 hashes/mask_target.txt ?u?l?l?l?l?l?d?d --force
Máscara incremental: probar longitudes 4-8 con solo dígitos
$ hashcat -m 0 -a 3 hashes/mask_target.txt ?d?d?d?d?d?d --increment --increment-min 4 --increment-max 8 --force
Máscara con charsets personalizados
# Definir charset1 = minúsculas + dígitos, charset2 = especiales limitados
$ hashcat -m 0 -a 3 hashes/mask_target.txt -1 ?l?d -2 !@# ?1?1?1?1?2?d?d?d --force
💡 Cuándo usar máscara vs wordlist
Usa máscara cuando conoces la política de contraseñas. Ejemplo: "mínimo 8 chars, al menos 1 mayúscula, 1 dígito" → diseña la máscara exacta. El espacio de búsqueda cae drásticamente.
Este hash corresponde a una secuencia numérica muy famosa. Prueba la máscara de solo dígitos con incremento.
e10adc3949ba59abbe56e057f20f883e → 123456
✓
10
▾
En un CTF real no te dicen el tipo de hash. Debes identificarlo, seleccionar el modo correcto en hashcat y adaptar la estrategia. Este ejercicio simula ese escenario con 5 hashes de tipos distintos.
ℹ️ Herramientas de identificación
hashid <hash> — lista posibles tipos con modo hashcat sugeridohash-identifier — alternativa interactivahashcat --example-hashes — ver formato de cada modo
5 hashes de tipos desconocidos — identifícalos tú
Hash A: 098f6bcd4621d373cade4e832627b4f6
Hash B: a94a8fe5ccb19ba61c4c0873d391e987982fbbd3
Hash C: b94f6f125c79e3a5ffaa826f584c10d52ada669e6762351386d77a119fbe1578
Hash D: $apr1$xyz12345$Kn4nZWQlFUOxHCfZx0f/r/
Hash E: $y$j9T$somerandombytes$hashvalue123456789
Paso 1 — Identificar cada hash
$ hashid 098f6bcd4621d373cade4e832627b4f6
$ hashid a94a8fe5ccb19ba61c4c0873d391e987982fbbd3
$ hashid b94f6f125c79e3a5ffaa826f584c10d52ada669e6762351386d77a119fbe1578
# Para los hashes con prefijo, el prefijo lo dice todo:
# $apr1$ → MD5-APR (modo 1600)
# $y$ → yescrypt (modo 25600, muy nuevo)
# $2a$ → bcrypt (modo 3200)
# $6$ → sha512crypt (modo 1800)
# $5$ → sha256crypt (modo 7400)
Paso 2 — Tabla de longitud → tipo de hash (referencia rápida)
# Hex puro (sin prefijo):
# 32 chars → MD5 (-m 0) o MD4 (-m 900) o NTLM (-m 1000)
# 40 chars → SHA1 (-m 100)
# 56 chars → SHA-224 (-m 1300)
# 64 chars → SHA-256 (-m 1400)
# 96 chars → SHA-384 (-m 10800)
# 128 chars → SHA-512 (-m 1700)
# Nota: MD5 y NTLM tienen la misma longitud, usar contexto (SAM → NTLM)
Paso 3 — Atacar cada hash con el modo correcto
# Hash A (MD5, 32 chars):
$ hashcat -m 0 -a 0 hashes/ctf_A.txt /usr/share/wordlists/rockyou.txt --force
# Hash B (SHA1, 40 chars):
$ hashcat -m 100 -a 0 hashes/ctf_B.txt /usr/share/wordlists/rockyou.txt --force
# Hash C (SHA-256, 64 chars):
$ hashcat -m 1400 -a 0 hashes/ctf_C.txt /usr/share/wordlists/rockyou.txt --force
# Hash D ($apr1$ → MD5-APR modo 1600):
$ hashcat -m 1600 -a 0 hashes/ctf_D.txt /usr/share/wordlists/rockyou.txt --force
Comando para ver todos los modos disponibles con ejemplos
$ hashcat --example-hashes | grep -A2 "MODE:" | head -100
# Buscar un modo específico por nombre:
$ hashcat --example-hashes | grep -i "ntlm"
Usa la longitud como primera pista. Los prefijos
$apr1$, $y$, $2a$ te dicen directamente el tipo. Para los hex puro, cuenta los caracteres y consulta la tabla de longitudes.
Hash A (32 chars) → MD5 (-m 0) → contraseña: test
Hash B (40 chars) → SHA1 (-m 100) → contraseña: test
Hash C (64 chars) → SHA-256 (-m 1400)
Hash D ($apr1$) → MD5-APR (-m 1600)
Hash E ($y$) → yescrypt (-m 25600)
Cheatsheet final
Flujo completo de cracking
## 1. Identificar el hash
$ hashid <hash>
## 2. Ataque rápido con diccionario
$ hashcat -m <modo> -a 0 hashes.txt rockyou.txt --force
## 3. Si no encuentra: añadir reglas
$ hashcat -m <modo> -a 0 hashes.txt rockyou.txt -r best64.rule --force
## 4. Si no encuentra: híbrido wordlist+máscara
$ hashcat -m <modo> -a 6 hashes.txt rockyou.txt ?d?d?d?d --force
## 5. Si conoces patrón: máscara directa
$ hashcat -m <modo> -a 3 hashes.txt ?u?l?l?l?l?l?d?d --force
## 6. Ver resultados
$ hashcat -m <modo> hashes.txt --show