John the Ripper — Laboratorio Completo

🔨 Introducción

JOHN THE RIPPER
Laboratorio guiado completo

John the Ripper es una de las herramientas de cracking de contraseñas más usadas en ciberseguridad ofensiva y auditorías. Este laboratorio te guía desde cero con ejercicios reales y paso a paso.

🖥 Kali Linux 2024 10 laboratorios Principiante → Avanzado ⚠ Solo entornos autorizados

🔴 Aviso legal: Todas las técnicas de este laboratorio deben practicarse exclusivamente en entornos controlados y con autorización explícita. Usar estas herramientas contra sistemas ajenos es ilegal. Este material es únicamente para formación en ciberseguridad.

¿Qué aprenderás?

💥

Ataques de diccionario

Usar wordlists como RockYou para crackear hashes MD5, SHA1, SHA-256 y más.

🔢

Fuerza bruta

Modo incremental con charsets configurables: dígitos, alfanumérico, todos los caracteres.

🎭

Rules & Mangling

Transformar palabras del diccionario con reglas: leetspeak, mayúsculas, sufijos numéricos.

🐧

/etc/shadow

Crackear contraseñas reales de sistemas Linux con unshadow y John.

📁

Archivos protegidos

ZIP, RAR, PDF y documentos Office con contraseña.

⚙️

Reglas personalizadas

Escribir tus propias reglas en john.conf para ataques dirigidos.

Estructura del laboratorio

#	Laboratorio	Nivel	Concepto clave
Lab 1	Primer crack MD5	Básico	Diccionario básico, archivo pot
Lab 2	Múltiples hashes	Básico	Varios hashes a la vez, --show
Lab 3	Modo Single	Básico	Variaciones del nombre de usuario
Lab 4	Fuerza bruta incremental	Intermedio	Charsets, longitud, estrategia
Lab 5	Rules & Mangling	Intermedio	best64, KoreLogic, reglas integradas
Lab 6	Wordlists avanzadas	Intermedio	SecLists, crunch, combinación
Lab 7	/etc/shadow real	Avanzado	unshadow, md5crypt, sha512crypt
Lab 8	Archivos ZIP / PDF	Avanzado	zip2john, pdf2john, office2john
Lab 9	Reglas personalizadas	Avanzado	john.conf, sintaxis de reglas
Lab 10	Ejercicio final guiado	CTF	Flujo completo de auditoría

⚙️ Setup

INSTALACIÓN &
PREPARACIÓN DEL ENTORNO

Antes de empezar los laboratorios, configura tu Kali Linux con todas las herramientas necesarias y el directorio de trabajo.

Checklist de setup0 / 5

Sistema actualizado (apt update && upgrade)

John the Ripper instalado y versión verificada

RockYou descomprimido en /usr/share/wordlists/

Directorio de laboratorio creado en ~/john-lab/

Hashes de práctica generados correctamente

Paso 1 — Actualizar el sistema

kali — bash

sudo apt update && sudo apt upgrade -y

Paso 2 — Instalar John the Ripper

En Kali Linux la versión disponible en repositorios es ya la versión Jumbo, que incluye soporte para cientos de formatos adicionales.

bash

# Instalar John
sudo apt install -y john

# Verificar versión (debe decir "jumbo")
john --version
John the Ripper 1.9.0-jumbo-1+bleeding-aec1328d6c 2024-01-23 ...

# Ver cuántos formatos soporta
john --list=formats | wc -l
526

# Buscar un formato concreto
john --list=formats | grep -i "md5\|sha\|ntlm\|bcrypt"

💡 Versión más reciente: Si quieres la última versión compilada desde código fuente: git clone https://github.com/openwall/john.git && cd john/src && ./configure && make -sj4 El binario quedará en john/run/john.

Paso 3 — Preparar RockYou

RockYou es la wordlist más usada. En Kali viene comprimida. Hay que descomprimirla antes de usarla con John.

bash

# Descomprimir RockYou (solo si aún está comprimido)
ls -lh /usr/share/wordlists/rockyou*
sudo gunzip /usr/share/wordlists/rockyou.txt.gz

# Cuántas contraseñas tiene
wc -l /usr/share/wordlists/rockyou.txt
14344391   # ~14 millones de contraseñas reales filtradas

# Ver las primeras 10
head -10 /usr/share/wordlists/rockyou.txt
123456
12345
123456789
password
iloveyou
princess
1234567
rockyou
12345678
abc123

Paso 4 — Crear directorio de trabajo

bash

# Crear estructura de directorios del laboratorio
mkdir -p ~/john-lab/{hashes,wordlists,results,shadow-lab}
cd ~/john-lab
ls
hashes/  results/  shadow-lab/  wordlists/

Paso 5 — Generar hashes de práctica

Vamos a crear nuestros propios hashes para los primeros laboratorios. Estos son hashes de contraseñas conocidas que usaremos como objetivos de práctica.

bash

# Generar hashes MD5
echo -n "password" | md5sum
5f4dcc3b5aa765d61d8327deb882cf99  -

echo -n "123456" | md5sum
e10adc3949ba59abbe56e057f20f883e  -

echo -n "qwerty" | md5sum
d8578edf8458ce06fbc5bb76a58c5ca4  -

# Crear archivo con los 3 hashes MD5
cat > ~/john-lab/hashes/md5_basico.txt << EOF
5f4dcc3b5aa765d61d8327deb882cf99
e10adc3949ba59abbe56e057f20f883e
d8578edf8458ce06fbc5bb76a58c5ca4
EOF

# Generar hashes SHA1
echo -n "password" | sha1sum
5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8  -

cat > ~/john-lab/hashes/sha1_basico.txt << EOF
5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8
7c4a8d09ca3762af61e59520943dc26494f8941b
cbfdac6008f9cab4083784cbd1874f76618d2a97
EOF
# SHA1 de: "password", "123456", "password123"

# Verificar que los archivos se crearon bien
ls -la ~/john-lab/hashes/
cat ~/john-lab/hashes/md5_basico.txt

📚 Teoría

TIPOS DE HASH
& FORMATOS EN JOHN

Antes de atacar un hash necesitas saber qué tipo es. John usa el parámetro --format para indicarlo. Aprende a identificarlos.

Hashes más comunes

Algoritmo	Longitud	Formato en John	Ejemplo	Seguridad
MD5	32 hex	raw-md5	5f4dcc3b5aa765d6...	MUY DÉBIL
SHA-1	40 hex	raw-sha1	5baa61e4c9b93f3f...	DÉBIL
SHA-256	64 hex	raw-sha256	5e884898da280471...	MODERADO
SHA-512	128 hex	raw-sha512	b109f3bbbc244eb8...	MODERADO
MD5crypt ($1$)	34 chars	md5crypt	$1$salt$hash	DÉBIL-MOD
SHA512crypt ($6$)	98 chars	sha512crypt	$6$salt$hash	FUERTE
bcrypt ($2y$)	60 chars	bcrypt	$2y$10$salt$hash	MUY FUERTE
NTLM	32 hex	nt	b4b9b02e6f09a9bd...	DÉBIL
LM	32 hex	lm	aad3b435b5140...	MUY DÉBIL

Identificar un hash desconocido

Cuando tienes un hash y no sabes su tipo, usa estas herramientas:

bash

