Descifrar Hashes de un Potfile de John the Ripper

Introducción

John the Ripper (JtR) es una popular herramienta para descifrar contraseñas. Cuando logra descifrar una contraseña, almacena el resultado en un archivo llamado john.pot, a menudo denominado "potfile". Esto evita que JtR pierda tiempo intentando volver a descifrar el mismo hash en el futuro.

En este laboratorio, trabajará en un escenario donde un intento de descifrado de contraseñas ya ha sido parcialmente completado por John the Ripper. Su tarea es identificar qué hashes no fueron descifrados y luego usar una herramienta diferente y potente, Hashcat, para intentar descifrar los restantes. Este flujo de trabajo es común en pruebas de penetración y auditorías de seguridad, donde se utilizan múltiples herramientas para maximizar los resultados.

Aprenderá a:

• Localizar y comprender el potfile de JtR.
• Utilizar herramientas de línea de comandos para extraer y comparar listas de hashes.
• Usar Hashcat para realizar un ataque de diccionario sobre los hashes restantes.

Localizar un Potfile de John the Ripper Existente

En este paso, localizará e inspeccionará el archivo john.pot. Este archivo es creado automáticamente por John the Ripper para almacenar los hashes que ha descifrado con éxito, junto con sus contraseñas en texto plano. La ubicación predeterminada de este archivo se encuentra dentro de un directorio oculto llamado .john en el directorio principal del usuario.

Nuestro entorno de laboratorio ha sido preconfigurado con un archivo john.pot de una sesión de descifrado anterior simulada. Veamos su contenido.

Utilice el comando cat para mostrar el contenido del potfile. Todo su trabajo se realizará en el directorio predeterminado ~/project, pero el potfile se encuentra en /home/labex/.john/.

cat ~/.john/john.pot

Debería ver la siguiente salida, que muestra los hashes y las contraseñas correspondientes que JtR ya ha encontrado.

$1$abc$gqNud23o1vjR/pYd9gH7k/:password123
$1$def$H9g2s3kLd/fG1hJkLpQ9r/:labex
$1$ghi$aB4c5dE6fG7hI8jK9lM0n/:secret

Comprender el Formato de un Potfile de JtR

En este paso, analizaremos la estructura del archivo john.pot. Comprender este formato es crucial para procesar sus datos.

Como vio en el paso anterior, cada línea en el potfile tiene un formato específico:

HASH:CONTRASEÑA_EN_TEXTO_PLANO

Analicemos la primera línea de nuestro archivo:

$1$abc$gqNud23o1vjR/pYd9gH7k/:password123

• $1$abc$gqNud23o1vjR/pYd9gH7k/: Esta es la cadena de hash completa que fue descifrada. Este formato (que comienza con $1$) indica que es un hash MD5-crypt, comúnmente utilizado en sistemas Linux más antiguos.
• :: Se utiliza dos puntos como delimitador, separando el hash de la contraseña.
• password123: Esta es la contraseña en texto plano que corresponde al hash.

Nuestro objetivo es averiguar qué hashes de nuestra lista original (all_hashes.txt) no están presentes en este potfile. Para ello, primero necesitamos aislar solo la porción del hash de cada línea en john.pot. Haremos esto en el siguiente paso. Este paso actual es para la comprensión conceptual, por lo que no hay comandos que ejecutar.

Extraer Hashes del Potfile de JtR

En este paso, extraerá solo los valores de hash del archivo john.pot. Podemos usar el comando cut, una utilidad estándar de Linux para cortar secciones de cada línea de un archivo.

Le indicaremos a cut que use el dos puntos (:) como delimitador y que extraiga el primer campo (-f1). Redirigiremos la salida a un nuevo archivo llamado cracked_hashes.txt en su directorio actual (~/project).

Ejecute el siguiente comando en su terminal:

cut -d: -f1 ~/.john/john.pot > cracked_hashes.txt

Ahora, verifique que el archivo se creó correctamente viendo su contenido:

cat cracked_hashes.txt

La salida solo debería contener las cadenas de hash:

$1$abc$gqNud23o1vjR/pYd9gH7k/
$1$def$H9g2s3kLd/fG1hJkLpQ9r/
$1$ghi$aB4c5dE6fG7hI8jK9lM0n/

Reformatar los Hashes para un Ataque con Hashcat

