1.10 Gestión de wordlists y diccionarios

Una wordlist genérica te lleva hasta cierto punto. Lo que marca la diferencia en un engagement real es el diccionario construido para ese objetivo concreto: palabras de su web, patrones de contraseña propios de su industria, variaciones del nombre de la empresa. Este apartado cubre las herramientas estándar, las técnicas de mutación y cómo construir listas contextuales que aumentan drásticamente la tasa de éxito.

1.10.1 RockYou, SecLists y CeWL: construir diccionarios desde el objetivo

Hay dos categorías de wordlists: las genéricas (compiladas de brechas reales y patrones estadísticos) y las contextuales (construidas específicamente para un objetivo). Las primeras son el punto de partida; las segundas son las que consiguen los resultados cuando las primeras fallan.

RockYou

RockYou es el punto de partida de cualquier ataque de diccionario. Nació de la brecha de datos de la empresa RockYou en 2009, donde se filtraron 32 millones de contraseñas de usuarios almacenadas en texto plano. La lista resultante se convirtió en el estándar de referencia porque refleja contraseñas reales que personas reales usaban — no contraseñas generadas aleatoriamente.

En Kali Linux ya está incluida, comprimida:

bash — RockYou en Kali

# Ubicación en Kali
/usr/share/wordlists/rockyou.txt.gz

# Descomprimir (solo la primera vez)
sudo gunzip /usr/share/wordlists/rockyou.txt.gz

# Ver cuántas entradas tiene
wc -l /usr/share/wordlists/rockyou.txt
# 14344391 — 14 millones de contraseñas

# Ver las 20 contraseñas más comunes
head -20 /usr/share/wordlists/rockyou.txt

# Filtrar solo las que tienen entre 8 y 12 caracteres
awk 'length($0) >= 8 && length($0) <= 12' /usr/share/wordlists/rockyou.txt > rockyou_8_12.txt
wc -l rockyou_8_12.txt

💡

Filtrar por longitud ahorra tiempo: Si el objetivo tiene una política de contraseñas mínima conocida (por ejemplo, mínimo 8 caracteres), filtrar RockYou a ese rango reduce la lista a la mitad y acelera el ataque proporcionalmente. La mayoría de contraseñas reales tienen entre 8 y 12 caracteres.

SecLists

SecLists es una colección mantenida por Daniel Miessler y Jason Haddix que va mucho más allá de las contraseñas. Es la referencia para casi cualquier tipo de lista que necesites en un engagement: nombres de usuario, subdominios, rutas web, payloads de inyección, patrones de fuzzing, usernames de sistemas específicos y más.

bash — instalar y explorar SecLists

# Instalar en Kali (si no está ya)
sudo apt install -y seclists

# Ubicación
/usr/share/seclists/

# O clonar desde GitHub para tener siempre la última versión
git clone https://github.com/danielmiessler/SecLists.git /usr/share/seclists

# Estructura de directorios
ls /usr/share/seclists/
# Discovery/    → rutas web, subdominios, parámetros
# Passwords/    → contraseñas por categoría
# Usernames/    → nombres de usuario por servicio/industria
# Fuzzing/      → payloads de fuzzing (SQLi, XSS, LFI, etc.)
# Miscellaneous → patrones varios

# Las listas más usadas para pentesting web
/usr/share/seclists/Discovery/Web-Content/directory-list-2.3-medium.txt
/usr/share/seclists/Discovery/Web-Content/raft-medium-files.txt
/usr/share/seclists/Discovery/DNS/subdomains-top1million-5000.txt

# Contraseñas comunes para servicios específicos
/usr/share/seclists/Passwords/Default-Credentials/default-passwords.csv
/usr/share/seclists/Passwords/Common-Credentials/10k-most-common.txt

# Mantener SecLists actualizado
cd /usr/share/seclists && git pull

CeWL: diccionario desde el propio objetivo

CeWL (Custom Word List generator) es una herramienta que recorre una web y extrae todas las palabras que aparecen en ella para construir un diccionario personalizado. La idea detrás es simple pero efectiva: las personas tienden a usar contraseñas relacionadas con su entorno — el nombre de la empresa, términos de su industria, proyectos en los que trabajan, nombres de productos.

Si el panel de administración de una empresa de logística tiene palabras como "flota", "almacén", "rutas2024" y "transportes" en su web pública, hay probabilidades reales de que algún usuario haya elegido una de esas palabras como contraseña o como base de ella.

bash — CeWL: construir diccionario desde la web del objetivo

# Instalación (suele venir en Kali)
sudo apt install -y cewl

# Uso básico: extraer palabras de una URL
# -d: profundidad de rastreo (cuántos niveles de enlace seguir)
# -m: longitud mínima de palabra
# -w: archivo de salida
cewl -d 3 -m 6 -w diccionario_objetivo.txt https://objetivo.com