# hashid: identifica e incluye el modo Hashcat (-m)
sudo apt install -y hashid
hashid -m "5f4dcc3b5aa765d61d8327deb882cf99"
Analyzing '5f4dcc3b5aa765d61d8327deb882cf99'
[+] MD2
[+] MD5 [Hashcat Mode: 0]
[+] MD4 [Hashcat Mode: 900]

# hash-identifier: herramienta interactiva incluida en Kali
hash-identifier
 HASH: 5f4dcc3b5aa765d61d8327deb882cf99
 Possible Hashs:
 [+] MD5
 [+] Domain Cached Credentials

# Método visual: identificar por longitud y prefijo
# 32 chars hex  → MD5 o NTLM
# 40 chars hex  → SHA-1
# 64 chars hex  → SHA-256
# 128 chars hex → SHA-512
# empieza por $1$ → MD5crypt (Linux)
# empieza por $5$ → SHA-256crypt (Linux)
# empieza por $6$ → SHA-512crypt (Linux)
# empieza por $2y$ o $2b$ → bcrypt

Identificador interactivo

🔍 Identificar tipo de hash — pega un hash y te digo qué es

Esperando hash...

Los 3 modos de ataque de John

👤

Single Crack

Usa el nombre de usuario y campos del archivo para derivar variaciones. Muy rápido. Siempre el primer intento.

📖

Wordlist

Ataque de diccionario. Lee contraseñas de un archivo línea a línea. Con o sin reglas de mangling.

🔢

Incremental

Fuerza bruta total. Prueba todas las combinaciones posibles de un charset definido. El más lento.

Estrategia óptima: Siempre sigue este orden para maximizar resultados con el mínimo tiempo: Single → Wordlist → Wordlist+Reglas → Incremental Digits → Incremental Alnum → Incremental All

🔨 Lab 1

PRIMER CRACK
Ataque de diccionario sobre MD5

En este primer laboratorio vas a crackear un hash MD5 usando la wordlist RockYou. Aprenderás el flujo básico completo de John: preparar el hash, lanzar el ataque y ver el resultado.

Nivel básico⏱ 15 minMD5 · Diccionario

Checklist — Lab 10 / 5

Crear archivo con el hash MD5 objetivo

Ejecutar John con --format=raw-md5 y rockyou

Leer la contraseña en la salida del terminal

Ver el archivo ~/.john/john.pot

Usar --show para consultar resultados sin recalcular

EJERCICIO 1.1Crackear un hash MD5 con diccionarioFácil

Objetivo: Tienes el hash MD5 de una contraseña desconocida. Debes usar John con RockYou para encontrar la contraseña original. El hash objetivo es: 5f4dcc3b5aa765d61d8327deb882cf99

01

Crea el archivo con el hash

John necesita que el hash esté en un archivo de texto. Una línea por hash.

bash

cd ~/john-lab
echo "5f4dcc3b5aa765d61d8327deb882cf99" > hashes/ej1.txt
# Verificar que se guardó bien
cat hashes/ej1.txt
5f4dcc3b5aa765d61d8327deb882cf99

02

Lanza el ataque con John

Especifica el formato del hash (--format=raw-md5) y la wordlist (--wordlist).

bash

john --format=raw-md5 --wordlist=/usr/share/wordlists/rockyou.txt hashes/ej1.txt

# Salida esperada:
Using default input encoding: UTF-8
Loaded 1 password hash (Raw-MD5 [MD5 256/256 AVX2 8x3])
Warning: no OpenMP support for this hash type, consider --fork=2
Press 'q' or Ctrl-C to abort, almost any other key for status
password          (5f4dcc3b5aa765d61d8327deb882cf99)
1g 0:00:00:00 DONE (2024-01-15 10:23) 100g/s 409600p/s
Session completed

La contraseña aparece a la izquierda, el hash entre paréntesis a la derecha.

03

Examina el archivo pot

John guarda automáticamente todas las contraseñas crackeadas en ~/.john/john.pot. Esto evita repetir trabajo.

bash

cat ~/.john/john.pot
$dynamic_0$5f4dcc3b5aa765d61d8327deb882cf99:password
# Formato: $formato$hash:contraseña_en_claro

04

Consulta los resultados con --show

Si ejecutas John sobre el mismo archivo otra vez, dirá "0 password hashes cracked" porque ya está en el pot. Usa --show para ver resultados guardados.

bash

john --show --format=raw-md5 hashes/ej1.txt
5f4dcc3b5aa765d61d8327deb882cf99:password
1 password hash cracked, 0 left

05

Forzar un nuevo ataque ignorando el pot

Si quieres volver a crackear desde cero (por ejemplo para practicar), usa --pot=/dev/null para ignorar el archivo pot.

bash

john --format=raw-md5 --wordlist=/usr/share/wordlists/rockyou.txt \
  --pot=/dev/null hashes/ej1.txt

EJERCICIO 1.2Crackear un hash SHA-1Fácil

Objetivo: Aplica el mismo proceso pero con SHA-1. El formato cambia a --format=raw-sha1. Hash objetivo: 7c4a8d09ca3762af61e59520943dc26494f8941b

01

Crear archivo y atacar

bash

echo "7c4a8d09ca3762af61e59520943dc26494f8941b" > hashes/ej2_sha1.txt

john --format=raw-sha1 --wordlist=/usr/share/wordlists/rockyou.txt hashes/ej2_sha1.txt

# El resultado mostrará la contraseña encontrada
# Cuando termines, consulta con --show:
john --show --format=raw-sha1 hashes/ej2_sha1.txt

💡 Auto-detección de formato: Si no sabes el formato puedes omitir --format y John intentará detectarlo automáticamente. Sin embargo, para hashes crudos como MD5 o SHA1 la detección automática a veces falla. Es mejor especificarlo siempre.

🔨 Lab 2

MÚLTIPLES HASHES
Crackear varios hashes a la vez

John puede procesar un archivo con cientos de hashes simultáneamente. Aprende a preparar archivos multi-hash y a analizar los resultados.

Nivel básico⏱ 20 minSHA-1 · Multi-hash

Checklist — Lab 20 / 4

Crear archivo con 5 hashes SHA-1 diferentes

Atacar con John y verificar cuántos crackea

Usar --show para listar todos los resultados

Guardar resultados en un archivo de texto

EJERCICIO 2.1Atacar 5 hashes SHA-1 simultáneamenteFácil

Objetivo: Crackear estos 5 hashes SHA-1 de una vez. Todos corresponden a contraseñas que están en RockYou.

01

Crear el archivo multi-hash

bash

cat > ~/john-lab/hashes/sha1_multi.txt << EOF
5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8
7c4a8d09ca3762af61e59520943dc26494f8941b
cbfdac6008f9cab4083784cbd1874f76618d2a97
b1b3773a05c0ed0176787a4f1574ff0075f7521e
f7c3bc1d808e04732adf679965ccc34ca7ae3441
EOF
# Verificar el archivo
wc -l ~/john-lab/hashes/sha1_multi.txt
5

02

Lanzar el ataque de diccionario

bash

john --format=raw-sha1 --wordlist=/usr/share/wordlists/rockyou.txt \
  ~/john-lab/hashes/sha1_multi.txt

