Descifrar contraseñas simples con modo de lista de palabras

Introducción

En este laboratorio, explorará una técnica fundamental en ciberseguridad: el cracking de contraseñas. Utilizará John the Ripper (JtR), una herramienta popular y potente de auditoría de seguridad de contraseñas de código abierto. Específicamente, aprenderá a realizar un ataque de "lista de palabras" (wordlist attack), que consiste en utilizar una lista predefinida de posibles contraseñas para adivinar la correcta contra un hash de contraseña almacenado.

Este ejercicio práctico le guiará a través de la creación de un hash de contraseña de ejemplo, la obtención de una lista de palabras, la ejecución de John the Ripper para descifrar la contraseña y, finalmente, la visualización y el guardado de los resultados. Comprender este proceso es crucial tanto para los administradores de sistemas que desean probar la fortaleza de las contraseñas de sus usuarios como para los aspirantes a profesionales de la seguridad.

Al finalizar este laboratorio, usted será capaz de:

• Crear un archivo que contenga hashes de contraseñas.
• Utilizar una lista de palabras con John the Ripper.
• Descifrar una contraseña simple y ver el resultado.

Crear un archivo de hash de contraseña de ejemplo

En este paso, creará un usuario de ejemplo y extraerá su hash de contraseña en un archivo. Las herramientas de cracking de contraseñas no funcionan con contraseñas en texto plano; funcionan con sus representaciones hasheadas, que normalmente se almacenan en archivos del sistema como /etc/shadow en Linux.

Primero, creemos un nuevo usuario llamado testuser con una contraseña simple, password123. Utilizaremos openssl para generar el hash de la contraseña y useradd para crear el usuario.

Ejecute el siguiente comando en su terminal:

sudo useradd -m -p $(openssl passwd -1 password123) testuser

A continuación, necesitamos extraer la línea que contiene el hash de contraseña para testuser del archivo /etc/shadow. Usaremos el comando grep para encontrar la línea y redirigiremos la salida a un nuevo archivo llamado hashes.txt dentro de su directorio actual (~/project).

sudo grep testuser /etc/shadow > ~/project/hashes.txt

Ahora, veamos el contenido del archivo hashes.txt para confirmar que contiene el hash del usuario.

cat hashes.txt

Debería ver una salida similar a esta. La larga cadena de caracteres entre los dos primeros dos puntos es la contraseña hasheada.

testuser:$1$jE/Ipl8J$z4JgUjZfH.yN.CgCjWn.H.:19782:0:99999:7:::

Ahora ha creado con éxito un archivo objetivo para nuestro ejercicio de cracking de contraseñas.

Descargar una lista de palabras común

En este paso, creará una lista de palabras. Una lista de palabras es simplemente un archivo de texto donde cada línea contiene una contraseña potencial. John the Ripper leerá este archivo e intentará cada contraseña contra el hash objetivo. Para este laboratorio, en lugar de descargar una lista de palabras grande y preexistente, crearemos la nuestra propia, pequeña y personalizada. Esto nos permite controlar el contenido y asegurarnos de que la contraseña correcta esté incluida para un cracking exitoso.

Creemos un archivo llamado wordlist.txt y agreguemos algunas contraseñas comunes, incluida la que establecimos para testuser.

Primero, cree el archivo y agregue password123:

echo "password123" > ~/project/wordlist.txt

Ahora, agreguemos algunas contraseñas comunes más al mismo archivo. Usamos >> para agregar, lo que añade al archivo sin sobrescribirlo.

echo "123456" >> ~/project/wordlist.txt
echo "qwerty" >> ~/project/wordlist.txt
echo "admin" >> ~/project/wordlist.txt

Verifiquemos el contenido de nuestra nueva lista de palabras.

cat wordlist.txt

Su terminal debería mostrar el siguiente contenido:

password123
123456
qwerty
admin

Ahora tiene una lista de palabras lista para ser utilizada con John the Ripper.

Ejecutar John the Ripper en modo de lista de palabras

En este paso, utilizará John the Ripper para descifrar el hash de la contraseña utilizando la lista de palabras que creó. La sintaxis para ejecutar JtR en modo de lista de palabras es sencilla. Debe especificar el archivo de lista de palabras y el archivo que contiene los hashes.

El formato del comando es john --wordlist=<ruta_a_la_lista_de_palabras> <ruta_al_archivo_de_hashes>.

