Crunch — Diccionarios Personalizados

📝

¿Qué es Crunch?

Generador de wordlists para auditorías de seguridad autorizadas

Crunch es una herramienta de línea de comandos para Linux que genera listas de palabras (wordlists / diccionarios) de forma sistemática. Es una de las herramientas más utilizadas en auditorías de seguridad para pruebas de contraseñas en redes Wi-Fi, servicios web y aplicaciones, siempre dentro de entornos autorizados y controlados.

A diferencia de diccionarios genéricos como rockyou.txt, Crunch permite crear wordlists personalizadas y específicas: si en una auditoría sabes que las contraseñas siguen un patrón concreto (ej: nombre + año + símbolo), puedes generar exactamente ese conjunto en lugar de millones de combinaciones irrelevantes.

Características principales:

Genera combinaciones de longitud mínima a máxima definida
Permite usar conjuntos de caracteres personalizados (charset)
Soporta patrones con placeholders para posiciones fijas
Puede procesar palabras base y generar sus variaciones
Salida directa a archivo o por pipe a otra herramienta (hashcat, aircrack-ng)
Control del tamaño del archivo de salida para dividir en partes

⚠ USO ÉTICO Y LEGALCrunch se usa exclusivamente en sistemas propios o con permiso escrito explícito del propietario. Su uso no autorizado contra redes o servicios de terceros es ilegal. Este manual es material educativo para certificaciones de ethical hacking (CEH, OSCP, eJPT) y práctica en entornos de laboratorio.

🔧¿CUÁNDO ES ÚTIL UN DICCIONARIO PERSONALIZADO?

Escenario de auditoría	Información conocida	Ventaja de Crunch
Wi-Fi corporativa	Contraseña es nombre empresa + 4 dígitos	Genera solo las combinaciones relevantes
Sistema de empleados	Política: 8 chars, mayúscula + número al final	Patrón con `-t` reduce billones a miles
Router doméstico	PIN de fondo de 8 dígitos	Genera exactamente 10^8 combinaciones de dígitos
Hash capturado	Contraseña mín. 6, máx. 8, solo alfanumérico	Charset reducido = 40x menos intentos que generar todo

⚙

Instalación de Crunch

Disponible en Kali, Parrot, Ubuntu y Debian

Instalar Crunch

# En Kali Linux / Parrot OS (ya viene preinstalado en Kali)
sudo apt update && sudo apt install crunch -y

# En Ubuntu / Debian
sudo apt install crunch -y

# Verificar instalaci&oacute;n y ver la ayuda
crunch --help
crunch 2>&1 | head -30

# Ver la versi&oacute;n
crunch 2>&1 | grep -i version

Estructura de directorios de Crunch

# Crunch incluye archivos de charset predefinidos en:
ls /usr/share/crunch/

# Archivos principales:
# charset.lst   -- conjuntos de caracteres predefinidos
# readme.txt    -- documentaci&oacute;n breve

cat /usr/share/crunch/charset.lst | head -30

📌 CRUNCH EN KALIEn Kali Linux, Crunch viene preinstalado y los archivos de charset están en /usr/share/crunch/charset.lst. En otras distribuciones, los archivos pueden instalarse en /usr/share/doc/crunch/.

📄

Sintaxis Básica de Crunch

Estructura del comando y parámetros esenciales

La sintaxis de Crunch es siempre la misma estructura base:

crunch <min> <max> [charset] [opciones] min -- Longitud mínima de cada palabra generada max -- Longitud máxima de cada palabra generada charset -- Caracteres a usar (opcional; default: abcdefghijklmnopqrstuvwxyz) opciones -- -o archivo, -t patrón, -p palabras, etc.

Ejemplos de la estructura:

Ejemplos de sintaxis

# Generar todas las combinaciones de 4 letras min&uacute;sculas
crunch 4 4

# Generar combinaciones de 3 a 5 caracteres usando solo d&iacute;gitos
crunch 3 5 0123456789

# Generar con charset personalizado y guardar en archivo
crunch 6 8 abcABC123 -o /tmp/wordlist.txt

# Generar con un patr&oacute;n espec&iacute;fico (@ = min&uacute;scula, , = may&uacute;scula, % = d&iacute;gito)
crunch 8 8 -t admin%%@

# Ver progreso en tiempo real (con -u suprimimos el porcentaje)
crunch 4 4 abc -o /tmp/test.txt

💡 CÁLCULO DEL TAMAÑO ANTES DE GENERARAntes de ejecutar Crunch, calcula cuántas combinaciones generarás: charset_size ^ longitud. Por ejemplo, 26 letras con longitud 6 = 26^6 = ~309 millones de combinaciones. Crunch muestra el tamaño estimado antes de generar, ¡úsalo!

🔤

Sets de Caracteres (Charsets)

Definir qué caracteres se usarán en cada posición

🔤CHARSETS DISPONIBLES EN /usr/share/crunch/charset.lst

