John the Ripper: guía de crackeo de contraseñas y hashes

John the Ripper es una herramienta de código abierto para auditoría y recuperación de contraseñas. Detecta automáticamente el tipo de hash y aplica distintos modos de ataque (diccionario, fuerza bruta incremental, combinado) para obtener la contraseña en texto claro. Es el estándar de facto en pentesting cuando quieres comprobar la fortaleza real de las contraseñas almacenadas.

Qué es John the Ripper y para qué sirve

John the Ripper (JtR) nació en 1996 dentro del proyecto Openwall y hoy sigue siendo uno de los crackers de contraseñas más usados en auditorías de seguridad. Su punto fuerte es la autodetección de formatos de hash: le pasas un fichero y él identifica solo si estás ante MD5, SHA-1, bcrypt, NTLM, etc., sin que tengas que especificarlo (aunque puedes forzarlo con --format).

La versión Jumbo (la que viene en Kali Linux) soporta más de 400 tipos de hash y cifrado, desde contraseñas Unix (/etc/shadow) hasta archivos ZIP, PDF, wallets de criptomonedas, hashes NTLM de Windows, capturas WPA, bases de datos MySQL/PostgreSQL y bastante más.

En pentesting se usa sobre todo para:

• Comprobar si los hashes extraídos de una base de datos comprometida son «craqueables» con recursos razonables.
• Auditar la política de contraseñas de una organización (¿cuántas se rompen en menos de 1 hora?).
• Recuperar contraseñas propias olvidadas de archivos ZIP, documentos Office, etc.

«John the Ripper is an Open Source password security auditing and password recovery tool available for many operating systems. Designed to detect weak Unix passwords.»

— Openwall / John the Ripper official page

Instalación

Kali Linux (ya incluido)

En Kali, JtR Jumbo viene preinstalado. Verifica la versión:

john --version
# Ejemplo de salida: John the Ripper 1.9.0-jumbo-1 OMP [linux-gnu 64-bit ...]

Instalación en Debian/Ubuntu via apt

sudo apt update
sudo apt install john

Este paquete suele ser la versión «community», sin todos los formatos de Jumbo. Para máxima cobertura, mejor compila desde fuentes.

Compilar John the Ripper Jumbo desde fuentes

# Dependencias básicas
sudo apt install build-essential libssl-dev libgmp-dev libpcap-dev zlib1g-dev

# Clonar repositorio oficial
git clone https://github.com/openwall/john.git
cd john/src

# Compilar (detecta automáticamente OpenMP para multi-hilo)
./configure && make -s clean && make -sj4

# El binario queda en ../run/
../run/john --version

La versión compilada soporta GPU (con --device) si tienes OpenCL instalado, y eso multiplica bastante la velocidad en ataques de fuerza bruta.

Sintaxis básica y opciones principales

Modos de ataque en detalle

Modo Wordlist (diccionario)

Es el más usado en pentesting porque la mayoría de usuarios elige contraseñas reales. El fichero más conocido es rockyou.txt, que en Kali está en /usr/share/wordlists/rockyou.txt.gz (descomprime con gunzip).

# Ataque con rockyou
john --wordlist=/usr/share/wordlists/rockyou.txt hashes.txt

# Con reglas (recomendado: prueba variaciones leetspeak, mayúsculas, números al final)
john --wordlist=/usr/share/wordlists/rockyou.txt --rules hashes.txt

Las reglas (--rules) son transformaciones definidas en john.conf que convierten «password» en «P@ssw0rd», «Password1», «PASSWORD», etc. Multiplican el diccionario sin ocupar disco extra.

Modo Single Crack

John usa el GECOS (campo de nombre completo) y el login del fichero de contraseñas para generar candidatos personalizados. Yo siempre lo lanzo primero: es rapidísimo y sorprendentemente efectivo con usuarios que eligen su propio nombre como contraseña.

john --single hashes.txt

Modo Incremental (fuerza bruta)

Genera todas las combinaciones posibles a partir de un charset. El charset Alpha solo usa letras, Alnum añade dígitos y All incluye caracteres especiales. Es el modo más lento de todos: úsalo como último recurso o solo para contraseñas cortas (<= 6 caracteres).

# Fuerza bruta con alfabeto alfanumérico
john --incremental=Alnum hashes.txt

# Solo dígitos (PINs numéricos)
john --incremental=Digits hashes.txt

Ejemplo práctico en laboratorio: crackear /etc/shadow

Este flujo completo se ejecuta sobre una máquina virtual propia o un laboratorio de práctica como las plataformas de hacking ético que recomendamos. Nunca en sistemas ajenos.

Paso 1 — Combinar passwd y shadow con unshadow

John necesita el fichero combinado para asociar hashes con nombres de usuario:

# En la máquina objetivo (o como root en el lab)
unshadow /etc/passwd /etc/shadow > hashes_shadow.txt

