1 Descifrando contraseñas con John the Ripper

1.1 Introducción

John the Ripper es una herramienta de código abierto diseñada para realizar ataques de fuerza bruta y descifrar contraseñas. Es ampliamente utilizada por profesionales de la seguridad informática para evaluar la fortaleza de las contraseñas y detectar vulnerabilidades en sistemas.

1.2 Instalación de la versión jumbo desde el código fuente

La versión jumbo, incluye soporte para una amplia variedad de formatos de hash, algoritmos de cracking avanzados y características adicionales.

Para instalar la versión jumbo de John the Ripper, puedes clonar el repositorio oficial de GitHub y compilarlo desde el código fuente:

Instalamos las dependencias necesarias para tener soporte para compilar con OpenSSL:

sudo apt update
sudo apt install libssl-dev

Puede ser que también sea necesario instalar la herramienta make para compilar el código:

sudo apt install build-essential

Descargamos el código fuente y compilamos John the Ripper:

git clone https://github.com/openwall/john.git

Nos situamos en el directorio src dentro de la carpeta del proyecto que hemos clonado y ejecutamos el script configure. Este script prepara el entorno de compilación y verifica que todas las dependencias necesarias estén presentes en el sistema.

cd john/src
./configure

Una vez que ha finalizado el script de configuración, procedemos a compilar el código fuente utilizando el comando make:

make -s clean && make -sj8

La opción -s suprime la salida detallada durante la compilación, mientras que -j8 permite que el proceso de compilación utilice 8 núcleos de CPU en paralelo, acelerando el proceso.

Si el proceso de compilación bien, se crearán los ejecutables de John y sus utilidades relacionadas en el directorio ../run/.

Puede ejecutar los tests que se incluyen con la herramienta para verificar que la instalación se ha realizado correctamente:

cd ../run
./john --test

Puede encontrar más información sobre el proceso de instalación en el documento oficial INSTALL del repositorio de GitHub del proyecto.

1.2.1 Creación de un alias

Para facilitar el uso de John the Ripper, puedes crear un alias en tu archivo de configuración de la shell (por ejemplo, .bashrc o .zshrc). Esto te permitirá ejecutar John desde cualquier ubicación en la terminal sin tener que navegar al directorio run cada vez.

Abre tu archivo de configuración de la shell con un editor de texto. Por ejemplo, si usas Bash:

nano ~/.bashrc

Añade la siguiente línea al final del archivo:

alias john='/ruta/a/john/run/john'

Reemplaza /ruta/a/john/run/john con la ruta completa al ejecutable de John the Ripper en tu sistema. Guarda el archivo y cierra el editor. Luego, recarga la configuración de la shell para que el alias esté disponible:

source ~/.bashrc

1.2.2 Configuración de la variable de entorno `PATH`

Otra opción es añadir el directorio run de John the Ripper a la variable de entorno PATH. Esto permitirá ejecutar John desde cualquier ubicación en la terminal sin necesidad de un alias.

Abre tu archivo de configuración de la shell con un editor de texto. Por ejemplo, si usas Bash:

nano ~/.bashrc

Añade la siguiente línea al final del archivo:

export PATH="/ruta/a/john/run:$PATH"

Reemplaza /ruta/a/john/run con la ruta completa al directorio run de John the Ripper en tu sistema.

Guarda el archivo y cierra el editor. Luego, recarga la configuración de la shell para que los cambios en PATH surtan efecto:

source ~/.bashrc

Ahora deberías poder ejecutar John the Ripper desde cualquier ubicación en la terminal simplemente escribiendo john.

1.3 Instalación mediante paquetes precompilados

En algunas distribuciones de Linux, John the Ripper está disponible en los repositorios oficiales. Puedes instalarlo utilizando el gestor de paquetes de tu sistema. Por ejemplo, en Debian o Ubuntu podemos instalarlo con el siguiente comando:

sudo apt update
sudo apt install john -y

1.4 Creación de un archivo de hash de contraseñas para pruebas

1.4.1 Crear un archivo de contraseñas a partir de `/etc/passwd` y `/etc/shadow`