Nombre	Caracteres	Uso típico
`lalpha`	a-z (26)	Contraseñas solo minúsculas
`ualpha`	A-Z (26)	Contraseñas solo mayúsculas
`mixalpha`	a-z + A-Z (52)	Contraseñas alfabéticas mixtas
`numeric`	0-9 (10)	PINs y códigos numéricos
`lalpha-numeric`	a-z + 0-9 (36)	Alfanumérico minúsculo
`ualpha-numeric`	A-Z + 0-9 (36)	Alfanumérico mayúsculo
`mixalpha-numeric`	a-z + A-Z + 0-9 (62)	Alfanumérico completo
`mixalpha-numeric-all-space`	Todos + espacio (95)	Contraseñas con espacio

Usar charsets predefinidos con -f

# -f especifica el archivo y el nombre del charset
crunch 4 6 -f /usr/share/crunch/charset.lst mixalpha-numeric

# Solo d&iacute;gitos (equivalente a: crunch 4 4 0123456789)
crunch 4 4 -f /usr/share/crunch/charset.lst numeric

# Alfanum&eacute;rico completo de 8 caracteres
crunch 8 8 -f /usr/share/crunch/charset.lst mixalpha-numeric -o /tmp/alphanum8.txt

Definir charset directamente en el comando

# Charset personalizado directamente en la l&iacute;nea de comandos
# Basta con poner los caracteres como tercer argumento

# Solo min&uacute;sculas y d&iacute;gitos
crunch 6 6 abcdefghijklmnopqrstuvwxyz0123456789

# Solo vocales + n&uacute;meros (charset muy reducido)
crunch 4 4 aeiou0123456789

# Caracteres especiales incluidos (entre comillas si hay espacios/meta)
crunch 8 8 'abcABC123!@#$'

📝

Ejercicio 1 — Primera Wordlist: Combinaciones Simples

Objetivo: generar las primeras wordlists y entender la salida de Crunch

Generar todas las combinaciones de 4 dígitosMÍNIMO VIÁBLE

Wordlist de 4 dígitos (PINs)

# Genera todos los PINs de 4 d&iacute;gitos: 0000 hasta 9999
crunch 4 4 0123456789

# Crunch mostrar&aacute; antes de generar:
# Crunch will now generate the following amount of data: 50000 bytes
# 0 MB
# 0 GB
# 0 TB
# 0 PB
# Crunch will now generate the following number of lines: 10000

# Salida:
# 0000
# 0001
# 0002
# ...
# 9999

💡 Crunch siempre muestra el tamaño estimado ANTES de generar. Revisa este dato antes de ejecutar para evitar generar archivos de cientos de GB por error.

Generar combinaciones de letras de 2 a 3 caracteresRANGO DE LONGITUD

Wordlist de 2 a 3 letras minúsculas

# min=2, max=3, charset=letras min&uacute;sculas (default)
crunch 2 3

# Esto genera:
# aa, ab, ac... az (26)
# ba, bb... zz (676)
# aaa, aab... zzz (17576)
# Total: 26 + 676 + 17576 = 18278 palabras

# Para ver cuantas palabras generar&iacute;a SIN generarlas realmente:
# No hay opci&oacute;n nativa, pero puedes redirigir a wc -l:
crunch 2 3 2>/dev/null | wc -l

Entender la salida y el progresoCOMPRENSIÓN

Seguir el progreso de generación

# Para listas grandes crunch muestra % de progreso
# Ejemplo con lista m&aacute;s grande:
crunch 4 4 abcdefghijklmnopqrstuvwxyz

# Salida esperada antes de generar:
# Crunch will now generate the following amount of data: 2641807360 bytes
# 2519 MB
# 2 GB
# ...
# Crunch will now generate the following number of lines: 456976

# &iexcl;PRECAUCI&Oacute;N! Con charset grande y longitud alta
# el tama&ntilde;o puede ser de TBs. Siempre rev&iacute;salo primero.

❓ Ejercicio práctico

Genera una wordlist con todos los PINs de 6 dígitos (como los que usan muchos móviles). ¿Cuántas combinaciones serán? ¿Cuánto espacio en disco ocupa aproximadamente?

💡 Pista: 6 dígitos, solo números del 0 al 9. Cada línea son 6 caracteres + salto de línea = 7 bytes.

Ver solución

crunch 6 6 0123456789 --- Combinaciones: 10^6 = 1.000.000 --- Tamaño: 1.000.000 x 7 bytes = 7.000.000 bytes ≈ 6.7 MB --- Crunch lo confirmará con el mensaje antes de generar.

📂

Ejercicio 2 — Guardar en Archivo con -o

Objetivo: guardar la wordlist en un fichero para usarla con otras herramientas

Guardar en un archivo con -oGUARDAR

Opción -o: guardar en archivo

# Guardar la wordlist en un archivo de texto
crunch 4 4 0123456789 -o /tmp/pines4.txt

# Verificar que se cre&oacute;
wc -l /tmp/pines4.txt
# Resultado: 10000 /tmp/pines4.txt

head -5 /tmp/pines4.txt
# 0000
# 0001
# 0002
# 0003
# 0004