Ahora, ejecute el comando en su terminal, apuntando JtR a sus archivos wordlist.txt y hashes.txt.

john --wordlist=wordlist.txt hashes.txt

John the Ripper comenzará a procesar. Cargará el hash y luego intentará cada contraseña de su lista de palabras. Dado que nuestra contraseña está en la lista, el proceso será muy rápido. Verá una salida similar a la siguiente:

Using default input encoding: UTF-8
Loaded 1 password hash (MD5-based crypt [MD5_body])
Cost 1 (algorithm [1:MD5 2:SHA256 3:SHA512] of 3) is 1 (MD5)
Press 'q' or Ctrl-C to abort, almost any other key for status
password123      (testuser)
1g 0:00:00:00 DONE (2023-10-27 10:30) 100.0g/s 100.0p/s 100.0c/s 100.0C/s admin..password123
Session completed

La línea password123 (testuser) indica que JtR ha descifrado la contraseña con éxito. También almacena este resultado en un archivo llamado "pot file" (plain old text), que normalmente se encuentra en ~/.john/john.pot, para que no tenga que volver a descifrar contraseñas conocidas.

Ver contraseñas descifradas

En este paso, aprenderá a ver las contraseñas que John the Ripper ya ha descifrado. Una vez que se ha descifrado una contraseña, JtR la guarda en su archivo pot. Si intenta ejecutar el mismo comando de descifrado nuevamente, JtR informará "No password hashes left to crack" (No quedan hashes de contraseña por descifrar) porque ya lo ha resuelto.

Para mostrar las contraseñas descifradas para un archivo de hashes dado, utiliza la opción --show.

Ejecute el siguiente comando para ver la contraseña descifrada para hashes.txt:

john --show hashes.txt

El comando verificará el archivo pot y mostrará cualquier contraseña descifrada asociada con los hashes en hashes.txt. La salida se verá así:

testuser:password123:19782:0:99999:7:::
1 password hash cracked, 0 left

El formato de salida es username:password:other_shadow_file_fields (nombre de usuario:contraseña:otros_campos_del_archivo_shadow). Esto confirma que la contraseña para testuser es password123. Este comando es muy útil para recuperar rápidamente los resultados de una sesión de descifrado sin tener que analizar manualmente el archivo pot.

Guardar contraseñas descifradas en un archivo

En este paso, guardará la contraseña descifrada en un archivo separado. Esta es una práctica común en las pruebas de penetración y auditorías de seguridad para fines de informes. Puede lograr esto fácilmente redirigiendo la salida del comando john --show a un archivo.

Guardemos los resultados en un archivo llamado cracked.txt.

john --show hashes.txt > cracked.txt

Este comando ejecuta john --show hashes.txt como antes, pero en lugar de imprimir el resultado en la terminal, el operador > redirige la salida y la guarda en el archivo cracked.txt. Si el archivo no existe, se creará. Si existe, se sobrescribirá.

Para verificar que la salida se guardó correctamente, puede mostrar el contenido del nuevo archivo utilizando el comando cat.

cat cracked.txt

La terminal mostrará el contenido del archivo, que debería ser idéntico a la salida que vio en el paso anterior:

testuser:password123:19782:0:99999:7:::

1 password hash cracked, 0 left

Ahora ha descifrado con éxito una contraseña y ha guardado el resultado en un archivo para su documentación.

Resumen

¡Felicitaciones por completar este laboratorio! Ha realizado con éxito un ataque básico de descifrado de contraseñas basado en listas de palabras utilizando John the Ripper.

En este laboratorio, ha aprendido a:

• Crear un archivo de hash de contraseña de ejemplo a partir del sistema.
• Crear una lista de palabras personalizada que contenga contraseñas potenciales.
• Ejecutar John the Ripper en modo de lista de palabras para descifrar un hash de contraseña.
• Utilizar la opción --show para ver las contraseñas ya descifradas.
• Redirigir la salida de comandos para guardar sus hallazgos en un archivo.

Este ejercicio demuestra con qué facilidad se pueden comprometer las contraseñas simples y comunes. Destaca la importancia crítica de usar contraseñas fuertes, complejas y únicas para proteger sistemas y datos. Las habilidades que ha aprendido son una parte fundamental de la auditoría de seguridad y las pruebas de penetración.