Loaded 5 password hashes with no different salts (Raw-SHA1 [SHA1 256/256 AVX2 8x])
password          (5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8)
123456            (7c4a8d09ca3762af61e59520943dc26494f8941b)
password123       (cbfdac6008f9cab4083784cbd1874f76618d2a97)
hello             (b1b3773a05c0ed0176787a4f1574ff0075f7521e)
1234567890        (f7c3bc1d808e04732adf679965ccc34ca7ae3441)
5g 0:00:00:02 DONE (2024-01-15 10:31) 2.500g/s 5120Kp/s
Session completed.

03

Mostrar resultados con --show

bash

john --show --format=raw-sha1 ~/john-lab/hashes/sha1_multi.txt
5baa61e4c9b93f3f...:password
7c4a8d09ca3762af...:123456
cbfdac6008f9cab4...:password123
b1b3773a05c0ed01...:hello
f7c3bc1d808e0473...:1234567890
5 password hashes cracked, 0 left

04

Guardar resultados en archivo

bash

john --show --format=raw-sha1 ~/john-lab/hashes/sha1_multi.txt \
  > ~/john-lab/results/lab2_resultados.txt
cat ~/john-lab/results/lab2_resultados.txt

EJERCICIO 2.2Hashes con formato usuario:hashFácil

Objetivo: En muchos escenarios reales los hashes van acompañados del nombre de usuario. John acepta el formato usuario:hash y lo usa para personalizar el ataque.

01

Crear archivo usuario:hash

bash

cat > ~/john-lab/hashes/usuarios_md5.txt << EOF
alice:7e53e8c9b26adff2bde1cbcaef5b6b45
bob:482c811da5d5b4bc6d497ffa98491e38
carlos:d8578edf8458ce06fbc5bb76a58c5ca4
EOF
# MD5 de: alice→"alice123", bob→"password123", carlos→"qwerty"

john --format=raw-md5 --wordlist=/usr/share/wordlists/rockyou.txt \
  ~/john-lab/hashes/usuarios_md5.txt

# Con --show muestra usuario:contraseña
john --show --format=raw-md5 ~/john-lab/hashes/usuarios_md5.txt
alice:alice123
bob:password123
carlos:qwerty

🔨 Lab 3

MODO SINGLE CRACK
Variaciones del nombre de usuario

El modo Single es el más rápido. John toma el nombre de usuario del archivo y genera miles de variaciones automáticamente. Muchos usuarios ponen su nombre como contraseña.

Nivel básico⏱ 15 min--single · user:hash

Checklist — Lab 30 / 3

Crear archivo con formato usuario:hash

Ejecutar John en modo --single

Comprender qué variaciones genera el modo single

¿Qué hace el modo Single?

Cuando el archivo tiene el formato usuario:hash, John en modo --single usa el nombre de usuario para derivar variaciones: alice → Alice, ALICE, alice1, alice2024, 3c!l@, alice!, ecila... Con campos GECOS (nombre completo) genera aún más variaciones.

EJERCICIO 3.1Single Crack con nombre de usuarioFácil

Objetivo: Varios usuarios han puesto como contraseña una variación simple de su nombre. El modo Single los encontrará en segundos.

01

Generar hashes de contraseñas basadas en nombre

bash — preparar lab

# Generar hashes MD5 de contraseñas basadas en nombre de usuario
echo -n "alice" | md5sum    # contraseña = nombre exacto
echo -n "Alice1" | md5sum   # variación capitalizada + número
echo -n "BOB" | md5sum      # en mayúsculas
echo -n "carlos1" | md5sum  # nombre + dígito

# Crear el archivo con usuario:hash (los hashes resultantes de los comandos anteriores)
cat > ~/john-lab/hashes/single_lab.txt << EOF
alice:6384e2b2184bcbf58eccf10ca7a6563c
bob:b9ece18c950afbfa6b0fdbfa4ff731d3
carlos:e77030daff78c4eb1f1b16cfe3dbb3cd
EOF
# Contraseñas: alice="alice", bob="bob", carlos="carlos1"

02

Ejecutar modo Single

bash

john --single --format=raw-md5 ~/john-lab/hashes/single_lab.txt

Loaded 3 password hashes with no different salts
Only 3 candidates buffered for the current salt...
alice             (alice)
bob               (bob)
carlos1           (carlos)
3g 0:00:00:00 DONE (2024-01-15 10:45) 150.0g/s

03

Ver las variaciones que genera (sin atacar)

Con --stdout puedes ver exactamente qué candidatas genera John en modo single sin lanzar el ataque.

bash

# Crear un mini archivo para ver las variaciones de "alice"
echo "alice:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" > /tmp/alice_test.txt
john --single --format=raw-md5 --stdout /tmp/alice_test.txt 2>/dev/null | head -30
alice
Alice
ALICE
eCiLa
alice0
alice1
alice2
alice3
...
Alice1
Alice!
alice2024

Cuándo usar Single: Siempre como primer paso antes del diccionario. Es instantáneo y sorprendentemente efectivo en sistemas con políticas de contraseñas débiles donde los usuarios usan su nombre o username como base.

🔨 Lab 4

FUERZA BRUTA
Modo incremental y charsets

El modo incremental prueba todas las combinaciones posibles de caracteres dentro de un charset. Lento pero exhaustivo. Ideal para contraseñas cortas o cuando conoces el patrón.

Nivel intermedio⏱ 25 min--incremental · charsets

Checklist — Lab 40 / 5

Crackear un PIN de 4 dígitos con Digits

Usar charset Alpha (solo letras)

Limitar longitud con --min-length / --max-length

Ejecutar fuerza bruta con charset Alnum

Entender cuándo usar fuerza bruta vs diccionario

Charsets disponibles en John

Charset	Caracteres incluidos	Tamaño	Uso recomendado
Digits	0123456789	10	PINs, fechas, códigos numéricos
Lower	a-z	26	Contraseñas solo minúsculas
Upper	A-Z	26	Combinado con otros
Alpha	a-z + A-Z	52	Contraseñas solo letras
Alnum	a-z + A-Z + 0-9	62	Contraseñas alfanuméricas sin símbolos
All	Todos los imprimibles	95	Último recurso (muy lento para >6 chars)

EJERCICIO 4.1Crackear un PIN de 4 dígitosFácil

Objetivo: El hash corresponde a un PIN numérico de exactamente 4 dígitos. Solo hay 10.000 combinaciones posibles, así que la fuerza bruta es muy rápida.

01

Preparar el hash objetivo

bash

# Creamos el hash MD5 de un PIN de 4 dígitos
echo -n "2048" | md5sum
f16fcc77e58c42048d1c01f6b5dc4cb3  -

echo "f16fcc77e58c42048d1c01f6b5dc4cb3" > ~/john-lab/hashes/pin4.txt

02

Fuerza bruta con charset Digits y longitud fija

bash

john --incremental=Digits --min-length=4 --max-length=4 \
  --format=raw-md5 ~/john-lab/hashes/pin4.txt

Loaded 1 password hash (Raw-MD5 [MD5 256/256 AVX2 8x3])
2048              (f16fcc77e58c42048d1c01f6b5dc4cb3)
1g 0:00:00:00 DONE (2024-01-15 10:52) 10000g/s

EJERCICIO 4.2Fuerza bruta alfanumérica con límite de longitudMedio

Objetivo: La contraseña es alfanumérica (solo letras y números) y tiene exactamente 4 caracteres. Usa el charset Alnum.