# Verificar que el fichero tiene el formato correcto
head -3 hashes_shadow.txt
# root:$6$xyz...:0:0:root:/root:/bin/bash
# alice:$6$abc...:1001:1001:Alice:/home/alice:/bin/bash

Paso 2 — Identificar el formato de hash

# $6$ = sha512crypt (Linux moderno)
# $5$ = sha256crypt
# $1$ = md5crypt
# $2y$ o $2b$ = bcrypt

# John suele detectarlo solo; para forzarlo:
john --format=sha512crypt hashes_shadow.txt --wordlist=/usr/share/wordlists/rockyou.txt

Paso 3 — Ejecutar ataque por fases

# Fase 1: Single (rápido)
john --single hashes_shadow.txt

# Fase 2: Diccionario con reglas
john --wordlist=/usr/share/wordlists/rockyou.txt --rules hashes_shadow.txt

# Fase 3: Diccionario adicional (seclists, cewl, etc.)
john --wordlist=/usr/share/seclists/Passwords/Common-Credentials/10-million-password-list-top-100000.txt hashes_shadow.txt

Paso 4 — Ver resultados

# Muestra contraseñas ya crackeadas (lee el fichero .pot)
john --show hashes_shadow.txt

# Ejemplo de salida:
# alice:password123:1001:1001:Alice:/home/alice:/bin/bash
# bob:qwerty:1002:1002:Bob:/home/bob:/bin/bash
# 2 password hashes cracked, 3 left

Paso 5 — Crackear hashes NTLM (Windows)

Si en un pentest de Active Directory obtienes hashes NTLM (de secretsdump.py o similar), el flujo es:

# Fichero hashes_ntlm.txt con formato usuario:hash
# Ejemplo contenido: Administrator:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::

john --format=nt --wordlist=/usr/share/wordlists/rockyou.txt hashes_ntlm.txt
john --show --format=nt hashes_ntlm.txt

Extraer hashes de otros tipos de ficheros

# Hash de fichero ZIP protegido
zip2john archivo.zip > hash_zip.txt
john --wordlist=/usr/share/wordlists/rockyou.txt hash_zip.txt

# Hash de PDF
pdf2john documento.pdf > hash_pdf.txt
john --wordlist=/usr/share/wordlists/rockyou.txt hash_pdf.txt

# Hash de clave SSH privada protegida con passphrase
ssh2john id_rsa > hash_ssh.txt
john --wordlist=/usr/share/wordlists/rockyou.txt hash_ssh.txt

Los scripts *2john vienen incluidos en John the Ripper Jumbo y convierten cualquier formato propietario en el formato interno de JtR.

Vídeo recomendado

Tutorial en español del canal Date Un Hack que cubre instalación, modos de ataque y ejemplos reales:

Cómo proteger las contraseñas frente a John the Ripper

Entender cómo funciona el crackeo es la mejor forma de diseñar defensas eficaces. Si te interesa la perspectiva ofensiva completa, consulta nuestra guía completa de hacking web.

1. Usa algoritmos de hash lentos (key stretching)

MD5 y SHA-1 fueron diseñados para ser rápidos: una GPU moderna puede probar miles de millones de hashes MD5 por segundo. Los algoritmos modernos incorporan un coste computacional deliberado:

• bcrypt: factor de coste configurable (12 es el mínimo recomendado hoy). Limita la velocidad de crackeo a unos pocos miles de intentos por segundo incluso con GPU.
• Argon2id: ganador del Password Hashing Competition (2015). Configurable en tiempo de CPU y uso de memoria; resistente a ataques con hardware especializado (ASIC/FPGA).
• scrypt: también memory-hard; se usa en algunos sistemas Unix modernos.
• PBKDF2: estándar NIST; inferior a los anteriores pero muy soportado (JWT, LUKS, etc.).

En PHP usa password_hash($pass, PASSWORD_BCRYPT) o PASSWORD_ARGON2ID. En Python, bcrypt o passlib. En aplicaciones web modernas, delega en el framework (Django usa PBKDF2-SHA256 por defecto; puedes configurarlo a Argon2).

2. Salt único por usuario

Un salt aleatorio de al menos 16 bytes hace que dos usuarios con la misma contraseña acaben con hashes completamente distintos. Esto invalida las rainbow tables y obliga a crackear cada hash por separado. bcrypt, Argon2 y scrypt incluyen el salt en el hash de salida, así que no tienes que gestionarlo tú.

3. Contraseñas largas y entropía alta

Una contraseña de 8 caracteres alfanuméricos tiene unos 47 bits de entropía. Una passphrase de 4 palabras aleatorias (estilo Diceware) tiene unos 51 bits con solo caracteres básicos, pero es mucho más resistente a ataques de reglas. La longitud importa más que la complejidad arbitraria, en mi opinión bastante más de lo que la mayoría de políticas corporativas asume.

• Política mínima recomendada: 12 caracteres, sin restricción de tipo (deja que el usuario use espacios y caracteres especiales).
• Mejor: passphrases largas tipo «cielo-rojo-gato-veloz-2026».