# Incluir también los metadatos de documentos encontrados (emails, autores)
cewl -d 3 -m 5 --meta -w diccionario_con_meta.txt https://objetivo.com

# Incluir direcciones de email encontradas
cewl -d 2 -m 5 --email -e emails.txt -w palabras.txt https://objetivo.com

# Aumentar el user agent para parecer un navegador normal
cewl -d 3 -m 6 \
    --ua "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" \
    -w diccionario_objetivo.txt https://objetivo.com

# Ver cuántas palabras ha extraído
wc -l diccionario_objetivo.txt

# Las palabras vienen sin duplicados pero con capitalización original
# Añadir también versiones en minúsculas
cat diccionario_objetivo.txt | tr '[:upper:]' '[:lower:]' >> diccionario_objetivo.txt
sort -u diccionario_objetivo.txt -o diccionario_objetivo.txt

Combinar fuentes para máxima cobertura

En la práctica, el diccionario más efectivo para un objetivo concreto combina varias fuentes. Este es el flujo típico:

bash — construir un diccionario combinado

# 1. Diccionario contextual desde la web del objetivo
cewl -d 3 -m 5 -w cewl_objetivo.txt https://objetivo.com

# 2. Palabras clave específicas del sector (escritas a mano)
cat > keywords_manuales.txt << 'EOF'
empresa
NombreEmpresa
logistica
almacen
2024
2025
EOF

# 3. Las contraseñas más comunes de RockYou (top 1000)
head -1000 /usr/share/wordlists/rockyou.txt > rockyou_top1000.txt

# 4. Combinar y deduplicar todo
cat cewl_objetivo.txt keywords_manuales.txt rockyou_top1000.txt \
    | sort -u > diccionario_final.txt

wc -l diccionario_final.txt
# Resultado: un diccionario pequeño pero relevante para este objetivo

1.10.2 Mutaciones con hashcat --stdout y reglas (best64, dive)

Una wordlist base solo cubre las contraseñas exactas que contiene. Las personas no usan contraseñas exactamente como las palabras del diccionario — las modifican: añaden números al final, capitalizan la primera letra, sustituyen letras por números (a→4, e→3), añaden símbolos al principio o al final. Las reglas de hashcat automatizan estas transformaciones a escala.

El flag --stdout de hashcat es la clave: en lugar de atacar un hash, genera todas las variaciones de una wordlist y las imprime por pantalla (o las redirige a un archivo). El resultado es una nueva wordlist con todas las mutaciones aplicadas.

Conjuntos de reglas principales

Conjunto de reglas	Reglas	Descripción	Uso recomendado
best64.rule	64	Las 64 transformaciones más efectivas estadísticamente	Primera pasada rápida en cualquier ataque
dive.rule	99.999	Conjunto muy extenso para máxima cobertura	Ataques exhaustivos con tiempo disponible
d3ad0ne.rule	34.096	Equilibrio entre amplitud y velocidad	Segunda pasada cuando best64 no es suficiente
Hashcat-legacy.rule	4.849	Reglas clásicas probadas en CTFs y pentests	CTFs y contraseñas de estilo "sysadmin antiguo"
OneRuleToRuleThemAll	52.000+	Compilación de las mejores reglas de múltiples fuentes	El conjunto más completo para ataques de cracking

bash — ubicación de las reglas en Kali / hashcat

# Hashcat instala las reglas en:
/usr/share/hashcat/rules/

ls /usr/share/hashcat/rules/
# best64.rule  d3ad0ne.rule  dive.rule  Hashcat-legacy.rule  ...

# OneRuleToRuleThemAll (no viene con hashcat, descargar aparte)
wget https://raw.githubusercontent.com/NotSoSecure/password_cracking_rules/master/OneRuleToRuleThemAll.rule \
    -O /usr/share/hashcat/rules/OneRuleToRuleThemAll.rule

Generar wordlists mutadas con --stdout

bash — hashcat --stdout para generar wordlists mutadas

# Aplicar best64 a una wordlist y guardar el resultado
# hashcat --stdout -r [regla] [wordlist_base]
hashcat --stdout -r /usr/share/hashcat/rules/best64.rule \
    diccionario_objetivo.txt > diccionario_mutado_best64.txt

wc -l diccionario_mutado_best64.txt
# Si el original tenía 500 palabras, ahora tiene ~32.000 variaciones

# Aplicar múltiples conjuntos de reglas a la vez
hashcat --stdout \
    -r /usr/share/hashcat/rules/best64.rule \
    -r /usr/share/hashcat/rules/d3ad0ne.rule \
    diccionario_objetivo.txt > diccionario_doble_regla.txt