01

Preparar y atacar

bash

# Generamos un hash de 4 chars alfanuméricos
echo -n "r3d5" | md5sum
b9f5d8e2a1c3f7a4b8d2e6c9a3f7b1d5  -

echo "HASH_RESULTADO_AQUI" > ~/john-lab/hashes/alnum4.txt

# Ataque con Alnum, solo 4 caracteres
# Alnum tiene 62 caracteres → 62^4 = 14.776.336 combinaciones
john --incremental=Alnum --min-length=4 --max-length=4 \
  --format=raw-md5 ~/john-lab/hashes/alnum4.txt

# Nota: John probará todas las combinaciones de 4 chars alfanuméricos
# En hardware moderno tarda segundos

02

Ver el progreso en tiempo real

Mientras John trabaja, pulsa cualquier tecla para ver el progreso. Con --fork aprovechas múltiples núcleos de CPU.

bash

# Ver velocidad y estado al presionar cualquier tecla durante el ataque
14g 0:00:00:03 3% (ETA: 10:55:22) 4.667g/s 3558Kp/s 3558Kc/s
# g/s = contraseñas por segundo

# Aprovechar múltiples núcleos CPU (ej: 4 núcleos)
john --incremental=Alnum --min-length=4 --max-length=4 \
  --format=raw-md5 --fork=4 ~/john-lab/hashes/alnum4.txt

EJERCICIO 4.3Estrategia: ¿cuándo usar fuerza bruta?Conceptual

Objetivo: Entender en qué casos conviene usar cada modo. Calcula los tiempos estimados según el charset y la longitud.

estimaciones de fuerza bruta — MD5 en CPU moderno (~500 MH/s)

# Digits (10 chars), longitud 4:  10^4 = 10.000         → < 1 segundo
# Digits (10 chars), longitud 8:  10^8 = 100.000.000    → < 1 segundo
# Alpha  (52 chars), longitud 6:  52^6 = 19.770.609.664 → ~40 segundos
# Alnum  (62 chars), longitud 6:  62^6 = 56.800.235.584 → ~2 minutos
# Alnum  (62 chars), longitud 8:  62^8 = 218.340.105.584.896 → ~5 días
# All    (95 chars), longitud 8:  95^8 = 6.634.204.312.890.625 → ~154 días

# CONCLUSIÓN: Fuerza bruta es viable para:
# - Contraseñas numéricas (PINs, fechas) de cualquier longitud razonable
# - Contraseñas alfanuméricas de hasta 6-7 caracteres
# - Cuando tienes GPU (Hashcat acelera 100x sobre CPU)

# Para contraseñas más largas → usa diccionario + reglas (Lab 5)

🔨 Lab 5

RULES & MANGLING
Transformar palabras del diccionario

Las reglas multiplican la efectividad del diccionario. "password" con las reglas adecuadas se convierte en "P@ssw0rd!", "Password1", "drowssap", y miles de variaciones más.

Nivel intermedio⏱ 30 min--rules · mangling

Checklist — Lab 50 / 5

Ejecutar John con --rules (reglas integradas Wordlist)

Usar las reglas best64 y KoreLogic

Ver las transformaciones con --stdout

Crackear un hash que requiere mangling para encontrarse

Entender la sintaxis básica de reglas

Sintaxis básica de reglas

Regla	Efecto	Ejemplo: "pass" →
c	Primera letra mayúscula	Pass
u	Todo mayúsculas	PASS
l	Todo minúsculas	pass
r	Invertir la cadena	ssap
d	Duplicar	passpass
$1	Añadir "1" al final	pass1
^!	Añadir "!" al principio	!pass
sa@	Sustituir 'a' por '@'	p@ss
se3	Sustituir 'e' por '3'	pass (sin 'e')
so0	Sustituir 'o' por '0'	pass (sin 'o')
[	Eliminar primera letra	ass
]	Eliminar última letra	pas

Las reglas se encadenan en una sola línea. Por ejemplo c sa@ $1 sobre "password" produce "P@ssword1".

EJERCICIO 5.1Ver transformaciones con --stdoutFácil

Objetivo: Antes de atacar, visualiza exactamente qué variaciones genera John con las reglas. Esto te ayuda a entender qué estás haciendo.

01

Ver variaciones de palabras comunes con --rules

bash

# Crear una wordlist pequeña de prueba
printf "password\nwelcome\nadmin\nsecret\n" > /tmp/mini_wl.txt

# Ver todas las variaciones que genera la regla "Wordlist" (la por defecto)
john --wordlist=/tmp/mini_wl.txt --rules=Wordlist --stdout 2>/dev/null | head -40
password
Password
PASSWORD
drowssap
password0
password1
password2
...
p@ssword
passw0rd
Pa$$word
Password1
Password!
password2024

# Contar cuántas variaciones genera
john --wordlist=/tmp/mini_wl.txt --rules=Wordlist --stdout 2>/dev/null | wc -l

EJERCICIO 5.2Crackear hash con contraseña modificadaMedio

Objetivo: La contraseña es una variación de una palabra de diccionario con reglas aplicadas: primera letra en mayúscula y número al final. Sin reglas no se encontraría.

01

Preparar el hash objetivo

bash

# La contraseña es "Welcome1" — NO está en RockYou en forma pura
echo -n "Welcome1" | md5sum
dbc5a21da5bd25c4e077f8af80e9e3cd  -

echo "dbc5a21da5bd25c4e077f8af80e9e3cd" > ~/john-lab/hashes/mangled.txt

02

Primer intento SIN reglas — fallará

bash

# Sin reglas, John busca exactamente las palabras del diccionario
john --format=raw-md5 --wordlist=/usr/share/wordlists/rockyou.txt \
  --pot=/dev/null ~/john-lab/hashes/mangled.txt
Loaded 1 password hash (Raw-MD5)
...
Session completed. (no cracked)
# "Welcome1" no está en RockYou, pero "welcome" sí

03

Segundo intento CON reglas — lo encontrará

bash

# Con --rules John transforma "welcome" → "Welcome1" entre otras variaciones
john --format=raw-md5 --wordlist=/usr/share/wordlists/rockyou.txt \
  --rules --pot=/dev/null ~/john-lab/hashes/mangled.txt

Welcome1          (dbc5a21da5bd25c4e077f8af80e9e3cd)
1g 0:00:00:08 DONE (2024-01-15 11:02) 0.125g/s 2873Kp/s

EJERCICIO 5.3Comparar diferentes conjuntos de reglasMedio

Objetivo: Conocer los diferentes conjuntos de reglas de John y cuándo usar cada uno.

bash

# Ver todos los conjuntos de reglas disponibles
john --list=rules
Wordlist, Single, Extra, Jumbo, NT, o1, o2, o3 ...

# Reglas integradas más importantes:

# --rules=Single: las mismas reglas que el modo Single, rápidas
john --format=raw-md5 --wordlist=rockyou.txt --rules=Single hash.txt

# --rules=Wordlist: el conjunto por defecto, buen equilibrio velocidad/efectividad
john --format=raw-md5 --wordlist=rockyou.txt --rules=Wordlist hash.txt

# --rules=Extra: más variaciones, más lento
john --format=raw-md5 --wordlist=rockyou.txt --rules=Extra hash.txt