Podemos crear un archivo de contraseñas a partir de los archivos /etc/passwd y /etc/shadow utilizando el siguiente comando:

sudo unshadow /etc/passwd /etc/shadow > hashes.txt

Esto combinará la información de ambos archivos y generará un archivo llamado hashes.txt que contiene los nombres de usuario y sus hashes de contraseña.

Por ejemplo, el contenido del archivo hashes.txt podría verse así:

usuario:$6$iP0B5yrxRxRXd8as$o...:1000:1000:usuario:/home/usuario:/usr/bin/zsh

1.4.2 Generar hashes de contraseñas

También podemos utilizar la herramienta mkpasswd para generar hashes de contraseñas que luego podemos intentar descifrar con John the Ripper.

Si estamos trabajando en Debian o Ubuntu, podemos instalar mkpasswd como parte del paquete whois:

sudo apt update
sudo apt install whois -y

Para consultar la lista de algoritmos de hash soportados por mkpasswd, podemos ejecutar el siguiente comando:

mkpasswd -m help

Deberíamos obteneruna lista similar a la siguiente:

Available methods:
yescrypt        Yescrypt
gost-yescrypt   GOST Yescrypt
scrypt          scrypt
bcrypt          bcrypt
bcrypt-a        bcrypt (obsolete $2a$ version)
sha512crypt     SHA-512
sha256crypt     SHA-256
sunmd5          SunMD5
md5crypt        MD5
bsdicrypt       BSDI extended DES-based crypt(3)
descrypt        standard 56 bit DES-based crypt(3)
nt              NT-Hash

1.4.3 Formatos utilizados por los métodos de cifrado

Cuando utilizamos una función de hash para cifrar una contraseña, el resultado incluye información sobre el algoritmo utilizado, los parámetros específicos, la sal (salt) y el hash resultante.

La salida debe tener un formato similar a este:

$id$params$salt$hash

Donde:

$id: Identifica el algoritmo de cifrado.
$params: Es opcional y cuando aparece representa un parámetro específico del algoritmo.
- Los algoritmos modernos: yescrypt y bcrypt usan este campo para definir la dificultad del cifrado.
$salt: Es una cadena aleatoria (sal) que evita que dos contraseñas iguales produzcan el mismo hash.
$hash: Es el resultado cifrado final.

Algoritmo	Identificador	Descripción
MD5	$1$	Obsoleto, no recomendado.
SHA-256	$5$	Cifrado seguro, más rápido que SHA-512.
SHA-512	$6$	Algoritmo por defecto en la mayoría de distribuciones modernas (Ubuntu, Debian).
yescrypt	$y$	Más moderno, resistente a ataques de fuerza bruta. Soportado en versiones recientes de PAM.
bcrypt	$2a$ , $2b$ , $2y$	Familia de algoritmos bcrypt (Blowfish)

Lecturas recomendadas:

Los siguientes artículos le ayudarán a entender mejor el uso de “sal” para mejorar la seguridad de las contraseñas almacenadas.

Adding Salt to Hashing: A Better Way to Store Passwords

Storing Passwords Safely: A Comprehensive Guide

Sal (criptografía). Wikipedia.

1.4.4 Ejemplo de creación de un hash con `yescrypt`

Con la opción -m o --method, podemos especificar el algoritmo de hash que queremos utilizar con mkpasswd.

Por ejemplo, para crear un hash de la contraseña 123456 con el algoritmo yescrypt, tendremos que ejecutar el siguiente comando:

mkpasswd -m yescrypt 123456

Obtendremos una salida similar a la siguiente:

$y$j9T$yFi38z1Rd0g/P3/FURKDL/$2muJ8gu2w4xF0gTHS5moWPotIqRbeI078m0zZ9vtVf3

Tenga en cuenta que no le estamos indicando un salt específico, por lo que mkpasswd generará uno aleatoriamente. Por lo tanto, cada vez que ejecute el comando, obtendrá un hash diferente para la misma contraseña.

Con la salida que hemos obtenido, podemos crear un archivo de texto llamado hashes.txt que contenga el hash generado. El archivo puede tener el nombre del usuario seguido de dos puntos y el hash de la contraseña, como se muestra a continuación:

usuario:$y$j9T$yFi38z1Rd0g/P3/FURKDL/$2muJ8gu2w4xF0gTHS5moWPotIqRbeI078m0zZ9vtVf3

1.5 Uso básico

Para utilizar John the Ripper, primero debes tener un archivo de contraseñas que deseas descifrar. Luego, puedes ejecutar el siguiente comando:

john <archivo_de_contraseñas>

John the Ripper intentará descifrar las contraseñas utilizando varios métodos de ataque.

Indicando el formato del hash de forma explícita

Puede ser que nos aparezca un mensaje de error indicando que no ha podido cargar el formato del hash utilizado en el archivo de contraseñas:

john pass.txt  

Using default input encoding: UTF-8
No password hashes loaded (see FAQ)

Si nos ocurre esto, podemos indicarle el formato que queremos utilizar de forma explícita utilizando la opción --format.

john --format=crypt pass.txt

El único inconveniente de esto es que si en el archivo de contraseñas hay hashes de diferentes formatos, John the Ripper va a intentar descifrarlos todos utilizando el formato que le hemos indicado.

1.6 Visión general de modos de John

Los modos principales de John the Ripper son:

Single crack: Utiliza información local (nombre de usuario, GECOS, rutas, etc.) para generar candidatos rápidos. Muy efectivo contra contraseñas derivadas del entorno del usuario.
Wordlist mode: Es el modo de diccionario, donde usa listas de palabras que pueden ser las contraseñas más comunes. Puede combinarse con reglas de mangling (--rules) que transforman las palabras (mayúsculas, añadir números, invertir, etc.) para generar más candidatos sin tener que añadir nuevas palabras a la lista.
Incremental mode: El modo incremental es una búsqueda por fuerza bruta que intenta todas las combinaciones posibles para una longitud dada, pero lo hace de forma inteligente. En lugar de probar las combinaciones en un orden arbitrario, usa tablas de frecuencia que indican qué caracteres y qué pares de caracteres son más comunes en contraseñas reales. Primero prueba las contraseñas más probables y deja las menos probables para el final. Es muy potente porque es exhaustivo, ya que examina todas las combinaciones, pero también es muy costoso en tiempo y en recursos.
Mask mode: Genera candidatos siguiendo una máscara definida por el usuario. Este modo es útil cuando se conoce la estructura de la contraseña. Por ejemplo, la estructura ?u?l?l?d?d, indica una contraseña que comienza con una letra mayúscula (?u), seguida de dos letras minúsculas (?l?l) y dos dígitos (?d?d). Algunas contraseñas que encajarían en esta máscara son Abc12, Xyz99 o Pqr45.
External mode: Permite motores de reglas complejos escritos en el lenguaje de reglas de John o en filtros externos; ideal para reglas personalizadas que no encajan en --rules.
Markov mode: Genera contraseñas basándose en tablas de probabilidad, que indican qué letra suele seguir a otra. En lugar de enumerar todas las combinaciones como el modo incremental, primero genera las cadenas más probables según esas probabilidades. Eso lo hace mucho más eficiente que el método de fuerza bruta puro, cuando las contraseñas tienden a seguir patrones estadísticos.
Regex mode : Genera contraseñas que coinciden con una expresión regular definida por el usuario. Es útil para atacar contraseñas que siguen patrones específicos.
Loopback mode: Utiliza las contraseñas que ya tienes descifradas en el archivo .pot como candidatas para intentar descifrar otras contraseñas. A partir de las contraseñas ya conocidas va generando variaciones.

John viene con conjuntos de reglas (/usr/share/john/rules/ o john/run/) y archivos de configuración (john.conf) que controlan modos avanzados.

Puede encontrar más información sobre los modos de uso en el documento oficial MODES del repositorio de GitHub del proyecto.

1.7 Ejemplos de uso de los modos principales

1.7.1 Modo Single crack

Este es el modo más rápido para intentar descifrar contraseñas basadas en información del usuario.

John toma nombres de usuario, GECOS, directorios home, etc., y aplica transformaciones sencillas (añadir dígitos, mayúsculas, invertir, etc.). Es el primer modo que deberías ejecutar en un auditoría porque es muy eficaz y rápido.