tail -5 /tmp/pines4.txt
# 9995
# 9996
# 9997
# 9998
# 9999

Dividir en múltiples archivos con -bDIVIDIR POR TAMAÑO

Opción -b: dividir por tamaño

# -b divide la salida en archivos del tama&ntilde;o especificado
# &Uacute;til cuando la lista total es muy grande

# Dividir en archivos de 10MB
crunch 6 6 abcdefghijklmnopqrstuvwxyz -b 10mb -o START

# Opciones de tama&ntilde;o:
# -b 100kb    -- 100 kilobytes
# -b 50mb     -- 50 megabytes
# -b 1gb      -- 1 gigabyte
# -b 500000   -- 500000 l&iacute;neas (usando n&uacute;mero entero)

# El nombre START hace que crunch nombre los archivos
# autom&aacute;ticamente: aaaaaa-aaaaaz.txt, aaabaa-aaabaz.txt...

# Ver los archivos generados
ls -lh *.txt

Redirigir directamente a otra herramienta con pipePIPELINE

Pipe directo a aircrack-ng o hashcat

# Sin guardar en disco: pasar directamente a otra herramienta
# Esto ahorra espacio en disco y es m&aacute;s r&aacute;pido

# Crunch -> aircrack-ng (auditor&iacute;a WPA en entorno propio)
crunch 8 8 0123456789 | aircrack-ng -w - -b AA:BB:CC:DD:EE:FF captura.cap

# Crunch -> hashcat (cracking de hashes en entorno de pr&aacute;ctica)
crunch 6 6 abc123 | hashcat -m 0 hash.txt

# Crunch -> wc para contar sin guardar
crunch 5 5 0123456789 2>/dev/null | wc -l

❓ Ejercicio práctico

Genera una wordlist de contraseñas de 8 caracteres alfanuméricos (a-z, 0-9) y gúardala en /tmp/alpha8.txt. Luego muestra las primeras y últimas 3 líneas y el número total.

💡 Pista: charset = letras minúsculas + dígitos = 36 caracteres. Revisa el tamaño ANTES de ejecutar.

Ver solución

crunch 8 8 abcdefghijklmnopqrstuvwxyz0123456789 -o /tmp/alpha8.txt --- head -3 /tmp/alpha8.txt --- tail -3 /tmp/alpha8.txt --- wc -l /tmp/alpha8.txt --- NOTA: esto son 36^8 = 2.821.109.907.456 combinaciones (~2.8 billones), unos 22TB. En clase usar min=3 max=3 para practicar la sintaxis sin llenar el disco.

🎲

Ejercicio 3 — Patrones con -t (la opción más poderosa)

Objetivo: generar wordlists con partes fijas y partes variables

La opción -t es la más útil de Crunch. Permite definir un patrón donde algunas posiciones son fijas y otras varían. Esto reduce drásticamente el número de combinaciones cuando conoces parte del formato de la contraseña.

🎲TABLA DE PLACEHOLDERS PARA -t

Placeholder	Representa	Charset usado
`@`	Carácter variable minúsculo	a-z
`,`	Carácter variable mayúsculo	A-Z
`%`	Carácter variable numérico	0-9
`^`	Carácter variable especial	!@#$%^&*()-_+=...
Cualquier otro	Carácter fijo (literal)	Ese carácter exacto

Patrón con texto fijo y números variablesBÁSICO

Contraseñas con prefijo fijo

# Genera: admin0000, admin0001, ... admin9999
crunch 9 9 -t admin%%%%

# Genera: pass000, pass001, ... pass999
crunch 7 7 -t pass%%%

# Genera: user_a, user_b, ... user_z
crunch 6 6 -t user_@

# Los min y max deben coincidir con la longitud del patr&oacute;n
# admin%%%% = 9 caracteres -> crunch 9 9

Combinar mayúsculas, minúsculas y númerosCOMPLEJO

Patrones con múltiples tipos de caracteres

# Primera letra may&uacute;scula + 5 min&uacute;sculas + 2 n&uacute;meros
# Ej: Abcdef12, Xyzabc99, etc.
crunch 8 8 -t ,@@@@@%%

# Nombre de 4 letras + a&ntilde;o (2020-2029)
crunch 8 8 -t @@@@202%

# Estructura: 3 letras + guion + 4 n&uacute;meros
# Ej: abc-1234, xyz-9999
crunch 8 8 -t @@@-%%%%

# Contrase&ntilde;as tipo: P@ssw0rd (patr&oacute;n corporativo com&uacute;n)
# Letra fija + car. especial + texto fijo + d&iacute;gito
crunch 8 8 -t ,^ss%%%@

Contraseñas con nombres propios + númerosCASO REAL

Patrón: nombre propio + año

# Escenario: usuario usa su nombre + a&ntilde;o de nacimiento
# Nombre conocido: 'carlos', variamos el a&ntilde;o (1970-1999)

# carlos1970, carlos1971, ... carlos1999
crunch 10 10 -t carlos19%%

