Descifrar hashes en Hashcat

Introducción

En este laboratorio, aprenderá cómo utilizar Hashcat, la herramienta de recuperación de contraseñas más rápida del mundo, para descifrar hashes criptográficos. Practicará la instalación de Hashcat, la preparación de archivos de hashes, la configuración de la aceleración de la GPU y la ejecución de ataques de fuerza bruta contra hashes MD5 de muestra.

Los ejercicios prácticos lo guiarán a través del descifrado de ejemplos de contraseñas del mundo real mientras optimiza el rendimiento. Adquirirá experiencia práctica con técnicas esenciales de ciberseguridad para la recuperación de contraseñas y las pruebas de seguridad.

Skills Graph

Instalar Hashcat

En este paso, instalará Hashcat, la herramienta de recuperación de contraseñas más rápida del mundo. Hashcat es una utilidad poderosa utilizada para descifrar hashes a través de varios métodos de ataque, como ataques de fuerza bruta, de diccionario y basados en reglas.

Antes de comenzar, entendamos qué son los hashes. Un hash es una cadena de longitud fija generada por una función matemática que toma una entrada (como una contraseña) y produce una salida encriptada. Los sistemas de contraseñas almacenan estos hashes en lugar de las contraseñas en texto plano por motivos de seguridad. Hashcat ayuda a recuperar la contraseña original probando diferentes combinaciones para coincidir con el hash almacenado.

Primero, debemos asegurarnos de estar en el directorio de trabajo correcto. El directorio ~/project es donde realizaremos todas nuestras operaciones de laboratorio:

cd ~/project

Ahora instalaremos Hashcat utilizando el gestor de paquetes de Ubuntu. El gestor de paquetes se encarga de descargar y configurar el software junto con sus dependencias. Ejecutamos dos comandos juntos: primero actualizamos la lista de paquetes (update), luego instalamos Hashcat (install):

sudo apt-get update && sudo apt-get install -y hashcat

La bandera -y confirma automáticamente la instalación, evitándonos tener que escribir 'yes' durante el proceso.

Después de que se complete la instalación, verifiquemos que Hashcat se haya instalado correctamente comprobando su versión. Esta es una buena práctica para confirmar que el software está listo para usar:

hashcat --version

Debería ver una salida que muestre el número de versión instalado, por ejemplo:

v6.2.6

Ver este número de versión significa que Hashcat está instalado correctamente en su sistema. En los siguientes pasos, lo usaremos para trabajar con archivos de hash reales y realizar operaciones de descifrado. El número de versión también es útil cuando se consulta la documentación o se solucionan problemas, ya que las características pueden variar entre versiones.

Preparar un archivo de hash

En este paso, creará un archivo de hash de muestra que se utilizará para el descifrado en los pasos posteriores. Un hash es una cadena de longitud fija generada por un algoritmo criptográfico que representa datos de entrada. Los archivos de hash contienen estos hashes criptográficos que intentaremos descifrar utilizando Hashcat.

Primero, asegúrese de estar en el directorio de trabajo correcto. El comando cd cambia su directorio actual:

cd ~/project

Creemos un archivo de texto simple que contenga hashes MD5. MD5 es una función de hash criptográfico ampliamente utilizada que produce un valor de hash de 128 bits. Utilizaremos el editor de texto nano para crear y editar un nuevo archivo:

nano hashes.txt

Agregue los siguientes hashes MD5 de muestra al archivo. Estos son hashes de prueba comunes con valores de texto plano conocidos (presione Ctrl+O para guardar y Ctrl+X para salir de nano):

5f4dcc3b5aa765d61d8327deb882cf99  ## password: "password"
098f6bcd4621d373cade4e832627b4f6  ## password: "test"

Como alternativa, puede crear el archivo directamente utilizando comandos echo. El operador > crea un nuevo archivo, mientras que >> agrega al archivo existente:

echo "5f4dcc3b5aa765d61d8327deb882cf99" > hashes.txt
echo "098f6bcd4621d373cade4e832627b4f6" >> hashes.txt

Verifique el contenido de su archivo de hash utilizando el comando cat, que muestra el contenido del archivo en la terminal:

cat hashes.txt