En este paso, identificará los hashes que JtR no logró descifrar. Tiene un archivo con todos los hashes originales (all_hashes.txt) y un archivo con los hashes que ya han sido descifrados (cracked_hashes.txt). Al comparar estos dos archivos, puede crear una nueva lista que contenga solo los hashes no descifrados.

Usaremos el comando grep para lograr esto. Las banderas que usaremos son:

• -v: Invierte la coincidencia, seleccionando líneas no coincidentes.
• -F: Trata los patrones como cadenas fijas, no como expresiones regulares.
• -f file: Obtiene patrones del archivo especificado.

Este comando leerá los patrones de cracked_hashes.txt y eliminará cualquier línea coincidente de all_hashes.txt, guardando el resultado en uncracked_hashes.txt.

grep -v -F -f cracked_hashes.txt all_hashes.txt > uncracked_hashes.txt

Ahora, verifique el contenido de su nuevo archivo. Debería contener los tres hashes que no estaban en el potfile.

cat uncracked_hashes.txt

Debería ver la siguiente salida:

user4:$1$jkl$oP1qR2sT3uV4wX5yZ6a7b/
user5:$1$mno$c8d9e0f1g2h3i4j5k6l7m/
user6:$1$pqr$n9o8p7q6r5s4t3u2v1w0x/

Este archivo ahora está listo para ser utilizado con Hashcat.

Usar Hashcat para Intentar Descifrar Hashes que JtR Pasó por Alto

En este paso final, usará Hashcat para atacar los hashes restantes. Hashcat es un descifrador de contraseñas muy rápido y versátil que puede aprovechar las GPUs para obtener enormes ganancias de rendimiento.

La sintaxis básica para un ataque de diccionario con Hashcat es hashcat -m <modo> <archivo_hash> <archivo_lista_palabras>.

• -m 500: Esto especifica el tipo de hash. 500 corresponde a MD5-crypt, que es el tipo de hash con el que estamos trabajando.
• --force: Esta opción a menudo es necesaria en entornos virtualizados o contenerizados como este laboratorio para omitir advertencias y forzar la ejecución de Hashcat.

Ahora, ejecute Hashcat contra el archivo uncracked_hashes.txt usando la wordlist.txt proporcionada.

hashcat -m 500 --force uncracked_hashes.txt wordlist.txt

Hashcat comenzará. Verá información de estado mientras se ejecuta. Dado que nuestra lista de palabras es pequeña y contiene las contraseñas correctas, el proceso será muy rápido.

...
Session..........: hashcat
Status...........: Running
Hash.Name........: md5crypt, MD5 (Unix), Cisco-IOS $1$ (MD5)
Hash.Target......: uncracked_hashes.txt
...
Approaching final keyspace - workload adjusted.

Session..........: hashcat
Status...........: Cracked
...

Una vez que Hashcat termine, almacena las contraseñas descifradas en su propio potfile. Para ver las contraseñas recién descifradas, puede usar la opción --show.

hashcat -m 500 --force --show uncracked_hashes.txt

La salida mostrará los hashes y sus contraseñas en texto plano recién descubiertas.

$1$jkl$oP1qR2sT3uV4wX5yZ6a7b/:dragon
$1$mno$c8d9e0f1g2h3i4j5k6l7m/:qwerty
$1$pqr$n9o8p7q6r5s4t3u2v1w0x/:sunshine

¡Felicitaciones, ha utilizado con éxito la salida de una herramienta de descifrado para guiar la entrada de otra!

Resumen

En este laboratorio, aprendió un flujo de trabajo práctico para combinar las fortalezas de diferentes herramientas de descifrado de contraseñas. Comenzó con un potfile de John the Ripper preexistente, que representa los resultados de una sesión de descifrado anterior.

Usted logró:

• Localizar e interpretar el contenido de un archivo john.pot.
• Usar el comando cut para extraer campos de datos específicos.
• Usar el comando grep para comparar dos listas y aislar los hashes no descifrados.
• Lanzar un ataque de diccionario con Hashcat sobre los hashes restantes y descifrarlos con éxito.

Este proceso de identificar el trabajo restante y pasarlo a otra herramienta es una estrategia altamente eficiente en las evaluaciones de seguridad del mundo real, lo que le permite cubrir más terreno y aumentar sus posibilidades de éxito.