john --single hashes.txt

1.7.2 Modo Wordlist + Reglas de transformación

Diccionarios (wordlists)

Cuando instalamos John the Ripper, se incluye una wordlist básica, pero es recomendable crear nuestro propio archivo de diccionario o descargar algunos de los diccionarios que existen en Internet.

En Kali Linux puede instalar el paquete wordlists que incluye varias listas de palabras comunes como el famoso rockyou.txt:
```
sudo apt install wordlists -y
```
En este repositorio de GitHub podemos encontrar varias listas con millones de contraseñas comunes:
- https://github.com/danielmiessler/SecLists/tree/master/Passwords/Common-Credentials
En la web Weakpass también puede encontrar una gran variedad de listas de contraseñas para descargar.

Ejemplos

En este ejemplo vamos a utilizar la wordlist rockyou.txt para intentar descifrar los hashes contenidos en el archivo hashes.txt.

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

Para aplicar reglas de transformación a cada palabra de la wordlist, podemos usar la opción --rules:

Esto aplica el conjunto de reglas por defecto (mayúsculas, añadir números, duplicar, etc.) a cada entrada de la wordlist.

john --wordlist=/usr/share/wordlists/rockyou.txt --rules hashes.txt

1.7.2.1 Dónde se almacenan las reglas

Las reglas de transformación se encuentran en el archivo de configuración john.conf. Si hemos instalado Joh the Ripper con un paquete precompliado, podemos encontrar este archivo en la ruta /etc/john/john.conf.

Podemos buscar la sección [List.Rules:] dentro del archivo para ver las reglas definidas:

grep -n '\[List.Rules:' /etc/john/john.conf

El modificador -n es para que nos muestre el número de línea donde ha encontrado la coincidencia.

1.7.2.2 Cómo comprobar el funcionamiento de las reglas

Podemos crear un archivo de texto llamado diccionario.txt con las siguientes palabras:

admin
password123
querty

Una vez creado el archivo, podemos ejecutar el siguiente comando para ver cómo se aplican las reglas de transformación a cada palabra.

Para ver cómo se aplican las reglas por defecto ejecutamos:

john --wordlist=diccionario.txt --rules --stdout

Si queremos ver cómo se aplican las reglas del conjunto Jumbo, podemos ejecutar el siguiente comando:

john --wordlist=diccionario.txt --rules:Jumbo --stdout

Para aplicar varias reglas a la vez, podemos definir una regla que incluya todas las reglas que queremos utilizar. Por ejemplo, en nuestro archivo john.conf ya tenemos una regla llamada All que incluye varias reglas comunes.

[List.Rules:All]
.include [List.Rules:Jumbo]
.include [List.Rules:KoreLogic]
.include [List.Rules:T9]
.include [List.Rules:hashcat]

Para ver cómo se aplican todas las reglas definidas en All, podemos ejecutar el siguiente comando:

john --wordlist=diccionario.txt --rules:All --stdout

Puede encontrar más información sobre las reglas en el documento oficial RULES del repositorio de GitHub del proyecto.

1.7.3 Modo máscara para patrones conocidos

Este modo lo vamos a utilizar cuando conocemos el patrón de la contraseña. Por jemplo, si sabemos que la contraseña tiene una mayúscula seguida de 6 minúsculas y 2 dígitos, podemos definir una máscara para generar solo esas combinaciones.

Ejemplo: probar contraseñas con una mayúscula seguida de 6 minúsculas y 2 dígitos:

john --mask='?u?l?l?l?l?l?d?d' hashes.txt

Otros ejemplos de máscaras: - ?l?l?l?l?l : 5 letras minúsculas (Ejemplo: apple, house) - ?u?l?l?d?d?d : 1 mayúscula, 2 minúsculas, 3 dígitos (Ejemplo: Abc123) - ?d?d?d?d?d?d : 6 dígitos (Ejemplo: 123456) - ?s?s?d?d?l?l : 2 símbolos, 2 dígitos, 2 minúsculas (Ejemplo: !@34ab)