# Variaci&oacute;n con may&uacute;scula inicial
# Carlos1970, Carlos1971...
crunch 10 10 -t Carlos19%%

# A&ntilde;os 2000-2009
crunch 10 10 -t carlos200%

# Combinado: nombre + punto + n&uacute;meros
# carlos.1234, carlos.5678...
crunch 11 11 -t carlos.%%%%

❓ Ejercicio práctico

Una empresa tiene la política de que las contraseñas deben empezar con mayúscula, seguida de 4 minúsculas, y terminar en 2 dígitos (total 7 caracteres). Genera la wordlist con ese patrón.

💡 Pista: Placeholder mayúscula = , (coma), minúsculas = @ y números = %

Ver solución

crunch 7 7 -t ,@@@@%% --- Esto genera: Aaaaa00, Aaaaa01... Zzzzz99 --- Total: 26 x 26^4 x 10^2 = 26^5 x 100 = 11.881.376 combinaciones

🔢

Ejercicio 4 — Charset Personalizado con -t y -p

Objetivo: definir exactamente qué caracteres va en cada posición del patrón

Con -t los placeholders usan sus charsets por defecto. Pero podemos cambiar exactamente qué caracteres reemplaza cada placeholder usando los argumentos adicionales del comando.

Cambiar el charset de los placeholders

# La sintaxis completa cuando se usa -t con charsets personalizados:
# crunch min max -t patr&oacute;n
# El charset que escribe va como argumento antes de -t

# Generar con charset espec&iacute;fico para los '@':
# (s&oacute;lo vocales min&uacute;sculas en posiciones @)
crunch 4 4 aeiou -t @@@@

# Solo n&uacute;meros pares en posiciones de '%'
# Truco: define el charset como s&oacute;lo n&uacute;meros pares
# No es nativo con %, pero podemos usar el charset directamente
crunch 4 4 02468 -t %%%%

# Caracteres espec&iacute;ficos en todas las posiciones
# Solo: a, b, c, 1, 2, 3
crunch 6 6 abc123 -t @@@@@@

Charset personalizado para auditoría específica

# Caso: El objetivo usa contrase&ntilde;as s&oacute;lo con teclado espa&ntilde;ol
# sin &ntilde;, s&oacute;lo letras y n&uacute;meros, longitud 6-8
crunch 6 8 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'

# Caso: Red Wi-Fi de peque&ntilde;a empresa
# Saben que usa s&oacute;lo n&uacute;meros y letras minus (sin especiales)
# y longitud exacta de 8
crunch 8 8 abcdefghijklmnopqrstuvwxyz0123456789 -o /tmp/wifi_audit.txt

# Caso: Aplicaci&oacute;n que s&oacute;lo acepta hex (0-9, a-f)
crunch 8 8 0123456789abcdef -o /tmp/hex_words.txt

❓ Ejercicio práctico

Genera una wordlist de PINs de 4 dígitos pero solo con dígitos del 1 al 6 (como en un dado). Guárdala en /tmp/dado.txt y cuenta cuántas combinaciones hay.

💡 Pista: charset = '123456', longitud = 4 fija.

Ver solución

crunch 4 4 123456 -o /tmp/dado.txt --- wc -l /tmp/dado.txt --- Total: 6^4 = 1296 combinaciones

⛰

Ejercicio 5 — Palabras Base con -p (permutaciones)

Objetivo: generar todas las permutaciones de un conjunto de palabras o caracteres

La opción -p es diferente al resto: en lugar de generar combinaciones caractér a carácter, genera permutaciones de palabras o caracteres completos. Muy útil cuando conoces los «componentes» de la contraseña pero no el orden.

Permutaciones de palabras conocidas

# -p seguido de palabras separadas por espacio
# Genera todas las permutaciones posibles de esas palabras

# Permutaciones de 3 palabras: nombre, a&ntilde;o, empresa
crunch 1 1 -p nombre 2023 empresa
# Genera:
# empresa2023nombre
# empresa nombre2023
# nombre2023empresa
# nombre empresa2023
# 2023empresanombre
# 2023nombreempresa

# Con 2 componentes
crunch 1 1 -p admin 123
# admin123 y 123admin

Permutaciones de caracteres individuales

# -p con caracteres sin espacios = permutaciones de esos chars
# Genera todas las permutaciones de los 4 caracteres dados

# Permutaciones de: a, b, 1, 2
crunch 1 1 -p ab12
# Genera: ab12, ab21, a1b2, a12b, a21b, a2b1
#         ba12, ba21, b1a2, b12a, b21a, b2a1...
# (4! = 24 permutaciones)

# Caso real: sabemos que la clave contiene estos 4 d&iacute;gitos
# pero no sabemos el orden
crunch 1 1 -p 4827 -o /tmp/pin_permut.txt
# Genera todas las ordenaciones de 4,8,2,7 (24 combinaciones)

Combinar -p con -t para máximo control

# Escenario: la contrase&ntilde;a es una de varias palabras conocidas
# m&aacute;s un sufijo num&eacute;rico de 2 d&iacute;gitos

