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 habitualmente 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, accederás automáticamente a una 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 hash 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 análisis. Este laboratorio está diseñado para principiantes y ofrece una experiencia de aprendizaje práctica y clara 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ó, 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. Hashcat requiere un entorno de ejecución OpenCL, por lo que también instalaremos un paquete de CPU OpenCL en este contenedor.
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, Hashcat y el entorno de ejecución de CPU OpenCL mediante el siguiente comando. El indicador -y confirma automáticamente la instalación.
apt install -y john hashcat pocl-opencl-icd
El proceso de instalación puede tardar unos minutos. Una vez completado, 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 se verá similar a esto:
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]
...
Después, 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 está listo para los ejercicios de descifrado de contraseñas de los siguientes pasos.
Creación de un archivo de hash 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 de Linux reales que John the Ripper pueda procesar. Estos hashes tienen el formato necesario para imitar los que se encuentran en el archivo /etc/shadow, que almacena de forma segura la información de las contraseñas de los usuarios en los 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 de Kali. Crearemos el archivo de hash directamente con hashes reales pregenerados para contraseñas simples y comunes que se pueden descifrar rápidamente.
Crea el archivo de hash 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 SHA-512 crypt, un estándar común para los sistemas Linux modernos. El formato sigue la estructura del archivo shadow: username:hashed_password:last_change:min_age:max_age:warning:inactive:expire:reserved.
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
passwordy123456, contraseñas muy simples y comunes que garantizadamente están 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, ahora 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 hash de muestra listo, es hora de comenzar a descifrar con John the Ripper. De forma predeterminada, 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 débiles y comunes.
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 comprobar los resultados antes. Para ver las contraseñas que se han descifrado, utiliza la opción --show.
john --show /root/sample_hashes.txt
Si las contraseñas se descifran correctamente, la salida debería verse así:
user1:password:18234:0:99999:7:::
user2:123456:18234:0:99999:7:::
2 password hashes cracked, 0 left
Dado que 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ápidamente, a menudo en cuestión de segundos. El éxito demuestra que John the Ripper funciona correctamente con nuestro archivo de hash real y muestra la rapidez con la que 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 eficaz. Una lista de palabras es simplemente un archivo de texto que contiene una posible contraseña por línea. En este paso, crearás una pequeña lista de palabras personalizada y la utilizará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 hash.
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 de palabras contiene las contraseñas reales (password y 123456) que corresponden a los hashes en nuestro archivo, John debería descifrarlas muy rápidamente.
Una vez finalizado el proceso, comprueba los resultados de nuevo.
john --show /root/sample_hashes.txt
Dado que nuestra lista de palabras contiene las contraseñas correctas, la salida debería mostrar ahora las credenciales descifradas:
user1:password:18234:0:99999:7:::
user2:123456:18234:0:99999:7:::
2 password hashes cracked, 0 left
Esto demuestra la eficacia de los ataques dirigidos con listas de palabras. 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 de palabras 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 reconocido por su velocidad, especialmente en sistemas con GPU. Aquí, realizaremos el mismo ataque de diccionario utilizando Hashcat.
Hashcat prefiere un archivo limpio que contenga solo los valores de hash. 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 hash:
$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
Antes de ejecutar el ataque, confirma que Hashcat puede detectar un backend OpenCL:
hashcat -I
Si este comando informa que no hay ninguna plataforma OpenCL disponible, instala el entorno de ejecución de CPU OpenCL y vuelve a comprobarlo:
apt update
apt install -y pocl-opencl-icd
hashcat -I
Una vez detectado OpenCL, ejecuta el comando de descifrado de nuevo. Si Hashcat imprime una advertencia en este entorno contenedorizado, añade --force.
hashcat -m 1800 -a 0 /root/clean_hashes.txt /root/custom_wordlist.txt --force
Después de que el ataque se complete, visualiza las contraseñas descifradas ejecutando el comando con el indicador --show.
hashcat -m 1800 -a 0 /root/clean_hashes.txt /root/custom_wordlist.txt --show
Cuando el ataque tiene éxito, Hashcat muestra cada 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 introducido 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 de Kali Linux. Comenzaste configurando tu espacio de trabajo, instalando herramientas esenciales como John the Ripper y Hashcat. Luego, aprendiste a preparar los datos de destino creando un archivo de hash 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 la documentación y la elaboración de informes. Estas habilidades forman una base sólida para las pruebas de penetración y destacan la importancia de implementar políticas de contraseñas seguras para defenderse contra este tipo de ataques.
