Descifrado de contraseñas en Kali con John

Introducción

En este laboratorio, aprenderás los fundamentos del descifrado de contraseñas utilizando Kali Linux, centrándote en la potente herramienta John the Ripper. El objetivo principal es comprender cómo descifrar hashes de contraseñas de Linux, que son representaciones cifradas de contraseñas almacenadas típicamente en el archivo /etc/shadow. Esta habilidad es esencial en las pruebas de penetración para identificar contraseñas débiles y mejorar la seguridad del sistema.

Al abrir la terminal, entrarás automáticamente en un shell de contenedor de Kali Linux. Todos los comandos de este laboratorio deben ejecutarse dentro de este entorno. A través de instrucciones guiadas paso a paso, trabajarás con archivos de hashes de muestra, crearás y utilizarás listas de palabras personalizadas, compararás herramientas de descifrado como John the Ripper y Hashcat, y guardarás tus resultados para su posterior análisis. Este laboratorio está diseñado para principiantes y proporciona una experiencia de aprendizaje clara y práctica en un entorno controlado.

Configuración del entorno e instalación de herramientas

En este primer paso, prepararemos el entorno de Kali Linux instalando las herramientas necesarias para el descifrado de contraseñas. Como se mencionó anteriormente, tu sesión de terminal ya se está ejecutando dentro de un contenedor de Kali Linux.

Utilizaremos dos herramientas principales: John the Ripper, un descifrador de contraseñas versátil y ampliamente utilizado, y Hashcat, otra herramienta potente conocida por su velocidad y flexibilidad. Ambas son esenciales en el arsenal de cualquier experto en pruebas de penetración.

Primero, actualiza la lista de paquetes para asegurarte de tener acceso a las versiones más recientes del software.

apt update

A continuación, instala John the Ripper y Hashcat utilizando el siguiente comando. El parámetro -y confirma automáticamente la instalación.

apt install -y john hashcat

El proceso de instalación puede tardar unos minutos. Una vez finalizado, puedes verificar que John the Ripper se haya instalado correctamente ejecutándolo sin ninguna opción.

john

Deberías ver la información de ayuda y la versión, lo que confirma que la herramienta está lista. La salida será similar a esta:

John the Ripper 1.9.0-jumbo-1+bleeding-aec1328d6c 2021-11-02 10:45:52 +0100 OMP [linux-gnu 64-bit x86_64 AVX512BW AC]
Copyright (c) 1996-2021 by Solar Designer and others
Homepage: https://www.openwall.com/john/

Usage: john [OPTIONS] [PASSWORD-FILES]
...

Luego, verifica la instalación de Hashcat comprobando su versión.

hashcat --version

La salida esperada mostrará el número de versión, por ejemplo:

v6.2.5

Con ambas herramientas instaladas y verificadas, tu entorno ya está preparado para los ejercicios de descifrado de contraseñas en los siguientes pasos.

Creación de un archivo de hashes de muestra

Ahora que las herramientas están instaladas, necesitamos datos con los que trabajar. En este paso, crearás un archivo que contenga hashes de contraseñas reales de Linux que John the Ripper pueda procesar. Estos hashes tienen el formato adecuado para imitar los que se encuentran en el archivo /etc/shadow, el cual almacena de forma segura la información de las contraseñas de los usuarios en sistemas Linux. Esto te permite practicar el descifrado de manera segura y controlada.

Todas las operaciones se realizarán en el directorio /root del contenedor Kali. Crearemos el archivo de hashes directamente con hashes reales pregenerados para contraseñas simples y comunes que se pueden descifrar rápidamente.

Crea el archivo de hashes de muestra directamente con el siguiente comando:

cd /root
echo -e "user1:\$6\$randomsalt\$WS2qjCQ1JrmZv8otdbtntIYu6lRzkk2aIVhgIMdMexOcvD9bEAoxtKcyZLXbR3wlhOOPBscJbLCPUU/fYjFhM0:18234:0:99999:7:::\nuser2:\$6\$anothersalt\$ZffCt8y5Hl8gLYS79/rhyT76C12kNhuOvkFR8Ll0RXcjQz2Nzuh3VUdT//e21HYfH6fP9btOp2aG22O3S7q1z/:18234:0:99999:7:::" > sample_hashes.txt

Alternativamente, puedes crear el archivo manualmente copiando y pegando el contenido:

cd /root
cat > sample_hashes.txt << 'EOF'
user1:$6$randomsalt$WS2qjCQ1JrmZv8otdbtntIYu6lRzkk2aIVhgIMdMexOcvD9bEAoxtKcyZLXbR3wlhOOPBscJbLCPUU/fYjFhM0:18234:0:99999:7:::
user2:$6$anothersalt$ZffCt8y5Hl8gLYS79/rhyT76C12kNhuOvkFR8Ll0RXcjQz2Nzuh3VUdT//e21HYfH6fP9btOp2aG22O3S7q1z/:18234:0:99999:7:::
EOF

El prefijo $6$ en cada línea indica que el hash es un hash criptográfico SHA-512, un estándar común para los sistemas Linux modernos. El formato sigue la estructura del archivo shadow: usuario:contraseña_hasheada:último_cambio:edad_mínima:edad_máxima:advertencia:inactividad:expiración:reservado.

Para confirmar que el archivo se creó correctamente, muestra su contenido usando el comando cat:

cat /root/sample_hashes.txt

La salida debería mostrar las dos entradas de usuario con valores de hash reales:

user1:$6$randomsalt$WS2qjCQ1JrmZv8otdbtntIYu6lRzkk2aIVhgIMdMexOcvD9bEAoxtKcyZLXbR3wlhOOPBscJbLCPUU/fYjFhM0:18234:0:99999:7:::
user2:$6$anothersalt$ZffCt8y5Hl8gLYS79/rhyT76C12kNhuOvkFR8Ll0RXcjQz2Nzuh3VUdT//e21HYfH6fP9btOp2aG22O3S7q1z/:18234:0:99999:7:::

Notas importantes:

• Estos son hashes SHA-512 reales y correctamente formateados que John the Ripper puede procesar.
• Las contraseñas son password y 123456, contraseñas muy simples y comunes que garantizan estar en la lista de palabras predeterminada de John.
• Esto asegura un descifrado rápido para fines de demostración, generalmente en cuestión de segundos.

Con este archivo de datos de muestra listo, ya tienes un objetivo para tu práctica de descifrado de contraseñas. En el siguiente paso, utilizarás John the Ripper para intentar descifrar estos hashes.

Descifrado de hashes con el modo predeterminado de John the Ripper

Con el archivo de hashes de muestra preparado, es hora de comenzar el descifrado con John the Ripper. Por defecto, John utiliza varios modos, incluido un modo de "descifrado único" (single crack) que utiliza el nombre de usuario y otra información para adivinar contraseñas, seguido de un modo de lista de palabras con su lista de contraseñas integrada. Este es un excelente punto de partida para identificar contraseñas comunes y débiles.

Ejecuta el siguiente comando para iniciar el proceso de descifrado en tu archivo sample_hashes.txt.

john /root/sample_hashes.txt

John cargará los hashes y comenzará su sesión de descifrado. Verás una salida que indica su progreso. Dado que creamos hashes reales con contraseñas muy simples y comunes (password y 123456), John debería poder descifrarlos rápidamente utilizando su modo de lista de palabras predeterminado.

Using default input encoding: UTF-8
Loaded 2 password hashes with 2 different salts (sha512crypt, crypt(3) $6$ [SHA512 512/512 AVX512BW 8x])
Cost 1 (iteration count) is 5000 for all loaded hashes
Will run 2 OpenMP threads
Proceeding with single, rules:Single
Press 'q' or Ctrl-C to abort, almost any other key for status
Almost done: Processing the remaining buffered candidate passwords, if any.
Proceeding with wordlist:/usr/share/john/password.lst
...