# Primero generamos las palabras base con -p
crunch 1 1 -p carlos antonio maria > /tmp/nombres.txt

# Luego a&ntilde;adimos sufijos con un bucle de bash
while read nombre; do
    crunch 2 2 0123456789 | sed "s/^/$nombre/"
done < /tmp/nombres.txt > /tmp/nombres_con_sufijo.txt

# O m&aacute;s eficiente: usar hashcat con reglas o piping

❓ Ejercicio práctico

Tenemos información de que la contraseña de un sistema de práctica contiene las palabras 'ghost', 'hack' y '2024' pero no sabemos el orden. Genera todas las permutaciones posibles.

💡 Pista: Usa -p con las tres palabras separadas por espacios.

Ver solución

crunch 1 1 -p ghost hack 2024 --- Genera 3! = 6 permutaciones: --- ghost hack2024, ghost2024hack, hack ghost2024, hack2024ghost, 2024ghosthack, 2024hackghost

📊

Ejercicio 6 — Control de Tamaño y Optimización

Objetivo: gestionar el tamaño de las wordlists y optimizar para auditorías reales

Limitar el número de caracteres por línea con -l

# -l permite especificar un literal para -t
# (caracteres que NO se iterar&aacute;n aunque sean placeholder)
# Esta opci&oacute;n fija algunos placeholders como literales

# Ejemplo: fijar la @ como literal (no iterar)
# -l @@-@@@@ junto con -t 
crunch 8 8 -t @@-@@@@ -l @@-@@@@
# Genera: ab-cdef donde los guiones son fijos y las @ iteran

Empezar desde una palabra concreta con -s

# -s indica por d&oacute;nde empezar la generaci&oacute;n
# &Uacute;til para reanudar una generaci&oacute;n interrumpida

# Empezar desde 'pass0500' en vez de 'pass0000'
crunch 8 8 -t pass%%%% -s pass0500

# Empezar desde una combinaci&oacute;n espec&iacute;fica
crunch 6 6 abc123 -s b12aaa

# Muy &uacute;til para dividir la generaci&oacute;n entre varios equipos:
# Equipo 1: 0000-4999
crunch 8 8 -t admin%%%% -s admin0000 | head -5000 > parte1.txt
# Equipo 2: 5000-9999
crunch 8 8 -t admin%%%% -s admin5000 > parte2.txt

Excluir patrones con -d (no duplicar caracteres consecutivos)

# -d evita que el mismo car&aacute;cter aparezca m&aacute;s de N veces seguidas
# &Uacute;til para reducir listas y hacerlas m&aacute;s 'humanas'

# M&aacute;ximo 2 caracteres iguales consecutivos
crunch 4 4 abc -d 2@
# Genera: aabc, aacb... pero NO aaab (3 'a' seguidas)

# Sin car&aacute;cteres repetidos consecutivos (m&aacute;x 1)
crunch 4 4 abc -d 1@
# No genera: aabc, abbc, etc.

❓ Ejercicio práctico

Necesitas generar las combinaciones de PIN de 6 dígitos que empiecen desde '500000'. Genera las últimas 500000 combinaciones (500000-999999) y guárdalas en /tmp/pin_parte2.txt.

💡 Pista: Usa -s para especificar el punto de inicio y -o para guardar.

Ver solución

crunch 6 6 0123456789 -s 500000 -o /tmp/pin_parte2.txt --- Genera desde 500000 hasta 999999 = 500000 combinaciones

🌎

Ejercicio 7 — Diccionarios Especializados para Redes

Objetivo: crear wordlists optimizadas para auditorías Wi-Fi WPA/WPA2 en entornos propios

⚠ ÚSO EXCLUSIVAMENTE EN REDES PROPIASLos siguientes ejemplos son para auditar tu propia red Wi-Fi o una red con permiso escrito del propietario. El acceso no autorizado a redes Wi-Fi ajenas es un delito penal. Estos ejercicios se realizan en laboratorio con un router propio.

WPA2: contraseñas mínimo 8 caracteresREQUISITO WPA

Wordlist para auditoría WPA2 propia

# WPA2 requiere m&iacute;nimo 8 caracteres
# Generamos solo combinaciones de 8 d&iacute;gitos (PINs de router)
crunch 8 8 0123456789 -o /tmp/wpa_pines8.txt

# Contrase&ntilde;as alfanum&eacute;ricas min&uacute;sculas de 8 chars
crunch 8 8 abcdefghijklmnopqrstuvwxyz0123456789 -o /tmp/wpa_alpha8.txt

# Patr&oacute;n t&iacute;pico ISP espa&ntilde;ol: 4 letras may&uacute;sculas + 4 d&iacute;gitos
crunch 8 8 -t ,,,,%%%% -o /tmp/wpa_isp.txt

# Patr&oacute;n: nombre red (conocido) + 4 d&iacute;gitos
# Ejemplo: si el SSID es 'MiFibra' y sospechamos 'MiFibra' + n&uacute;meros
crunch 11 11 -t MiFibra%%%% -o /tmp/mifibra_audit.txt