4. Autenticación multifactor (MFA)

Aunque un atacante crackee la contraseña, el MFA (TOTP, clave de seguridad FIDO2) bloquea el acceso. En entornos corporativos es la defensa con más impacto contra el robo de credenciales. Aprende más en nuestro curso de hacking web.

5. Detección y respuesta

• Monitoriza intentos de autenticación fallidos (rate limiting, bloqueo temporal, alertas SIEM).
• Usa Have I Been Pwned o servicios equivalentes para detectar si las credenciales de tus usuarios han aparecido en brechas.
• Rota contraseñas de inmediato si detectas una brecha de base de datos.

Errores comunes y buenas prácticas

Errores frecuentes al usar John

• No especificar el formato cuando John falla: si el hash no se detecta automáticamente, usa --list=formats | grep -i <tipo> para encontrar el nombre exacto y pásalo con --format=.
• Olvidar ejecutar unshadow: si pasas /etc/shadow directamente sin combinarlo con /etc/passwd, John no puede asociar nombres de usuario y pierde funcionalidad en el modo Single.
• Interrumpir sin guardar sesión: John guarda el progreso automáticamente en ~/.john/john.rec. Si lo matas con Ctrl+C, puedes retomarlo con john --restore. No lo mates con kill -9.
• Ignorar el fichero .pot: John almacena contraseñas ya crackeadas en ~/.john/john.pot. Si relanzas el mismo ataque, salta los hashes ya resueltos automáticamente. Usa --show para consultarlos.
• Usar solo rockyou sin reglas: rockyou sin --rules prueba las palabras tal cual. La mayoría de usuarios añade números al final o cambia vocales por símbolos, y sin reglas te pierdes esas variantes.

Buenas prácticas profesionales

• Documenta siempre el scope y la autorización antes de ejecutar JtR en un pentest real.
• Usa Kali Linux o una VM dedicada para no mezclar herramientas de pentest con tu entorno de trabajo.
• Combina John con Hashcat para usar la GPU: John es superior en CPU y en gestión de reglas; Hashcat domina en ataques con GPU.
• Practica en entornos legales como HackTheBox, TryHackMe o VulnHub. Revisa nuestra lista de las mejores plataformas para practicar hacking ético.
• Mantén actualizado el Jumbo: el repositorio recibe actualizaciones frecuentes con nuevos formatos y optimizaciones.

Preguntas frecuentes

¿Es legal usar John the Ripper?

La herramienta en sí es legal: es software de código abierto con fines de auditoría. Lo que puede ser ilegal es su uso. En España, el artículo 197 bis del Código Penal sanciona el acceso sin autorización a sistemas informáticos ajenos y la interceptación de comunicaciones. Usar JtR para crackear hashes de un sistema o fichero que no te pertenece, o para el que no tienes autorización escrita, es un delito. Úsalo siempre en sistemas propios o con permiso explícito.

¿Qué diferencia hay entre John the Ripper y Hashcat?

Hashcat está optimizado para GPU y es más rápido en ataques de fuerza bruta masivos con hardware gráfico. John the Ripper es más versátil en CPU, tiene un motor de reglas muy potente integrado, incluye los scripts *2john para preparar hashes de múltiples formatos y resulta más sencillo de usar en un flujo de pentesting estándar. En la práctica, los pentesters usan ambas herramientas de forma complementaria.

¿Cuánto tarda John en crackear una contraseña?

Depende del algoritmo, la longitud de la contraseña, la potencia de la máquina y el diccionario. Un hash MD5 de una contraseña de 8 caracteres puede crackearse en segundos. Un hash bcrypt con factor de coste 12 puede tardar años con esa misma contraseña si no está en un diccionario conocido. Como referencia rápida: MD5/NTLM van velocísimo; sha512crypt va lento; bcrypt/Argon2 van muy lento a propósito.

¿Cómo sé qué formato de hash tengo?

Observa el prefijo del hash: $1$ es md5crypt, $2y$ o $2b$ es bcrypt, $5$ es sha256crypt, $6$ es sha512crypt. Los hashes NTLM son cadenas hexadecimales de 32 caracteres. También puedes usar hashid o hash-identifier (incluidas en Kali) para identificar el tipo automáticamente. John también detecta el formato solo en la mayoría de casos.

¿Puedo usar John para recuperar mi propia contraseña de un fichero ZIP olvidado?

Sí, ese es exactamente uno de los usos legítimos de la herramienta. Usa zip2john archivo.zip > hash.txt para extraer el hash y luego john --wordlist=... hash.txt para intentar recuperarla. Si la contraseña es compleja y no está en ningún diccionario, puede hacer falta un ataque incremental que tarde mucho tiempo. También existen servicios online para hashes de ficheros no sensibles. Para más contexto sobre técnicas de seguridad ofensiva, visita nuestra guía completa de hacking web.