Token	Significado	Ejemplo de caracteres	Cardinalidad (nº de opciones)
`?l`	Letra minúscula	`a`–`z`	26
`?u`	Letra mayúscula	`A`–`Z`	26
`?d`	Dígito	`0`–`9`	10
`?s`	Símbolo / especial (espacio + puntuación)	`!@# $%&*()_+[]`	Depende del sistema
`?a`	Todos los caracteres imprimibles (letras, dígitos y símbolos)	mayúsculas + minúsculas + dígitos + símbolos	≈ 95 (Varía)
`?1`–`?8`	Conjuntos personalizados (definidos por `-1`…`-8`)	Por ejemplo: `-1='?l?d'`, entonces `?1` = letras minúsculas + dígitos	Depende de la definición

Puede encontrar más información sobre las clases de caracteres que puede aplicar en el documento oficial RULES del repositorio de GitHub del proyecto.

Ejercicio

Intente descrifrar el siguiente hash, sabiendo que la contraseña tiene el formato ?l?d?d, una letra minúscula seguida de dos dígitos.

usuario:$y$j9T$uKoO.N4FyJROMgSHlWNzn.$EE.05RVuuckuh.TLOTL0cnZx8etycEf9pqoU27hTYoB

1.7.4 Modo Incremental

Este modo realiza un ataque de fuerza bruta inteligente, probando todas las combinaciones posibles de caracteres basándose en tablas de frecuencia.

Este modo es muy costoso en tiempo y recursos, pero es exhaustivo y puede descifrar contraseñas complejas que otros modos no pueden.

john --incremental hashes.txt

1.8 Consultar las contraseñas encontradas

Para ver las contraseñas que John ha logrado descifrar, podemos utilizar el siguiente comando:

john --show hashes.txt

Las contraseñas descifradas se almacenan en un archivo llamado john.pot, que por defecto se encuentra en el directorio ~/.john/.

1.9 Guardar y reanudar sesiones

John the Ripper permite guardar y reanudar sesiones de cracking utilizando la opción --session. Esto es útil si el proceso de descifrado se interrumpe o si deseas pausar y continuar más tarde.

Para iniciar una sesión, puedes usar el siguiente comando:

john --session=mi_sesion hashes.txt

Para reanudar una sesión guardada, utiliza el mismo comando:

john --restore=mi_sesion

1.10 Ejecutar John en segundo plano con `tmux`

Imagina que vamos a ejecutar John the Ripper en una máquina remota a través de SSH y queremos asegurarnos de que el proceso continúe ejecutándose cuando cerremos la conexión SSH.

Para lograr esto, podemos utilizar tmux, que es un multiplexor de terminal que nos permite crear sesiones persistentes.

Primero, instalamos tmux si no lo tenemos ya instalado:

sudo apt update
sudo apt install tmux -y

Luego, iniciamos una nueva sesión de tmux. En este ejemplo vamos a crear una sesión llamada john1:

tmux new -s john1

Una vez dentro de la sesión de tmux, podemos ejecutar John the Ripper como lo haríamos normalmente. Por ejemplo:

john --session=misesion --incremental ejercicio5.txt

Para desconectarnos de la sesión de tmux sin detener el proceso en ejecución, podemos presionar las teclas Ctrl + B, soltar y luego presionar la tecla D. Esto nos devolverá a la terminal normal, dejando la sesión de tmux en segundo plano.

Para volver a conectarnos a la sesión de tmux más tarde, podemos cuáles son las sesiones activas con el siguiente comando:

tmux ls

En nuestro caso, obtendremos una salida similar a esta:

john1: 1 windows (created Mon Nov 10 22:39:06 2025)

Donde podemos ver el nombre de la sesión john1 y cuándo fue creada.

Para volver a conectarnos a la sesión john1, utilizamos el siguiente comando:

tmux attach -t john1

Para eliminar una sesión podemos utilizar el siguiente comando:

tmux kill-session -t john1

Lecturas recomendadas sobre tmux

Cómo usar Tmux: guía completa con cheat sheet. Hostinger.

Getting started with tmux. Repositorio oficial de tmux en GitHub.

1.11 Ejercicios prácticos

1.11.1 Ejercicio 1