Puedes dejar que John se ejecute durante un tiempo para intentar el descifrado, o detener el proceso con Ctrl-C si deseas verificar los resultados antes. Para ver cualquier contraseña que haya sido descifrada, utiliza la opción --show.

john --show /root/sample_hashes.txt

Si las contraseñas se descifran con éxito, la salida debería verse así:

user1:password:18234:0:99999:7:::
user2:123456:18234:0:99999:7:::

2 password hashes cracked, 0 left

Como utilizamos contraseñas muy simples (password y 123456) que casi con seguridad están en la lista de palabras predeterminada de John, estos hashes deberían descifrarse muy rápido, a menudo en segundos. El éxito demuestra que John the Ripper funciona correctamente con nuestro archivo de hashes reales y muestra con qué rapidez se pueden comprometer las contraseñas débiles.

En el siguiente paso, exploraremos cómo proporcionar a John listas de palabras personalizadas y ajustar varios parámetros para mejorar la eficiencia del descifrado.

Uso de una lista de palabras personalizada con John the Ripper

Confiar en la configuración predeterminada a menudo no es suficiente. Un ataque dirigido utilizando una lista de palabras personalizada puede ser mucho más efectivo. Una lista de palabras es simplemente un archivo de texto que contiene una contraseña potencial por línea. En este paso, crearás una pequeña lista de palabras personalizada y la usarás con John the Ripper.

Crea un archivo llamado custom_wordlist.txt en el directorio /root con algunas contraseñas comunes, incluidas las que sabemos que están en nuestro archivo de hashes.

echo -e "password\n123456\nadmin123\ntest1234\nqwerty\npassword123" > /root/custom_wordlist.txt

Verifica el contenido de tu nueva lista de palabras.

cat /root/custom_wordlist.txt

La salida debería mostrar las seis contraseñas que acabas de añadir:

password
123456
admin123
test1234
qwerty
password123

Ahora, ejecuta John the Ripper de nuevo, pero esta vez especifica tu lista de palabras personalizada utilizando la opción --wordlist.

john --wordlist=/root/custom_wordlist.txt /root/sample_hashes.txt

Este comando le indica a John que pruebe cada contraseña en custom_wordlist.txt contra los hashes en sample_hashes.txt. Dado que nuestra lista contiene las contraseñas reales (password y 123456) que corresponden a los hashes de nuestro archivo, John debería descifrarlas muy rápidamente.

Una vez que el proceso termine, verifica los resultados nuevamente.

john --show /root/sample_hashes.txt

Como nuestra lista de palabras contiene las contraseñas correctas, la salida ahora debería mostrar las credenciales descifradas:

user1:password:18234:0:99999:7:::
user2:123456:18234:0:99999:7:::

2 password hashes cracked, 0 left

Esto demuestra la efectividad de los ataques con listas de palabras dirigidas. Al incluir las contraseñas reales en nuestra lista personalizada, pudimos descifrar los hashes mucho más rápido que confiando únicamente en la lista predeterminada de John. Esta técnica es fundamental para los ataques de contraseñas dirigidos. A continuación, veremos cómo realizar un ataque similar con Hashcat.

Descifrado de hashes con Hashcat para comparación

Aunque John the Ripper es una herramienta excelente, es una buena práctica familiarizarse con alternativas como Hashcat. Hashcat es famoso por su velocidad, especialmente en sistemas con GPUs. Aquí, realizaremos el mismo ataque de diccionario utilizando Hashcat.

Hashcat prefiere un archivo limpio que contenga solo los valores de los hashes. Utiliza el comando awk para extraer el segundo campo (el hash) de sample_hashes.txt y guárdalo en un nuevo archivo, clean_hashes.txt.

awk -F':' '{print $2}' /root/sample_hashes.txt > /root/clean_hashes.txt

Verifica el contenido del nuevo archivo.