# Combinar la wordlist mutada con el original y deduplicar
cat diccionario_objetivo.txt diccionario_mutado_best64.txt \
    | sort -u > diccionario_completo.txt

Sintaxis de las reglas: escribir las tuyas propias

Las reglas de hashcat tienen su propio lenguaje. Cada carácter es una operación que se aplica a la palabra. Conocer las operaciones básicas te permite escribir reglas específicas para un objetivo:

Operación	Símbolo	Ejemplo: "empresa"	Resultado
Sin cambio	`:`	empresa	empresa
Mayúscula primera letra	`c`	empresa	Empresa
Todo en mayúsculas	`u`	empresa	EMPRESA
Añadir al final	`$X`	empresa con `$1`	empresa1
Añadir al principio	`^X`	empresa con `^!`	!empresa
Invertir la palabra	`r`	empresa	aserpmE (invertida)
Duplicar	`d`	empresa	empresaempresa
Sustituir carácter	`sXY`	empresa con `sea`	emprasa (e→a)
Eliminar primer char	`[`	empresa	mpresa
Eliminar último char	`]`	empresa	empres

bash — escribir reglas personalizadas para un objetivo

# Reglas personalizadas para un objetivo en España en 2024
# Patron típico español: Palabra+año o Palabra+!  o Palabra+123
cat > /tools/cracking/rules/objetivo_es.rule << 'EOF'
# Sin cambio
:
# Primera letra mayúscula
c
# Primera letra mayúscula + año al final
c $2 $0 $2 $4
c $2 $0 $2 $5
# Primera letra mayúscula + ! al final
c $!
# Primera letra mayúscula + 123
c $1 $2 $3
# Todo el año al final
$2 $0 $2 $4
$2 $0 $2 $5
# Sustitucion leet basica: a→@, e→3, i→1, o→0
sa@ se3 si1 so0
# Combinacion leet + año
sa@ se3 c $2 $0 $2 $4
EOF

# Aplicar las reglas personalizadas a la wordlist del objetivo
hashcat --stdout -r /tools/cracking/rules/objetivo_es.rule \
    cewl_objetivo.txt > mutaciones_objetivo.txt

wc -l mutaciones_objetivo.txt

💡

Orden de ataque recomendado: En un engagement con tiempo limitado, el orden que maximiza resultados es: (1) contraseñas por defecto del servicio, (2) CeWL del objetivo con best64, (3) top 1000 de RockYou con best64, (4) RockYou completo con d3ad0ne. Si llegas al paso 4 sin resultado, el problema suele ser otro.

1.10.3 Wordlists contextuales con kwprocessor (keyboard walks)

Hay una categoría de contraseñas que ni RockYou, ni SecLists, ni CeWL capturan bien: las contraseñas generadas pulsando teclas adyacentes en el teclado. qwerty, 123456, asdfgh son los ejemplos más conocidos, pero hay patrones mucho más elaborados: qweqwe, 1qaz2wsx, zxcvbnm, diagonales, espirales, o combinaciones de filas.

Estas contraseñas son comunes porque parecen aleatorias a primera vista pero son fáciles de teclear y de recordar — y no aparecen en ningún diccionario de palabras reales. kwprocessor (kwp) es la herramienta específica para generarlas.

Instalación de kwprocessor

bash — instalar kwprocessor

# Clonar el repositorio
git clone https://github.com/hashcat/kwprocessor.git
cd kwprocessor

# Compilar
make

# Mover el binario a una ubicación accesible
sudo cp kwp /usr/local/bin/

# Verificar instalación
kwp --help

Conceptos: basechars, keymaps y routes

kwprocessor necesita tres ingredientes para generar walks:

basechars: los caracteres desde los que puede empezar el walk. Por defecto incluye todos los caracteres del teclado. Puedes limitarlo para generar listas más pequeñas.
keymaps: el mapa del teclado — qué teclas hay y en qué posición. kwprocessor incluye mapas para QWERTY (inglés, español, alemán, etc.), AZERTY y otros layouts.
routes: los patrones de movimiento. Definen las direcciones posibles del walk: derecha, izquierda, diagonal, en L, etc. Un route define cuántos pasos da el walk y en qué dirección.

bash — archivos de configuración de kwprocessor

# Dentro del directorio kwprocessor/ hay tres carpetas:
ls kwprocessor/
# basechars/  keymaps/  routes/

# Mapas de teclado disponibles
ls kwprocessor/keymaps/
# en.keymap  de.keymap  es.keymap  fr.keymap  ...

# Rutas disponibles (de menor a mayor cobertura)
ls kwprocessor/routes/
# 2-to-10-max-3-direction-changes_1.route
# 2-to-10-max-3-direction-changes_2.route
# ...