# --rules=Jumbo: el más completo de los incluidos
john --format=raw-md5 --wordlist=rockyou.txt --rules=Jumbo hash.txt

# Ver cuántas reglas tiene cada conjunto
grep -c "^[^#;]" /etc/john/john.conf

🔨 Lab 6

WORDLISTS AVANZADAS
SecLists, crunch y wordlists propias

RockYou no siempre es suficiente. Aprende a usar SecLists, generar wordlists con crunch y crear listas personalizadas basadas en información del objetivo.

Nivel intermedio⏱ 25 minSecLists · crunch · OSINT

Checklist — Lab 60 / 4

Instalar SecLists y explorar las wordlists disponibles

Generar wordlist de 6 dígitos con crunch

Crear una wordlist personalizada con datos del objetivo

Combinar múltiples wordlists con cat

EJERCICIO 6.1SecLists — La colección definitivaFácil

Objetivo: Instalar SecLists y explorar las wordlists específicas para distintos escenarios.

01

Instalar SecLists

bash

sudo apt install -y seclists
# Se instala en /usr/share/seclists/

# Explorar las wordlists de contraseñas disponibles
ls /usr/share/seclists/Passwords/
Common-Credentials/    Default-Credentials/
Leaked-Databases/      WiFi-WPA/
darkweb2017-top100.txt
xato-net-10-million-passwords.txt

# Wordlists más útiles para John:
# Top 10.000 contraseñas más comunes
wc -l /usr/share/seclists/Passwords/Common-Credentials/10k-most-common.txt

# Contraseñas por defecto de dispositivos
cat /usr/share/seclists/Passwords/Default-Credentials/default-passwords.csv | head -20

# Usar con John:
john --format=raw-md5 \
  --wordlist=/usr/share/seclists/Passwords/Common-Credentials/10k-most-common.txt \
  ~/john-lab/hashes/md5_basico.txt

EJERCICIO 6.2Generar wordlists con crunchMedio

Objetivo: Cuando conoces el patrón de la contraseña (longitud, caracteres usados), crunch genera todas las combinaciones posibles eficientemente.

01

Instalar crunch y aprender la sintaxis

bash

sudo apt install -y crunch

# Sintaxis: crunch min_longitud max_longitud [charset] [opciones]
# Caracteres especiales en -t (template):
#   @  = letra minúscula
#   ,  = letra mayúscula
#   %  = número
#   ^  = símbolo especial

02

Generar wordlists con patrones específicos

bash

# Todos los PINs de 6 dígitos (000000 a 999999)
crunch 6 6 0123456789 -o ~/john-lab/wordlists/pins6.txt
Crunch will now generate the following amount of data: 7000000 bytes

# Contraseñas con patrón: nombre fijo + 3 números (ej: Admin001 ... Admin999)
crunch 8 8 -t Admin%%% -o ~/john-lab/wordlists/admin_nums.txt

# Patrón: 1 mayúscula + 5 minúsculas + 2 números
crunch 8 8 -t ,@@@@@%% -o ~/john-lab/wordlists/patron1.txt

# Usar la wordlist generada con John via pipe (más eficiente en memoria)
crunch 4 4 0123456789 | john --format=raw-md5 --stdin ~/john-lab/hashes/pin4.txt

EJERCICIO 6.3Wordlist personalizada con datos del objetivo (OSINT)Medio

Objetivo: En pentesting real, la información del objetivo (nombres, fechas, mascotas, empresa) permite crear wordlists muy específicas y efectivas.

01

Escenario: tenemos información del objetivo

bash — wordlist personalizada

# Datos del objetivo obtenidos por OSINT:
# Nombre: Maria Garcia, nació en 1988, mascota: Luna, empresa: Acme

cat > ~/john-lab/wordlists/objetivo.txt << EOF
maria
Maria
MARIA
garcia
Garcia
luna
Luna
acme
Acme
1988
maria1988
Maria1988
mgarcia
MGarcia
luna88
Luna88
acme2024
Acme2024
maria.garcia
mariagarcia
EOF

# Combinarlo con reglas para más variaciones
john --format=raw-md5 --wordlist=~/john-lab/wordlists/objetivo.txt \
  --rules=Wordlist ~/john-lab/hashes/ej1.txt

# Herramienta específica para esto: cupp (Common User Passwords Profiler)
sudo apt install -y cupp
cupp -i   # Modo interactivo: te hace preguntas sobre el objetivo

02

Combinar múltiples wordlists

bash

# Combinar RockYou + wordlist personalizada en una sola
cat /usr/share/wordlists/rockyou.txt ~/john-lab/wordlists/objetivo.txt \
  > ~/john-lab/wordlists/combinada.txt

# Eliminar duplicados y ordenar
sort -u ~/john-lab/wordlists/combinada.txt > ~/john-lab/wordlists/combinada_uniq.txt
wc -l ~/john-lab/wordlists/combinada_uniq.txt

🔨 Lab 7

/ETC/SHADOW
Contraseñas reales de Linux

El archivo /etc/shadow almacena los hashes de contraseñas de usuarios Linux. Aprende a usar unshadow, identificar el tipo de hash y crackear contraseñas de sistema.

Nivel avanzado⏱ 35 minunshadow · shadow · salt

⚠ Entorno controlado: Este lab se realiza con una VM vulnerable (Metasploitable2 o similar) o simulando los archivos localmente. Nunca en sistemas en producción.

Checklist — Lab 70 / 5

Entender el formato de /etc/shadow

Crear archivos passwd y shadow de laboratorio

Usar unshadow para combinar los archivos

Crackear hashes MD5crypt ($1$)

Intentar crackear SHA512crypt ($6$) — más lento

Formato de /etc/shadow

Cada línea del shadow tiene 9 campos separados por dos puntos. El campo de contraseña tiene el formato $tipo$sal$hash:

formato /etc/shadow

# usuario:$tipo$sal$hash:ultimocambio:min:max:aviso:inactivo:expirado:
root:$6$rounds=5000$salt$hashlargosha512:19000:0:99999:7:::
alice:$1$xyz12345$hashmd5crypt:18500:0:99999:7:::
bob:$2y$10$salt$hashbcrypt:18500:0:99999:7:::
charlie:!:18000::::::     # ! = cuenta bloqueada, sin contraseña
daemon:*:1::::::           # * = sin login

# Prefijos de tipo:
# $1$  = MD5crypt (antiguo Linux)     → John: md5crypt
# $5$  = SHA-256crypt                  → John: sha256crypt
# $6$  = SHA-512crypt (Linux moderno)  → John: sha512crypt
# $2y$ = bcrypt                        → John: bcrypt
# $y$  = yescrypt (Ubuntu 22.04+)      → John: yescrypt

EJERCICIO 7.1Simular y crackear /etc/shadow con MD5cryptMedio

Objetivo: Crear archivos passwd y shadow de laboratorio con hashes MD5crypt ($1$), combinarlos con unshadow y crackearlos.

01

Generar hashes MD5crypt reales con openssl

bash

# Generar hashes MD5crypt ($1$) con openssl
# openssl passwd -1 -salt "SALT" "password"
openssl passwd -1 -salt "abc12345" "password"
$1$abc12345$oGNYzFXFYPFRyFVrqhOiS/

openssl passwd -1 -salt "xyz99999" "123456"
$1$xyz99999$H9YAVkHxLlzHLUxdBMIv50