Crea un archivo de hashes llamado ejercicio1.txt utilizando el comando unshadow con los archivos /etc/passwd y /etc/shadow de tu sistema.

Añade algunos usuarios al archivo ejercicio1.txt con contraseñas sencillas que contengan el nombre del usuario o información personal del campo GECOS.

Para crear el hash de las contraseñas de los nuevos usuarios puede hacer uso de la herramienta mkpasswd con el algoritmo yescrypt.

Utilice el modo --single para intentar descifrar las contraseñas del archivo ejercicio1.txt.

Si no consigue descifrar todas las contraseñas de una explicación de por qué ha fallado y qué modo utilizaría para intentar descifrarlas.

1.11.2 Ejercicio 2

Crea un nuevo archivo de hashes llamado ejercicio2.txt donde sólo guarde el nombre del usuario y el hash de la contraseña en formato yescrypt, sin incluir el resto de campos del archivo /etc/shadow. Por ejemplo:

usuario:$y$j9T$uKoO.N4FyJROMgSHlWNzn.$EE.05RVuuckuh.TLOTL0cnZx8etycEf9pqoU27hTYoB

Añade varios usuarios con contraseñas que aparezcan en la wordlist rockyou.txt y otras contraseñas que estén basadas en las contraseñas de la wordlist, pero con pequeñas modificaciones como cambiar minúsculas por mayúsculas, añadir números al final, etc.

Intente descifrar las contraseñas utilizando los modos que considere más adecuados.

1.11.3 Ejercicio 3

Crea un nuevo archivo de hashes llamado ejercicio3.txt donde almacene varios usuarios con los hashes de sus contraseñas en formato yescrypt.

Las contraseñas deben de seguir el siguiente patrón: una letra mayúscula, seguida de 4 letras minúsculas y 4 dígitos.

Indique cuál es el comando que utilizaría para intentar descifrar las contraseñas del archivo ejercicio3.txt y explique por qué ha elegido ese modo.

Antes de ejecutar el comando, intente calcular cuánto tiempo tardaría en descifrar las contraseñas con el patrón definido utilizando el modo incremental.

1.11.4 Ejercicio 4

Busque un patrón que se pueda descifrar en pocos minutos haciendo uso del modo incremental con el hardware disponible en su máquina.

Una vez que tenga el patrón definido, ejecute John the Ripper para intentar descifrar el hash proporcionado y obtenga el tiempo que ha tardado en encontrar la contraseña

1.11.5 Ejercicio 5

Crea un archivo con el nombre ejercicio5.txt que contenga los siguientes hashes de contraseñas:

pepe:$y$j9T$x3xba12mfGEHUoB2qOTzg/$CS4fhOXkZr7PqFP3lPtSMpHPH6J3zfHsiajVntkvPC/
maria:$y$j9T$Cb.i.cUeOVrprcEOjz939/$U7a5zKSEb7JGSge7192BccX4gfY5Y44HYdrlFOHZG3B
juanperez:$y$j9T$5lgpgvJw6VD6BMJURMi8O0$a7C3Lu0BkyzEiTWytgeczxF7ZI7MZIbnoM1vj0W1Do5
antonio:$y$j9T$2rlYLSn/uXjLPe0gGoI/X0$r1TZTSH71JupDWtHV.DMqd9QAeCa2kc1Yniw59TJ1d1
usuario:$y$j9T$uKoO.N4FyJROMgSHlWNzn.$EE.05RVuuckuh.TLOTL0cnZx8etycEf9pqoU27hTYoB
admin:$y$j9T$k/NxRMhrE49ROKqma4617.$WhQzySHNQupbsoxQE.C.xPQpRiq4nWLPLXFwjQR8tE6
pepe:$y$j9T$9EXulv9IayDXg8LPOMWEo.$b6u/ID4cFgdXTyMuDsYwkFMvO8xv6gIsCnmKeHcyws/
root:$y$j9T$r9EHbtkvAB0XGNP49QLwo/$avv75WqPAKGg0H9zM5BU5eTZd.VDg2.UZNw9zcE2wc2

Intente descifrar las contraseñas contenidas en el archivo ejercicio5.txt utilizando los modos que considere más adecuados.