cat /root/clean_hashes.txt

La salida debería contener solo las cadenas de los hashes:

$6$randomsalt$WS2qjCQ1JrmZv8otdbtntIYu6lRzkk2aIVhgIMdMexOcvD9bEAoxtKcyZLXbR3wlhOOPBscJbLCPUU/fYjFhM0
$6$anothersalt$ZffCt8y5Hl8gLYS79/rhyT76C12kNhuOvkFR8Ll0RXcjQz2Nzuh3VUdT//e21HYfH6fP9btOp2aG22O3S7q1z/

Ahora, ejecuta Hashcat. Debes especificar el modo de hash (-m 1800 para SHA-512 crypt) y el modo de ataque (-a 0 para un ataque de diccionario directo).

hashcat -m 1800 -a 0 /root/clean_hashes.txt /root/custom_wordlist.txt

Session..........: hashcat
Status...........: Cracked
Hash.Mode........: 1800 (sha512crypt $6$, SHA512 (Unix))
Hash.Target......: /root/clean_hashes.txt
Time.Started.....: Mon Sep  1 06:33:21 2025 (0 secs)
Time.Estimated...: Mon Sep  1 06:33:21 2025 (0 secs)
Kernel.Feature...: Pure Kernel
Guess.Base.......: File (/root/custom_wordlist.txt)
Guess.Queue......: 1/1 (100.00%)
Speed.#1.........:      226 H/s (5.08ms) @ Accel:8 Loops:1024 Thr:1 Vec:8
Recovered........: 2/2 (100.00%) Digests (total), 1/2 (50.00%) Digests (new), 2/2 (100.00%) Salts
Progress.........: 6/12 (50.00%)
Rejected.........: 0/6 (0.00%)
Restore.Point....: 0/6 (0.00%)
Restore.Sub.#1...: Salt:0 Amplifier:0-1 Iteration:4096-5000
Candidate.Engine.: Device Generator
Candidates.#1....: password -> password123

Hashcat iniciará la sesión de descifrado. Dado que nuestra lista de palabras contiene las contraseñas correctas (password y 123456), Hashcat debería descifrar estos hashes muy rápidamente. Una vez que termine, visualiza las contraseñas descifradas ejecutando el mismo comando con el parámetro --show.

hashcat -m 1800 -a 0 /root/clean_hashes.txt /root/custom_wordlist.txt --show

Si el ataque tiene éxito, Hashcat mostrará el hash seguido de la contraseña descifrada, separados por dos puntos:

$6$randomsalt$WS2qjCQ1JrmZv8otdbtntIYu6lRzkk2aIVhgIMdMexOcvD9bEAoxtKcyZLXbR3wlhOOPBscJbLCPUU/fYjFhM0:password
$6$anothersalt$ZffCt8y5Hl8gLYS79/rhyT76C12kNhuOvkFR8Ll0RXcjQz2Nzuh3VUdT//e21HYfH6fP9btOp2aG22O3S7q1z/:123456

Este paso te ha presentado a Hashcat como una potente alternativa para el descifrado de contraseñas. En el paso final, aprenderás a documentar adecuadamente tus hallazgos.

Resumen

En este laboratorio, has adquirido experiencia práctica con técnicas fundamentales de descifrado de contraseñas en un entorno Kali Linux. Comenzaste configurando tu espacio de trabajo e instalando herramientas esenciales como John the Ripper y Hashcat. Luego, aprendiste a preparar datos de destino creando un archivo de hashes de muestra que imita el formato /etc/shadow de Linux.

Practicaste el uso de John the Ripper tanto con su configuración predeterminada como con una lista de palabras personalizada, y exploraste Hashcat como una alternativa potente. Finalmente, aprendiste el paso crítico de guardar tus hallazgos para fines de documentación e informes. Estas habilidades constituyen una base sólida para las pruebas de penetración y resaltan la importancia de implementar políticas de contraseñas robustas para defenderse contra este tipo de ataques.