openssl passwd -1 -salt "mno55555" "qwerty"
$1$mno55555$somehashedvalue

02

Crear los archivos passwd y shadow del laboratorio

bash

cat > ~/john-lab/shadow-lab/passwd << EOF
root:x:0:0:root:/root:/bin/bash
alice:x:1001:1001:Alice Garcia:/home/alice:/bin/bash
bob:x:1002:1002:Bob Martinez:/home/bob:/bin/bash
carlos:x:1003:1003:Carlos Lopez:/home/carlos:/bin/bash
EOF

# Usar los hashes generados en el paso anterior
cat > ~/john-lab/shadow-lab/shadow << EOF
root:$1$abc12345$oGNYzFXFYPFRyFVrqhOiS/:19000:0:99999:7:::
alice:$1$xyz99999$H9YAVkHxLlzHLUxdBMIv50:19000:0:99999:7:::
bob:$1$mno55555$ReplaceConHashReal:19000:0:99999:7:::
carlos:$1$pqr11111$ReplaceConHashReal:19000:0:99999:7:::
EOF

03

Usar unshadow y atacar con John

bash

# unshadow combina passwd + shadow en el formato que John necesita
unshadow ~/john-lab/shadow-lab/passwd ~/john-lab/shadow-lab/shadow \
  > ~/john-lab/shadow-lab/combined.txt

cat ~/john-lab/shadow-lab/combined.txt
root:$1$abc12345$oGNYzFXFYPFRyFVrqhOiS/:0:0:root:/root:/bin/bash
alice:$1$xyz99999$H9YAVkHxLlzHLUxdBMIv50:1001:1001:Alice Garcia:...

# Primero modo Single (usa nombres: root, alice, bob, carlos)
john --single ~/john-lab/shadow-lab/combined.txt

# Luego diccionario con RockYou
john --wordlist=/usr/share/wordlists/rockyou.txt ~/john-lab/shadow-lab/combined.txt

# Ver resultados
john --show ~/john-lab/shadow-lab/combined.txt
root:password
alice:123456

EJERCICIO 7.2Lab real con Metasploitable2Avanzado

Objetivo: Aplicar el proceso completo contra una VM Metasploitable2 real. Las contraseñas son deliberadamente débiles para practicar.

bash — desde Kali contra Metasploitable2 (IP: 192.168.56.101)

# 1. Obtener acceso a la VM (credenciales por defecto: msfadmin/msfadmin)
ssh msfadmin@192.168.56.101

# 2. Dentro de la VM, copiar los archivos
cat /etc/passwd     # ver contenido
sudo cat /etc/shadow  # requiere sudo o root

# 3. Desde Kali, copiar los archivos por SCP
scp msfadmin@192.168.56.101:/etc/passwd ~/john-lab/shadow-lab/msf_passwd
scp msfadmin@192.168.56.101:/etc/shadow ~/john-lab/shadow-lab/msf_shadow

# 4. Combinar y atacar
unshadow ~/john-lab/shadow-lab/msf_passwd ~/john-lab/shadow-lab/msf_shadow \
  > ~/john-lab/shadow-lab/msf_combined.txt
john --wordlist=/usr/share/wordlists/rockyou.txt ~/john-lab/shadow-lab/msf_combined.txt

# Metasploitable2 tiene contraseñas muy débiles — encontrarás:
msfadmin  (msfadmin)
user      (user)
service   (service)
postgres  (postgres)
klog      (123456789)
sys       (batman)

🔨 Lab 8

ARCHIVOS PROTEGIDOS
ZIP, RAR, PDF y Office

John incluye herramientas para extraer el hash de archivos protegidos con contraseña. Una vez extraído el hash, el proceso de cracking es idéntico al de cualquier otro hash.

Nivel avanzado⏱ 30 minzip2john · pdf2john · office2john

Checklist — Lab 80 / 4

Crear un ZIP con contraseña y crackearlo con zip2john

Extraer y crackear hash de un PDF protegido

Crackear un documento Office (docx/xlsx) protegido

Conocer los modos Hashcat para cada tipo de archivo

EJERCICIO 8.1Crackear archivos ZIP con contraseñaMedio

Objetivo: Crear un archivo ZIP protegido, extraer su hash con zip2john y crackearlo.

01

Crear un ZIP protegido de prueba

bash

cd ~/john-lab
# Crear un archivo de texto de prueba
echo "Datos confidenciales del laboratorio" > secreto.txt

# Crear ZIP con contraseña "monkey" (está en RockYou)
zip -e -P monkey archivo_protegido.zip secreto.txt
  adding: secreto.txt (stored 0%)

# Verificar que está protegido
unzip -l archivo_protegido.zip
Archive:  archivo_protegido.zip
  Length      Date    Time    Name
      38  2024-01-15 11:00   secreto.txt

02

Extraer el hash con zip2john

bash

zip2john archivo_protegido.zip > hashes/zip_hash.txt
cat hashes/zip_hash.txt
archivo_protegido.zip/secreto.txt:$pkzip2$1*2*2*0*...*$/pkzip2$:secreto.txt:archivo_protegido.zip
# El hash $pkzip2$ es el que John debe crackear

03

Crackear el hash del ZIP

bash

# John auto-detecta el formato pkzip2
john --wordlist=/usr/share/wordlists/rockyou.txt hashes/zip_hash.txt

Loaded 1 password hash (PKZIP [32/64])
monkey           (archivo_protegido.zip/secreto.txt)
1g 0:00:00:00 DONE (2024-01-15 11:05)

# Verificar y descomprimir con la contraseña encontrada
john --show hashes/zip_hash.txt
unzip -P monkey archivo_protegido.zip
cat secreto.txt

EJERCICIO 8.2Crackear PDF protegido con contraseñaMedio

Objetivo: Usar pdf2john para extraer el hash de un PDF con contraseña y crackearlo.

01

Crear PDF protegido con qpdf

bash

sudo apt install -y qpdf

# Crear un PDF simple de prueba
convert -size 200x100 xc:white -annotate 0 "Laboratorio John" /tmp/lab.pdf 2>/dev/null
# Alternativa si no tienes convert:
echo "PDF de prueba" | enscript -p /tmp/lab.ps 2>/dev/null && ps2pdf /tmp/lab.ps /tmp/lab.pdf

# Proteger el PDF con contraseña "dragon" (está en RockYou)
qpdf --encrypt dragon dragon 128 -- /tmp/lab.pdf ~/john-lab/lab_protegido.pdf

02

Extraer hash y crackear

bash

# Extraer el hash del PDF
pdf2john ~/john-lab/lab_protegido.pdf > ~/john-lab/hashes/pdf_hash.txt
cat ~/john-lab/hashes/pdf_hash.txt
lab_protegido.pdf:$pdf$4*4*128*...::

# Crackear con John
john --wordlist=/usr/share/wordlists/rockyou.txt ~/john-lab/hashes/pdf_hash.txt
dragon           (lab_protegido.pdf)

# Verificar abriendo el PDF con la contraseña encontrada
qpdf --decrypt --password=dragon ~/john-lab/lab_protegido.pdf ~/john-lab/lab_descifrado.pdf

EJERCICIO 8.3Documentos Office (Word, Excel)Avanzado

Objetivo: office2john extrae el hash de documentos Word, Excel y PowerPoint protegidos con contraseña.

