Realizar un Ataque Combinatorio en Hashcat

Introducción

En este laboratorio, explorará una técnica específica de cracking de contraseñas conocida como ataque combinatorio utilizando Hashcat, una herramienta de recuperación de contraseñas potente y versátil. Un ataque combinatorio es un método en el que se combinan dos listas de palabras separadas para generar candidatos a contraseñas. Por ejemplo, si una lista contiene "password" y la otra contiene "123", el ataque probará la combinación "password123".

Este enfoque es particularmente efectivo contra contraseñas que se forman concatenando dos palabras, o una palabra y una secuencia de números o símbolos. A lo largo de este laboratorio, aprenderá a preparar listas de palabras, construir el comando Hashcat apropiado, ejecutar el ataque contra un hash de muestra y verificar los resultados.

Comprender el Concepto del Ataque Combinatorio

En este paso, aprenderá sobre el concepto central de un ataque combinatorio en Hashcat. Este ataque se designa con el modo de ataque -a 1. Funciona tomando una palabra base de la primera lista de palabras y añadiéndole una palabra de la segunda lista de palabras, creando una nueva contraseña candidata. Este proceso se repite para cada palabra en ambas listas.

Por ejemplo, si tiene dos listas:

• wordlist1.txt: admin, user
• wordlist2.txt: 123, !

El ataque combinatorio generaría los siguientes candidatos: admin123, admin!, user123, user!.

Este método expande significativamente el espacio de contraseñas potenciales sin necesidad de un único y masivo archivo de diccionario. Comencemos confirmando el modo de ataque en el menú de ayuda de Hashcat.

Ejecute el siguiente comando para filtrar la salida de ayuda en busca de información sobre el ataque combinatorio:

hashcat --help | grep "Combinator"

Debería ver una línea en la salida que mencione explícitamente el modo de ataque Combinatorio y su número correspondiente.

-a, --attack-mode         |      ## | Attack-mode
...
                          |      1 | Combinator
...

Esto confirma que -a 1 es el indicador correcto a utilizar para un ataque combinatorio.

Crear Dos Listas de Palabras Separadas para el Ataque

En este paso, creará las dos listas de palabras que se utilizarán en nuestro ataque combinatorio. Para este laboratorio, crearemos dos listas personalizadas y pequeñas. En un escenario del mundo real, estas listas serían mucho más grandes y contendrían palabras, nombres y patrones más comunes.

Nuestra contraseña objetivo es una combinación de una palabra común y una secuencia numérica. Colocaremos la parte de la palabra en wordlist1.txt y la parte numérica en wordlist2.txt.

Primero, cree wordlist1.txt con algunas palabras base potenciales. Utilice el comando echo con el indicador -e para manejar los saltos de línea (\n):

echo -e "admin\nuser\npassword\nguest" > wordlist1.txt

A continuación, cree wordlist2.txt con algunos sufijos numéricos comunes:

echo -e "2024\n!@#\n123\nxyz" > wordlist2.txt

Ahora, verifique el contenido de ambos archivos utilizando el comando cat para asegurarse de que se crearon correctamente.

Compruebe la primera lista de palabras:

cat wordlist1.txt

Salida esperada:

admin
user
password
guest

Compruebe la segunda lista de palabras:

cat wordlist2.txt

Salida esperada:

2024
!@#
123
xyz

Con estas dos listas de palabras, Hashcat ahora podrá formar la contraseña candidata password123.

Construir el Comando del Ataque Combinatorio con Dos Listas de Palabras

En este paso, construirá el comando completo de Hashcat para el ataque combinatorio. Es importante comprender qué hace cada parte del comando antes de ejecutarlo.

La sintaxis general para un ataque combinatorio es: hashcat [opciones] <archivo-hash> <lista-palabras1> <lista-palabras2>

Aquí está el desglose del comando que utilizaremos:

• hashcat: El programa ejecutable.
• -m 0: Esto especifica el tipo de hash. El modo 0 corresponde a MD5.
• -a 1: Esto establece el modo de ataque en 1, que es el ataque Combinatorio.
• hash.txt: Este es el archivo que contiene el hash que queremos descifrar. Fue creado para usted durante la configuración del laboratorio.
• wordlist1.txt: La primera lista de palabras, que contiene la parte izquierda de los candidatos a contraseña.
• wordlist2.txt: La segunda lista de palabras, que contiene la parte derecha de los candidatos a contraseña.