Combinar Crunch directamente con aircrack-ngPIPELINE

Crunch + aircrack-ng sin fichero intermedio

# Capturar el handshake WPA primero (con tu propio router en modo monitor)
# Luego auditar sin guardar la wordlist en disco:

# Modo 1: pipe directo
crunch 8 8 0123456789 | aircrack-ng -w - -b AA:BB:CC:DD:EE:FF handshake.cap

# Modo 2: con patr&oacute;n
crunch 8 8 -t ,,,,%%%% | aircrack-ng -w - -b AA:BB:CC:DD:EE:FF handshake.cap

# Ventaja: no se escribe nada en disco, va directo a la GPU/CPU
# de aircrack-ng reduciendo el I/O

Generar wordlist para routers por marcaWORDLISTS ESPECÍFICAS

Patrones comunes de routers domésticos (en red propia)

# Algunos modelos usan patrones conocidos como contrase&ntilde;a por defecto
# Esto es &uacute;til para verificar si TU router tiene la clave por defecto

# Movistar/Mitrastar: 10 d&iacute;gitos
crunch 10 10 0123456789 -o /tmp/movistar_default.txt

# Jazztel/Sagemcom: letras may&uacute;sculas + n&uacute;meros, 10 chars
crunch 10 10 -t ,,,,%%%%%  -o /tmp/jazztel_default.txt

# Vodafone: patr&oacute;n hex 10 chars
crunch 10 10 0123456789abcdef -o /tmp/vodafone_hex.txt

# Nota: siempre cambia la clave por defecto de tu router!

❓ Ejercicio práctico

Quieres auditar la contraseña de tu propio router que sospechas sigue el patrón: 4 letras mayúsculas seguidas de 4 dígitos. Genera la wordlist y múestrala por pantalla (sin guardar) para ver si es viable.

💡 Pista: Usa -t con mayusculas = , y numeros = %. Calcula primero: 26^4 x 10^4 = ?

Ver solución

crunch 8 8 -t ,,,,%%%%% --- Nota: son 26^4 = 456976 mayusculas x 10^4 = 10000 digitos = ~4.570 millones de combinaciones. Es muy grande. Mejor acotar el patrón o usar crunch 8 8 -t ,,,,%%%% | aircrack-ng directamente.

🛠

Ejercicio 8 — Crunch con Hashcat y Flujo Completo

Objetivo: integrar Crunch con Hashcat para auditoría de hashes en entorno de práctica

🎓 ENTORNO DE PRÁCTICAEste ejercicio se realiza con hashes creados por ti mismo en un entorno de laboratorio. Hashcat es una herramienta legal para recuperación de contraseñas en sistemas propios y auditorías autorizadas.

Crear un hash de prácticaPREPARACIÓN

Crear hash MD5 para practicar

# Crear un hash MD5 de una contrase&ntilde;a conocida para practicar
echo -n 'admin2024' | md5sum
# Resultado: a7c4d5f2... (hash)

# Guardar el hash en un archivo
echo -n 'admin2024' | md5sum | cut -d' ' -f1 > /tmp/hash_practica.txt
cat /tmp/hash_practica.txt

# Crear hash SHA1
echo -n 'admin2024' | sha1sum | cut -d' ' -f1 > /tmp/hash_sha1.txt

# Con Python (m&aacute;s preciso, sin el salto de l&iacute;nea)
python3 -c "import hashlib; print(hashlib.md5('admin2024'.encode()).hexdigest())"

Crunch + Hashcat en pipelineAUDITORÍA

Crunch directo a Hashcat sin archivo intermedio

# Instalar hashcat si no est&aacute; disponible
# sudo apt install hashcat

# M&oacute;dulos de hashcat comunes:
# -m 0    = MD5
# -m 100  = SHA1
# -m 1000 = NTLM (Windows)
# -m 2500 = WPA/WPA2

# Crunch -> Hashcat para MD5 (ejemplo pr&aacute;ctica)
crunch 9 9 -t admin%%%% | hashcat -m 0 /tmp/hash_practica.txt --stdin

# Crunch -> Hashcat SHA1
crunch 7 9 abcdefghijklmnopqrstuvwxyz0123456789 | hashcat -m 100 /tmp/hash_sha1.txt --stdin

# Ver resultados de hashcat
hashcat -m 0 /tmp/hash_practica.txt --show

Flujo completo: captura -> diccionario -> auditoríaFLUJO COMPLETO

Pipeline completo documentado

#!/bin/bash
# ===============================================
# FLUJO DE AUDITOR&Iacute;A WPA2 (SOLO EN RED PROPIA)
# GhostAcademy - unfantasmaenelsistema.com
# ===============================================

SSID="MiRedPropia"
BSSID="AA:BB:CC:DD:EE:FF"
IFACE="wlan0"
CAPTURA="/tmp/handshake"

# 1. Poner interfaz en modo monitor
echo "[*] Activando modo monitor..."
airmon-ng start $IFACE