Debería ver los dos hashes MD5 mostrados en su terminal. Este archivo servirá como nuestro objetivo para el descifrado de hashes en los siguientes pasos cuando configuremos Hashcat y ejecutemos ataques de fuerza bruta. Tener hashes de prueba conocidos ayuda a verificar que nuestra configuración de descifrado funcione correctamente.

Configurar el soporte de GPU

En este paso, configurará Hashcat para utilizar la aceleración de GPU para descifrar hashes de manera más rápida. Hashcat puede aprovechar tanto los recursos de la CPU como de la GPU, pero las GPUs son especialmente efectivas para el descifrado de contraseñas porque contienen miles de núcleos pequeños que pueden realizar muchos cálculos simultáneamente. Esta capacidad de procesamiento paralelo hace que las GPUs sean mucho más rápidas que las CPUs para ataques de fuerza bruta.

Antes de configurar el soporte de GPU, primero verifiquemos qué dispositivos de hardware están disponibles para Hashcat. Ejecute este comando para enumerar todos los dispositivos OpenCL detectados:

hashcat -I

Este comando mostrará los dispositivos OpenCL disponibles. En el entorno de la máquina virtual (VM) de LabEx, debería ver una salida similar a:

OpenCL Platform #1: NVIDIA Corporation
* Device #1: NVIDIA GeForce GTX 1080 Ti, 10240/11264 MB allocatable, 28MCU

La salida muestra los detalles de su GPU, incluyendo su modelo y capacidad de memoria. Ahora crearemos un archivo de configuración para optimizar el rendimiento de Hashcat. Los archivos de configuración ayudan a automatizar la configuración para que no tenga que escribirla cada vez.

Cree y edite el archivo de configuración con:

nano ~/.hashcat/hashcat.conf

Agregue la siguiente configuración (presione Ctrl+O para guardar y Ctrl+X para salir):

--force
--opencl-device-types=1,2
--workload-profile=4

Entendamos qué hace cada parámetro:

• --force le dice a Hashcat que continúe incluso si detecta posibles problemas (útil en entornos de laboratorio)
• --opencl-device-types=1,2 habilita tanto los dispositivos de CPU (tipo 1) como de GPU (tipo 2) para el procesamiento
• --workload-profile=4 establece el perfil de rendimiento más alto, priorizando la velocidad sobre el ahorro de energía

Para confirmar que todo funciona correctamente, ejecute una prueba de rendimiento:

hashcat -b

La prueba de rendimiento probará varios algoritmos de hash y mostrará métricas de rendimiento como:

Speed.#1.........: 12345.7 MH/s (98.23ms) @ Accel:1024 Loops:1024 Thr:256 Vec:1

Estos números muestran cuántos hashes puede intentar su sistema por segundo. Valores más altos significan un descifrado más rápido. La prueba de rendimiento confirma que la aceleración de GPU está activa y lista para usar en el siguiente paso, donde realizaremos el ataque de fuerza bruta real.

Ejecutar un ataque de fuerza bruta

En este paso, ejecutará un ataque de fuerza bruta utilizando Hashcat para descifrar los hashes MD5 que preparamos anteriormente. Un ataque de fuerza bruta es un método de prueba y error que comprueba sistemáticamente todas las posibles combinaciones de caracteres hasta encontrar la contraseña correcta. Este enfoque es especialmente útil cuando no se tiene información sobre la estructura de la contraseña.

Primero, naveguemos hasta nuestro directorio de trabajo donde almacenamos el archivo de hash. Esto asegura que Hashcat pueda acceder al archivo que queremos descifrar:

cd ~/project

Ahora usaremos Hashcat con parámetros específicos diseñados para nuestro ataque:

• -m 0 le dice a Hashcat que estamos trabajando con hashes MD5 (cada tipo de hash tiene un número específico en Hashcat)
• -a 3 establece el modo de ataque en fuerza bruta
• ?a?a?a?a define nuestra máscara de contraseña, lo que significa que estamos buscando contraseñas de exactamente 4 caracteres que podrían incluir:
  • Letras minúsculas (a-z)
  • Letras mayúsculas (A-Z)
  • Números (0-9)
  • Caracteres especiales (!@#$% etc.)

Ejecute el ataque de fuerza bruta con este comando:

hashcat -m 0 -a 3 hashes.txt ?a?a?a?a --force

Mientras Hashcat se ejecuta, mostrará estadísticas en tiempo real en su terminal. Esta salida le ayuda a monitorear el progreso del descifrado:

Session..........: hashcat
Status...........: Running
Hash.Name........: MD5
Hash.Target......: hashes.txt
Time.Started.....: [timestamp]
Speed.#1.........: [speed] H/s
Recovered........: 0/2 (0.00%)
Progress.........: [progress]
Rejected.........: 0
Restore.Point....: 0

La velocidad de descifrado (H/s) muestra cuántos cálculos de hash está realizando su sistema por segundo. El indicador de progreso ayuda a estimar el tiempo restante. Para una contraseña de 4 caracteres, esto puede tomar varios minutos dependiendo de su hardware.

Cuando el ataque se complete, podemos comprobar los resultados. El siguiente comando muestra cualquier contraseña descifrada con éxito:

hashcat -m 0 hashes.txt --show

Una salida exitosa emparejará cada hash con su contraseña de texto plano descubierta:

5f4dcc3b5aa765d61d8327deb882cf99:password
098f6bcd4621d373cade4e832627b4f6:test

Esta salida confirma que Hashcat revirtió con éxito ambos hashes MD5 en nuestro archivo de prueba a sus contraseñas originales. La primera columna muestra el hash con el que comenzamos, mientras que la segunda columna revela la contraseña real que creó ese hash.

Verificar hashes descifrados

En este último paso, verificará y analizará los resultados de su ataque de fuerza bruta. Hashcat almacena automáticamente las contraseñas descifradas con éxito en un archivo especial llamado "potfile". Este actúa como una base de datos de todas las contraseñas que ha recuperado durante sus sesiones de descifrado. Examinaremos esto para confirmar qué contraseñas se descifraron con éxito.

Primero, naveguemos hasta nuestro directorio de trabajo donde almacenamos nuestro archivo de hash. Esto asegura que estemos trabajando con los archivos correctos:

cd ~/project

Para ver todos los hashes descifrados de su ataque, usamos la bandera --show con Hashcat. Este comando busca específicamente hashes MD5 (modo 0) en nuestro archivo hashes.txt y muestra cualquier coincidencia encontrada en el potfile:

hashcat -m 0 hashes.txt --show

Debería ver una salida similar a esta, que muestra el hash original seguido de su contraseña de texto plano descifrada:

5f4dcc3b5aa765d61d8327deb882cf99:password
098f6bcd4621d373cade4e832627b4f6:test

Para una comprensión más completa de su sesión de descifrado, la bandera --status proporciona estadísticas valiosas. Esto muestra cuántos hashes se descifraron, el tipo de hash y las métricas de rendimiento:

hashcat -m 0 hashes.txt --status

Esto mostrará información importante, incluyendo:

Session.Name.....: hashcat
Status..........: Exhausted
Hash.Name.......: MD5
Hash.Target.....: hashes.txt
Time.Started....: [timestamp]
Time.Estimated..: [timestamp]
Recovered.......: 2/2 (100.00%)
Progress.......: [progress]
Speed.#1.......: [speed] H/s

Para generar un informe completo de su sesión de descifrado que puede guardar y revisar más tarde, use los siguientes comandos. El primero crea un archivo de informe formateado y el segundo muestra su contenido:

hashcat -m 0 hashes.txt --outfile-format=2 --outfile=results.txt
cat results.txt

El informe contendrá información detallada sobre cada hash descifrado, incluyendo el tipo de hash, la contraseña de texto plano y el tiempo exacto que tomó descifrar cada uno. Esta documentación es especialmente útil cuando necesita analizar su rendimiento de descifrado o compartir resultados con otros.

Resumen

En este laboratorio, has aprendido cómo instalar y configurar Hashcat, una poderosa herramienta de recuperación de contraseñas, actualizando el gestor de paquetes y verificando su versión. También has preparado un archivo de hash que contiene hashes MD5 de muestra y has confirmado su contenido utilizando comandos básicos de Linux.

Además, has explorado el soporte de GPU de Hashcat para optimizar el rendimiento y has realizado un ataque de fuerza bruta para descifrar los hashes de muestra. Este ejercicio práctico ha demostrado el papel esencial de Hashcat en ciberseguridad para escenarios de recuperación de contraseñas y evaluación de vulnerabilidades.