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 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 hash de muestra, crearás y utilizarás listas de palabras personalizadas y guardarás los resultados obtenidos para su posterior revisión. Este laboratorio está diseñado para principiantes y mantiene el flujo de trabajo enfocado en John the Ripper, que funciona de manera fiable en el entorno de contenedor proporcionado.
Configuración del entorno e instalación de herramientas
En este primer paso, prepararemos el entorno de Kali Linux instalando la herramienta principal para este laboratorio. Como se mencionó, tu sesión de terminal ya se está ejecutando dentro de un contenedor de Kali Linux.
Utilizaremos John the Ripper, un descifrador de contraseñas versátil y ampliamente utilizado que funciona de manera fiable en el contenedor de LabEx proporcionado.
Primero, actualiza la lista de paquetes para asegurarte de tener acceso a las versiones de software más recientes.
apt update
A continuación, instala John the Ripper utilizando el siguiente comando. El indicador -y confirma automáticamente la instalación.
apt install -y john
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 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]
...
Con John the Ripper instalado y verificado, tu entorno está ahora preparado para los ejercicios de descifrado de contraseñas en los siguientes pasos.
Creación de un archivo de hash de muestra
Ahora que las herramientas están instaladas, necesitamos algunos 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 una 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 Ripperpuede procesar. - Las contraseñas son
passwordy123456, contraseñas muy simples y comunes que garantizamos que 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 en su lugar, 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 lo rápido que pueden verse comprometidas 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 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 descifrarlos muy rápidamente.
Una vez que el proceso termine, 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 de palabras 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. En el paso final, guardarás las credenciales descifradas en un archivo de informe para su posterior revisión.
Guardado de las contraseñas descifradas
En este paso, guardarás las credenciales descifradas de tu sesión de John the Ripper en un archivo de informe. Este es un hábito práctico durante el trabajo de auditoría de contraseñas, ya que te permite revisar las cuentas recuperadas más tarde sin tener que volver a ejecutar el proceso de descifrado.
Utiliza john --show para mostrar las contraseñas recuperadas y, a continuación, redirige esa salida a /root/cracked_passwords.txt.
john --show /root/sample_hashes.txt > /root/cracked_passwords.txt
Muestra el informe guardado para confirmar que contiene las credenciales descifradas.
cat /root/cracked_passwords.txt
La salida debería verse similar a esta:
user1:password:18234:0:99999:7:::
user2:123456:18234:0:99999:7:::
2 password hashes cracked, 0 left
Si el archivo aún no contiene ninguna contraseña descifrada, vuelve a ejecutar el comando john --wordlist=/root/custom_wordlist.txt /root/sample_hashes.txt del paso anterior y, a continuación, guarda los resultados de nuevo.
Al guardar las contraseñas descifradas en un archivo, completas el flujo de trabajo desde la preparación del hash hasta los resultados documentados. Esto te proporciona un registro reutilizable que puedes inspeccionar o compartir durante una revisión de seguridad controlada.
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 e instalando John the Ripper. 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 luego guardaste las credenciales recuperadas en un archivo de informe para su posterior revisión. Estas habilidades forman una base sólida para las pruebas de penetración y destacan la importancia de implementar políticas de contraseñas sólidas para defenderse contra este tipo de ataques.