# 2. Escanear redes (ctrl+C cuando veas la tuya)
airodump-ng wlan0mon

# 3. Capturar handshake
airodump-ng --bssid $BSSID -c 6 -w $CAPTURA wlan0mon

# 4. (En otra terminal) Enviar deauth para forzar reautenticaci&oacute;n
aireplay-ng -0 1 -a $BSSID wlan0mon

# 5. Generar diccionario y atacar el handshake (sin guardar)
echo "[*] Iniciando ataque con Crunch..."
crunch 8 8 -t ,,,,%%%%%  | aircrack-ng -w - -b $BSSID ${CAPTURA}*.cap

# 6. Restaurar interfaz
airmon-ng stop wlan0mon

🔧

Referencia: Tabla Completa de Parámetros

Todos los parámetros de Crunch con descripción y ejemplo

Parámetro	Descripción	Ejemplo
`min`	Longitud mínima de las palabras (primer argumento)	`crunch 4 ...`
`max`	Longitud máxima de las palabras (segundo argumento)	`crunch 4 8 ...`
`charset`	Caracteres a usar (tercer argumento, opcional)	`crunch 4 4 abc123`
`-o archivo`	Guardar salida en archivo (en lugar de stdout)	`-o /tmp/lista.txt`
`-b tamaño`	Dividir en archivos del tamaño indicado	`-b 50mb`
`-t patrón`	Definir patrón con placeholders (@,%,,,^)	`-t admin%%%%`
`-l literal`	Tratar ciertos placeholders como literales fijos	`-l @@-@@`
`-f archivo charset`	Usar charset predefinido del archivo charset.lst	`-f /usr/share/crunch/charset.lst mixalpha`
`-p palabras`	Generar permutaciones de las palabras indicadas	`-p word1 word2 word3`
`-s inicio`	Empezar la generación desde esta palabra	`-s aaaaaa`
`-e fin`	Terminar la generación en esta palabra	`-e zzzzzz`
`-d N@`	Limitar repeticiones consecutivas de minúsculas	`-d 2@`
`-d N,`	Limitar repeticiones consecutivas de mayúsculas	`-d 2,`
`-d N%`	Limitar repeticiones consecutivas de dígitos	`-d 2%`
`-i`	Invertir la salida (escribe en orden inverso)	`crunch 4 4 -i`
`-q archivo`	Usar palabras del archivo como "componentes" de permutación	`-q palabras.txt`
`-u`	Desactivar la barra de progreso (modo silencioso)	`crunch 4 4 -u -o lista.txt`
`-z tipo`	Comprimir la salida (gzip, bzip2, lzma, 7z)	`-z gzip -o lista.txt`

🎲

Tabla de Placeholders para -t

Referencia rápida de los wildcards del parámetro -t

Placeholder	Tipo	Charset por defecto	Ejemplo generado
`@`	Variable minúscula	a-z (26 chars)	admin@ → admina, adminb... adminz
`,` (coma)	Variable mayúscula	A-Z (26 chars)	,dmin → Admin, Bdmin... Zdmin
`%`	Variable numérica	0-9 (10 chars)	pass% → pass0, pass1... pass9
`^`	Variable especial	!@#$%^&*()... (33 chars)	pass^ → pass!, pass@... pass/
Cualquier otro char	Literal fijo	Ese carácter exacto	a@bc → aabc, abbc... azbc

💡EJEMPLOS RÁPIDOS DE PATRONES COMUNES

Patrones de contraseñas corporativas comunes

# Patr&oacute;n: May&uacute;scula + 6 min&uacute;sculas + 2 d&iacute;gitos (p.ej: Empresa01)
crunch 9 9 -t ,@@@@@@%%

# Patr&oacute;n: 4 letras + 4 d&iacute;gitos (p.ej: test1234)
crunch 8 8 -t @@@@%%%%

# Patr&oacute;n: Nombre 5 chars + a&ntilde;o 4 d&iacute;gitos (p.ej: maria2024)
crunch 9 9 -t @@@@@%%%%

# Patr&oacute;n: prefijo fijo + 4 d&iacute;gitos (p.ej: empresa0000)
crunch 12 12 -t empresa%%%%

# Patr&oacute;n: contrase&ntilde;a con ! al final (muy com&uacute;n: Abc1234!)
crunch 8 8 -t ,@@%%%%^

# Solo pines de 4 d&iacute;gitos (ya lo sabemos pero como patr&oacute;n)
crunch 4 4 -t %%%%

⚡

Optimización y Consejos Prácticos

Cómo usar Crunch eficientemente en auditorías reales

⚡CALCULAR EL TAMAÑO ANTES DE GENERAR

Fórmula de tamaño y script de estimación

# F&oacute;rmula:
# N&uacute;mero de combinaciones = charset_size ^ longitud
# Tama&ntilde;o en bytes ≈ combinaciones * (longitud + 1)  [+1 por salto de l&iacute;nea]