Antes de ejecutar el ataque completo, es una buena práctica usar el indicador --show. Este indicador le dice a Hashcat que muestre cualquier hash que ya haya sido descifrado y almacenado en el archivo "potfile", sin iniciar una nueva sesión de descifrado.

Ejecutemos el comando con --show para ver que nuestro hash objetivo aún no ha sido descifrado:

hashcat -m 0 -a 1 hash.txt wordlist1.txt wordlist2.txt --show

Dado que es la primera vez que lo ejecutamos, el comando no producirá ninguna salida, que es el resultado esperado. Esto confirma que estamos listos para proceder con el ataque real.

Ejecutar el Ataque y Observar las Combinaciones

Ahora es el momento de ejecutar el ataque combinatorio sin el indicador --show. Esto iniciará el proceso de descifrado. Hashcat leerá las dos listas de palabras, las combinará, cifrará los resultados y los comparará con el hash objetivo en hash.txt.

Ejecute el siguiente comando en su terminal:

hashcat -m 0 -a 1 hash.txt wordlist1.txt wordlist2.txt

Hashcat se inicializará y mostrará una pantalla de estado. Dado que nuestras listas de palabras son muy pequeñas, el proceso finalizará casi instantáneamente. La salida mostrará que el hash ha sido descifrado.

Verá una salida similar a la siguiente (algunos detalles como la velocidad y el tiempo pueden variar):

hashcat (v6.2.6) starting

...

Session..........: hashcat
Status...........: Cracked
Hash.Name........: MD5
Hash.Target......: e10adc3949ba59abbe56e057f20f883e
Time.Started.....: ...
Time.Estimated...: 0 secs (0.00ms)
Guess.Base.......: File (wordlist1.txt), File (wordlist2.txt)
Guess.Queue......: 2/2 (100.00%)
Speed.#*.........: ... H/s (...)
Recovered........: 1/1 (100.00%) Digests
Progress.........: 16/16 (100.00%)
Rejected.........: 0/16 (0.00%)
Restore.Point....: 4/4 (100.00%)
Restore.Sub.#*...: 4/4 (100.00%)
Candidates.#*....: 16

Cracked Hashes: 1/1
e10adc3949ba59abbe56e057f20f883e:password123

...
All hashes have been recovered

Started: ...
Stopped: ...

La línea e10adc3949ba59abbe56e057f20f883e:password123 muestra claramente el hash original y su contraseña en texto plano descifrada. Esto confirma que nuestro ataque fue exitoso.

Revisar el Archivo "Potfile" para Resultados de Contraseñas Combinadas

En este paso, revisará el archivo "potfile" de Hashcat. El archivo "potfile" (hashcat.potfile) es un archivo de texto plano donde Hashcat almacena automáticamente los hashes descifrados con éxito y sus contraseñas correspondientes. Esta es una característica útil que le evita perder tiempo volviendo a descifrar hashes que ya se han resuelto.

Por defecto, el archivo "potfile" se encuentra en el directorio ~/.local/share/hashcat/.

Utilice el comando cat para ver el contenido del archivo "potfile" y confirmar que nuestro resultado se guardó:

cat ~/.local/share/hashcat/hashcat.potfile

La salida mostrará el hash y su contraseña descifrada, separados por dos puntos:

e10adc3949ba59abbe56e057f20f883e:password123

Esto confirma que el ataque fue exitoso y que el resultado ahora está almacenado permanentemente en el archivo "potfile". Si volviera a ejecutar el mismo ataque, Hashcat utilizaría el indicador --show para recuperar instantáneamente el resultado de este archivo en lugar de volver a ejecutar todo el proceso de descifrado.

Resumen

En este laboratorio, ha realizado con éxito un ataque combinatorio utilizando Hashcat.

Ha aprendido a:

• Comprender el concepto de un ataque combinatorio (-a 1) en Hashcat.
• Crear dos listas de palabras separadas para servir como base para los candidatos a contraseñas.
• Construir el comando correcto de Hashcat, especificando el modo de ataque, el tipo de hash y los archivos de entrada.
• Ejecutar el ataque y descifrar con éxito un hash MD5 combinando una palabra y una secuencia numérica.
• Localizar y revisar el archivo hashcat.potfile para ver los resultados almacenados de un descifrado exitoso.

El ataque combinatorio es una técnica fundamental en el descifrado de contraseñas, especialmente útil cuando se trata de contraseñas que siguen patrones de concatenación predecibles.