bash

# Crear un documento Word protegido en LibreOffice (desde la línea de comandos)
python3 -c "
from docx import Document
doc = Document()
doc.add_paragraph('Documento de laboratorio confidencial')
doc.save('/tmp/lab_doc.docx')
" 2>/dev/null || echo "Usa LibreOffice para crear un .docx protegido manualmente"

# Si tienes un .docx protegido (creado con Word o LibreOffice):
office2john documento_protegido.docx > ~/john-lab/hashes/office_hash.txt
cat ~/john-lab/hashes/office_hash.txt
documento_protegido.docx:$office$*2013*...*

# Crackear (Office 2013+ es lento — bcrypt-based)
john --wordlist=/usr/share/wordlists/rockyou.txt ~/john-lab/hashes/office_hash.txt

# Tipos de hash Office según versión:
# $office$*2007* → Office 2007  (más rápido)
# $office$*2010* → Office 2010
# $office$*2013* → Office 2013+ (muy lento)
# Estrategia: wordlist pequeña (top 1000) para Office 2013+
head -1000 /usr/share/wordlists/rockyou.txt > /tmp/top1000.txt
john --wordlist=/tmp/top1000.txt ~/john-lab/hashes/office_hash.txt

🔨 Lab 9

REGLAS PERSONALIZADAS
Escribir tus propias reglas en john.conf

Cuando los conjuntos de reglas integrados no son suficientes, puedes escribir tus propias reglas en john.conf. Fundamental para ataques dirigidos con políticas de contraseñas conocidas.

Nivel avanzado⏱ 40 minjohn.conf · reglas custom

Checklist — Lab 90 / 4

Localizar y editar john.conf

Crear una sección de reglas corporativas

Probar las reglas con --stdout antes de atacar

Aplicar reglas personalizadas a un hash objetivo

EJERCICIO 9.1Crear reglas corporativas en john.confAvanzado

Objetivo: Muchas empresas tienen políticas de contraseñas específicas (mínimo 8 caracteres, 1 mayúscula, 1 número). Crear reglas que imiten esas políticas acelera enormemente el cracking.

01

Localizar el archivo john.conf

bash

# Localizar john.conf (puede estar en varios lugares)
find / -name "john.conf" 2>/dev/null
/etc/john/john.conf
/usr/share/john/john.conf

# Ver las reglas que ya existen
grep "^\[List.Rules" /etc/john/john.conf
[List.Rules:Single]
[List.Rules:Wordlist]
[List.Rules:Extra]
[List.Rules:Jumbo]

# Hacer una copia de seguridad antes de editar
sudo cp /etc/john/john.conf /etc/john/john.conf.bak

02

Añadir sección de reglas corporativas

bash

# Añadir al final de john.conf estas reglas corporativas
sudo tee -a /etc/john/john.conf << 'EOF'

[List.Rules:Corporativa]
# Política: 1 mayúscula + 6 letras + 1 número al final
c $0
c $1
c $2
c $3
c $4
c $5
c $6
c $7
c $8
c $9
# Primera mayúscula + año actual al final
c $2$0$2$4
c $2$0$2$3
c $2$0$2$2
# Primera mayúscula + "!" al final
c $!
# Primera mayúscula + número + símbolo
c $1$!
c $2$0$2$4$!
# Leetspeak completo: a→@ e→3 i→! o→0 s→$
sa@ se3 si! so0 ss$
# Leetspeak + primera mayúscula
c sa@ se3 so0
# Invertir + primera mayúscula
r c
# Duplicar con número
d $1
EOF

03

Verificar las transformaciones con --stdout

bash

# Ver qué genera la regla Corporativa con palabras de prueba
printf "password\nwelcome\nadmin\nsecret\n" > /tmp/test_words.txt
john --wordlist=/tmp/test_words.txt --rules=Corporativa --stdout 2>/dev/null
Password0
Password1
Password2
...
Password2024
Password!
Password1!
Password2024!
p@ssw0rd!
P@ssword
drowssap
...
Welcome1
Welcome2024
Welcome!
Admin1
Admin2024
Secret2024

# Contar total de variaciones generadas
john --wordlist=/tmp/test_words.txt --rules=Corporativa --stdout 2>/dev/null | wc -l

04

Usar la regla personalizada en un ataque real

bash

# Crear un hash de prueba con contraseña corporativa "Welcome2024"
echo -n "Welcome2024" | md5sum
8f14e45fceea167a5a36dedd4bea2543  -

echo "8f14e45fceea167a5a36dedd4bea2543" > ~/john-lab/hashes/corporativo.txt

# Sin regla especial — fallará (no está en RockYou puro)
john --format=raw-md5 --wordlist=/usr/share/wordlists/rockyou.txt \
  --pot=/dev/null ~/john-lab/hashes/corporativo.txt

# Con regla Corporativa — lo encontrará
john --format=raw-md5 --wordlist=/usr/share/wordlists/rockyou.txt \
  --rules=Corporativa --pot=/dev/null ~/john-lab/hashes/corporativo.txt
Welcome2024       (8f14e45fceea167a5a36dedd4bea2543)

🏆 Lab 10

EJERCICIO FINAL
Auditoría completa de contraseñas Linux

Escenario completo de auditoría. Tienes acceso a los archivos passwd y shadow de un servidor comprometido. Tu misión: crackear todas las contraseñas posibles y documentar los hallazgos.

Nivel avanzado⏱ 60 minFlujo completo

📋 Escenario: Durante un pentest has obtenido acceso inicial a un servidor Linux y has podido extraer los archivos /etc/passwd y /etc/shadow. El servidor tiene 8 usuarios con contraseñas de diferentes complejidades. Tu objetivo es crackear el mayor número posible en el menor tiempo.

Checklist — Lab 10 (Ejercicio Final)0 / 8

Preparar los archivos passwd y shadow del escenario

Ejecutar unshadow para combinar los archivos

Aplicar modo Single (encontrará las más débiles)

Aplicar diccionario RockYou (el grueso)

Aplicar reglas Wordlist + Corporativa

Fuerza bruta incremental Digits para posibles PINs

Documentar resultados con --show

Generar informe final de auditoría

Fase 1 — Preparar el escenario

01

Crear los archivos del servidor comprometido

bash — preparar escenario

mkdir -p ~/john-lab/final
cd ~/john-lab/final

# Archivo /etc/passwd del servidor
cat > passwd_servidor << EOF
root:x:0:0:root:/root:/bin/bash
sysadmin:x:1000:1000:System Admin:/home/sysadmin:/bin/bash
jgarcia:x:1001:1001:Juan Garcia:/home/jgarcia:/bin/bash
mlopez:x:1002:1002:Maria Lopez:/home/mlopez:/bin/bash
dbadmin:x:1003:1003:DB Admin:/home/dbadmin:/bin/bash
webuser:x:1004:1004:Web User:/home/webuser:/bin/bash
backup:x:1005:1005:Backup Service:/home/backup:/bin/bash
guest:x:1006:1006:Guest User:/home/guest:/bin/bash
EOF