# Calculadora r&aacute;pida en bash:
charset_size=36    # a-z + 0-9
longitud=8
combinaciones=$(python3 -c "print($charset_size ** $longitud)")
tamano_bytes=$(python3 -c "print($charset_size ** $longitud * ($longitud + 1))")
tamano_gb=$(python3 -c "print(round($charset_size ** $longitud * ($longitud + 1) / 1e9, 2))")

echo "Combinaciones: $combinaciones"
echo "Tama&ntilde;o estimado: ${tamano_gb} GB"

# Regla pr&aacute;ctica:
# 8 chars, 36 charset = ~2.8 BILLONES = ~22 GB (inviable sin pipe)
# 8 chars, 10 charset = 100 millones = ~700 MB (manejable)
# 4 chars, 36 charset = 1.7 millones = ~13 MB (r&aacute;pido)

📈COMPRIMIR LA SALIDA CON -z

Comprimir wordlist para ahorrar espacio

# Generar comprimido en gzip (hasta 3-5x menos espacio)
crunch 8 8 0123456789 -z gzip -o /tmp/pines.txt
# Crea: /tmp/pines.txt.gz

# Otros formatos de compresi&oacute;n disponibles:
crunch 8 8 0123456789 -z bzip2 -o /tmp/pines.txt
crunch 8 8 0123456789 -z lzma  -o /tmp/pines.txt
crunch 8 8 0123456789 -z 7z    -o /tmp/pines.txt

# Nota: Hashcat puede leer directamente archivos gzip
hashcat -m 0 hash.txt /tmp/pines.txt.gz

🏆ESTRATEGIAS DE ATAQUE EFICIENTES

Orden recomendado para auditorías en entornos autorizados (de más a menos probable éxito):

Primero: contraseñas por defecto del fabricante — muchos dispositivos sin cambiar su clave default. Consultar bases de datos de defaults.
Segundo: patrones específicos conocidos — si conoces la política de contraseñas (longitud, caracteres), Crunch con -t es ideal.
Tercero: diccionarios estándar + reglas — rockyou.txt con reglas de Hashcat antes que fuerza bruta total.
Cuarto: Crunch con charset reducido — si sabes el rango de caracteres posibles.
Último recurso: fuerza bruta completa — charset completo es costoso en tiempo/recursos.

Comparativa de wordlists: tamaños y tiempos

# REFERENCIA R&Aacute;PIDA - combis, tama&ntilde;o y tiempo estimado
# (Asumiendo 1 millones de intentos/segundo, t&iacute;pico para WPA)

# 4 d&iacute;gitos (PIN bancario):
# 10^4 = 10.000 combis | 70 KB | < 1 segundo

# 6 d&iacute;gitos (PIN m&oacute;vil):
# 10^6 = 1.000.000 combis | 7 MB | ~1 segundo

# 8 d&iacute;gitos (PIN largo):
# 10^8 = 100.000.000 combis | 700 MB | ~1.5 minutos

# 8 chars alfanum&eacute;rico min&uacute;sculo (a-z+0-9):
# 36^8 = 2.8 billones | 22 TB | ~32 d&iacute;as (inviable sin GPU)

# 8 chars con patr&oacute;n ,@@@@%%% (May+5min+2dig):
# 26 x 26^4 x 10^2 = 1.18 millones | 9 MB | ~1 segundo
# -> El patr&oacute;n reduce de 32 d&iacute;as a 1 segundo!

⚖

Ética, Legalidad y Uso Responsable

Marco legal y buenas prácticas en ciberseguridad ofensiva

⚖ MARCO LEGAL EN ESPAÑAEl acceso no autorizado a sistemas informáticos ajenos está tipificado en el Artículo 197 bis del Código Penal español con penas de hasta 2 años. La interceptación de comunicaciones inalámbricas (Wi-Fi) sin autorización también constituye delito. Las herramientas como Crunch son legales, el uso indebido no lo es.

✅USO LEGAL Y ÉTICO DE CRUNCH

Auditar tu propia red Wi-Fi o sistemas de tu empresa
Pruebas de penetración con contrato firmado por el cliente
Entornos de laboratorio (VMs aisladas, redes propias para práctica)
Plataformas de CTF (HackTheBox, TryHackMe, VulnHub)
Recuperar contraseñas de tus propios dispositivos (router, NAS, etc.)
Formación y certificaciones (CEH, OSCP, eJPT, CompTIA PenTest+)

❌USOS ILEGALES Y PROHIBIDOS

Auditar redes Wi-Fi de vecinos, empresas o lugares públicos sin permiso
Intentar acceder a sistemas ajenos (correo, redes sociales, bancos)
Usar wordlists generadas para comprometer cuentas de terceros
Distribuir wordlists generadas que contengan datos personales de terceros

🎓 ENTORNOS DE PRÁCTICA RECOMENDADOSPara practicar de forma legal: HackTheBox (hackthebox.eu), TryHackMe (tryhackme.com), VulnHub (máquinas virtuales vulnerables), DVWA (Damn Vulnerable Web App) y Metasploitable para entornos locales. Todos estos entornos están diseñados específicamente para práctica legal.