Generar wordlists de keyboard walks

bash — kwprocessor: generar keyboard walks

# Generación básica: walks sobre teclado QWERTY inglés
# -z: incluir shift (caracteres en mayúsculas y símbolos)
kwp \
    kwprocessor/basechars/full.base \
    kwprocessor/keymaps/en.keymap \
    kwprocessor/routes/2-to-10-max-3-direction-changes_1.route \
    -o walks_en.txt

# Para teclado español
kwp \
    kwprocessor/basechars/full.base \
    kwprocessor/keymaps/es.keymap \
    kwprocessor/routes/2-to-10-max-3-direction-changes_1.route \
    -o walks_es.txt

# Incluir variantes con shift (letras mayúsculas, símbolos del teclado)
kwp -z \
    kwprocessor/basechars/full.base \
    kwprocessor/keymaps/en.keymap \
    kwprocessor/routes/2-to-10-max-3-direction-changes_1.route \
    -o walks_en_shift.txt

# Ver cuántas contraseñas genera
wc -l walks_en.txt

# Mostrar los primeros ejemplos generados
head -20 walks_en.txt
# 12
# 21
# 23
# qw
# we
# ...

Combinar walks con mutaciones

Los keyboard walks por sí solos cubren los patrones puros. Pero muchas personas modifican el walk: lo capitalizan, le añaden un número al final, lo combinan con una palabra. Aplicar reglas de hashcat sobre la lista de walks amplía significativamente la cobertura:

bash — walks + reglas hashcat

# 1. Generar la lista de walks base
kwp \
    kwprocessor/basechars/full.base \
    kwprocessor/keymaps/en.keymap \
    kwprocessor/routes/2-to-10-max-3-direction-changes_1.route \
    -o walks_base.txt

# 2. Aplicar best64 para generar variaciones (capitalización, números al final, etc.)
hashcat --stdout -r /usr/share/hashcat/rules/best64.rule \
    walks_base.txt > walks_mutados.txt

# 3. Combinar los walks base con los mutados
cat walks_base.txt walks_mutados.txt | sort -u > walks_completo.txt

# Resultado: miles de variaciones de keyboard walk con transformaciones
wc -l walks_completo.txt

Flujo completo: de cero a diccionario personalizado

Este script combina las tres técnicas del apartado 1.10 en un solo flujo para construir un diccionario completo orientado a un objetivo concreto:

bash — build_wordlist.sh: diccionario completo en un script

#!/bin/bash
# build_wordlist.sh — construye un diccionario personalizado para un objetivo
# Uso: ./build_wordlist.sh https://objetivo.com salida_final.txt

URL="$1"
OUTPUT="${2:-wordlist_objetivo.txt}"
TMPDIR="$(mktemp -d)"

[ -z "$URL" ] && { echo "Uso: $0 <URL> [archivo_salida]"; exit 1; }

echo "[*] Construyendo diccionario para: $URL"

# 1. Diccionario contextual con CeWL
echo "[1/4] Extrayendo palabras del objetivo con CeWL..."
cewl -d 3 -m 5 -q -w "${TMPDIR}/cewl.txt" "$URL"

# 2. Mutaciones con best64
echo "[2/4] Aplicando mutaciones best64..."
hashcat --stdout -r /usr/share/hashcat/rules/best64.rule \
    "${TMPDIR}/cewl.txt" > "${TMPDIR}/cewl_mutado.txt"

# 3. Keyboard walks (inglés y español)
echo "[3/4] Generando keyboard walks..."
kwp /tools/kwprocessor/basechars/full.base \
    /tools/kwprocessor/keymaps/en.keymap \
    /tools/kwprocessor/routes/2-to-10-max-3-direction-changes_1.route \
    -o "${TMPDIR}/walks.txt" 2>/dev/null

# 4. Combinar todo y deduplicar
echo "[4/4] Combinando y deduplicando..."
cat "${TMPDIR}/cewl.txt" \
    "${TMPDIR}/cewl_mutado.txt" \
    "${TMPDIR}/walks.txt" \
    | sort -u > "$OUTPUT"

echo "[✓] Diccionario generado: $OUTPUT ($(wc -l < "$OUTPUT") entradas)"
rm -rf "$TMPDIR"

💡

El tamaño importa: Un diccionario de 100.000 entradas contra un hash MD5 en GPU tarda segundos. Contra un hash bcrypt con factor de coste 12, puede tardar días. Calibra el tamaño del diccionario al tipo de hash que vas a atacar. Para hashes lentos (bcrypt, scrypt, argon2) prefiere diccionarios pequeños y muy relevantes. Para hashes rápidos (MD5, SHA1, NTLM) puedes permitirte listas mucho más grandes.