# Generar los hashes MD5crypt para las contraseñas del escenario
# (En el laboratorio real vendrían directamente de /etc/shadow)
python3 - << 'PYEOF'
import crypt, hmac
users = [
    ("root",     "root"),
    ("sysadmin", "sysadmin"),
    ("jgarcia",  "password"),
    ("mlopez",   "Maria2024"),
    ("dbadmin",  "Db@dmin1"),
    ("webuser",  "web123"),
    ("backup",   "backup2024"),
    ("guest",    "guest"),
]
for user, pwd in users:
    h = crypt.crypt(pwd, crypt.mksalt(crypt.METHOD_MD5))
    print(f"{user}:{h}:19000:0:99999:7:::")
PYEOF
# Copia el output anterior al archivo shadow_servidor

02

Crear el archivo shadow con los hashes generados

bash

# Pegar el output del script Python anterior en este archivo
# Los hashes serán únicos cada vez que ejecutes el script
python3 -c "
import crypt
users = [
    ('root',     'root'),
    ('sysadmin', 'sysadmin'),
    ('jgarcia',  'password'),
    ('mlopez',   'Maria2024'),
    ('dbadmin',  'Db@dmin1'),
    ('webuser',  'web123'),
    ('backup',   'backup2024'),
    ('guest',    'guest'),
]
with open('shadow_servidor', 'w') as f:
    for user, pwd in users:
        h = crypt.crypt(pwd, crypt.mksalt(crypt.METHOD_MD5))
        f.write(f'{user}:{h}:19000:0:99999:7:::\n')
print('shadow_servidor creado correctamente')
"

Fase 2 — Proceso de cracking

03

unshadow + análisis inicial

bash

unshadow passwd_servidor shadow_servidor > combined_final.txt
cat combined_final.txt

# ¿Qué tipo de hash tienen? Mirar el prefijo
cut -d: -f2 combined_final.txt | cut -c1-4
$1$   ← MD5crypt en todos los usuarios

# Cuántos usuarios vamos a atacar
wc -l combined_final.txt
8

04

PASO 1: Modo Single (instantáneo)

bash

john --single combined_final.txt
# Esperamos encontrar: root, sysadmin, guest
# Sus contraseñas son iguales o variaciones de sus nombres
john --show combined_final.txt
root:root
sysadmin:sysadmin
guest:guest
3 password hashes cracked, 5 left

05

PASO 2: Diccionario RockYou (el grueso)

bash

john --wordlist=/usr/share/wordlists/rockyou.txt combined_final.txt
# Esperamos encontrar: jgarcia (password), webuser (web123)
john --show combined_final.txt
root:root
sysadmin:sysadmin
jgarcia:password
webuser:web123
guest:guest
5 password hashes cracked, 3 left

06

PASO 3: Reglas (mangled passwords)

bash

# Wordlist + reglas integradas
john --wordlist=/usr/share/wordlists/rockyou.txt --rules=Wordlist combined_final.txt

# Si tenemos la regla Corporativa del Lab 9:
john --wordlist=/usr/share/wordlists/rockyou.txt --rules=Corporativa combined_final.txt
# Esperamos encontrar: mlopez (Maria2024), backup (backup2024)
john --show combined_final.txt
mlopez:Maria2024
backup:backup2024
7 password hashes cracked, 1 left

07

PASO 4: Ataque dirigido para el último hash

bash

# Queda dbadmin con contraseña "Db@dmin1" (leetspeak + número)
# Intentar con reglas Extra o Jumbo:
john --wordlist=/usr/share/wordlists/rockyou.txt --rules=Extra combined_final.txt
john --wordlist=/usr/share/wordlists/rockyou.txt --rules=Jumbo combined_final.txt

# También podemos crear una wordlist dirigida basada en "dbadmin"
echo "dbadmin" | john --stdin --rules=Corporativa --stdout 2>/dev/null > /tmp/dbadmin_wl.txt
john --wordlist=/tmp/dbadmin_wl.txt combined_final.txt

# Resultado final
john --show combined_final.txt
root:root
sysadmin:sysadmin
jgarcia:password
mlopez:Maria2024
dbadmin:Db@dmin1
webuser:web123
backup:backup2024
guest:guest
8 password hashes cracked, 0 left

Fase 3 — Informe de auditoría

08

Generar informe de resultados

bash

# Generar informe estructurado
cat > ~/john-lab/final/informe_auditoria.txt << EOF
======================================================
INFORME DE AUDITORÍA DE CONTRASEÑAS
Fecha: $(date)
Servidor: servidor-lab-final
======================================================

RESULTADOS:
$(john --show combined_final.txt)

ANÁLISIS DE SEGURIDAD:
- Contraseñas iguales al username: root, sysadmin, guest (CRÍTICO)
- Contraseñas en diccionario sin modificar: jgarcia, webuser (ALTO)
- Contraseñas con mangling básico: mlopez, backup (MEDIO)
- Contraseñas con complejidad: dbadmin (BAJO - aun crackeada)

RECOMENDACIONES:
1. Implementar política de contraseñas mínimo 12 caracteres
2. Prohibir contraseñas iguales o derivadas del username
3. Activar fail2ban y bloqueo por intentos fallidos
4. Implementar MFA (autenticación de dos factores)
5. Usar herramientas de auditoría periódica (lynis, passwd-quality)
======================================================
EOF

cat ~/john-lab/final/informe_auditoria.txt

🎯 ¡Laboratorio completado! Has dominado el flujo completo de auditoría de contraseñas con John the Ripper: desde la instalación hasta el informe final. El siguiente paso es practicar en plataformas como HackTheBox, TryHackMe o VulnHub con máquinas reales.

Resumen de comandos clave

cheatsheet rápido — John the Ripper

# ─── FLUJO COMPLETO RECOMENDADO ────────────────────────────────

# 1. Single (más rápido, basado en username)
john --single hash.txt

# 2. Diccionario puro
john --wordlist=/usr/share/wordlists/rockyou.txt hash.txt

# 3. Diccionario + reglas (el más efectivo)
john --wordlist=/usr/share/wordlists/rockyou.txt --rules=Wordlist hash.txt
john --wordlist=/usr/share/wordlists/rockyou.txt --rules=Jumbo hash.txt

# 4. Fuerza bruta Digits (para PINs)
john --incremental=Digits --max-length=8 hash.txt

# 5. Fuerza bruta alfanumérica (para contraseñas cortas)
john --incremental=Alnum --min-length=4 --max-length=6 hash.txt

# ─── UTILIDADES ────────────────────────────────────────────────

# Ver resultados guardados
john --show hash.txt
john --show --format=raw-md5 hash.txt

# Listar formatos disponibles
john --list=formats | grep -i "md5\|sha\|bcrypt\|ntlm"

# Ver reglas disponibles
john --list=rules

# Usar múltiples cores
john --fork=4 --wordlist=rockyou.txt hash.txt

# Linux shadow: combinar passwd + shadow
unshadow /etc/passwd /etc/shadow > combined.txt
john --wordlist=rockyou.txt combined.txt

# Archivos protegidos
zip2john archivo.zip > hash.txt && john --wordlist=rockyou.txt hash.txt
pdf2john archivo.pdf > hash.txt && john --wordlist=rockyou.txt hash.txt
office2john doc.docx > hash.txt && john --wordlist=rockyou.txt hash.txt

JOHN THE RIPPER — COMPLETADO

Has completado los 10 laboratorios. Practica en entornos reales para afianzar los conocimientos.

TryHackMe → HackTheBox → VulnHub →