Ejecutar un Ataque de Máscara de Fuerza Bruta en Hashcat

Introducción

Bienvenido a este laboratorio sobre cómo realizar un ataque de máscara con Hashcat. Hashcat es una herramienta potente y versátil para la recuperación de contraseñas, ampliamente utilizada en ciberseguridad para probar la fortaleza de las contraseñas y recuperar contraseñas perdidas.

Un ataque de fuerza bruta estándar intenta adivinar una contraseña probando todas las combinaciones posibles de caracteres, lo que puede ser increíblemente lento. Un ataque de máscara es un tipo de ataque de fuerza bruta más inteligente y eficiente. Se utiliza cuando se tiene información sobre la estructura de la contraseña, como su longitud o los tipos de caracteres utilizados en posiciones específicas (por ejemplo, "comienza con una letra mayúscula, termina con dos números").

En este laboratorio, aprenderá a definir la estructura de una contraseña utilizando una máscara y a usar Hashcat para descifrar un hash SHA1 de muestra, demostrando la potencia y eficiencia de este enfoque dirigido.

Comprender el Concepto de un Ataque de Máscara

En este paso, aprenderá el concepto fundamental de un ataque de máscara. Como se mencionó en la introducción, este ataque es una forma especializada de un ataque de fuerza bruta.

Imagine que necesita descifrar una contraseña, pero tiene algunas pistas:

• Sabe que la contraseña tiene exactamente 6 caracteres de longitud.
• Sabe que el primer carácter es una letra mayúscula.
• Sabe que los dos últimos caracteres son dígitos.

Un ataque de fuerza bruta estándar desperdiciaría tiempo intentando combinaciones como "aaaaaa" o "123456". Un ataque de máscara, sin embargo, le permite definir una "máscara" o plantilla que le indica a la herramienta de descifrado que solo intente combinaciones que se ajusten a su patrón conocido. Para el ejemplo anterior, la máscara especificaría [Letra Mayúscula][Cualquiera][Cualquiera][Cualquiera][Dígito][Dígito].

Esto reduce drásticamente el número de posibilidades, haciendo que el proceso de descifrado sea significativamente más rápido y eficiente. En el siguiente paso, aprenderá la sintaxis específica que Hashcat utiliza para crear estas potentes máscaras. Este paso es puramente conceptual y no se necesitan comandos.

Aprender Conjuntos de Caracteres Integrados como ?l ?u ?d ?s

En este paso, aprenderá sobre los conjuntos de caracteres integrados de Hashcat, que son los componentes básicos de una máscara.

Hashcat utiliza marcadores de posición especiales, llamados "conjuntos de caracteres" (charsets), para definir el tipo de carácter en cada posición de una máscara de contraseña. Estos son los conjuntos de caracteres integrados más comunes:

• ?l: Representa todas las letras minúsculas (a a z).
• ?u: Representa todas las letras mayúsculas (A a Z).
• ?d: Representa todos los dígitos (0 a 9).
• ?s: Representa todos los caracteres especiales estándar (por ejemplo, !@#$%^&*).
• ?a: Representa todos los anteriores (?l?u?d?s).

Por ejemplo, si sabemos que una contraseña tiene 4 caracteres de longitud y consta de una letra mayúscula, seguida de dos letras minúsculas y luego un dígito, la máscara sería ?u?l?l?d. Esto generaría candidatos como Pass9, Word1, Test0, etc.

Puede ver estas definiciones en el menú de ayuda de Hashcat. Ejecute el siguiente comando en su terminal para ver la información de ayuda relacionada con las máscaras:

hashcat --help | grep "?l"

Verá una sección que enumera los conjuntos de caracteres integrados, lo que confirma la información anterior.

?l | abcdefghijklmnopqrstuvwxyz              | Letras minúsculas

Crear un Hash SHA1 de Muestra de un Patrón Conocido

En este paso, creará un hash SHA1 objetivo para una contraseña que descifraremos en los próximos pasos. Para realizar un ataque de contraseña, primero necesitamos un hash al que atacar.

Elijamos una contraseña que se ajuste a un patrón claro: LabX99!. Esta contraseña tiene la siguiente estructura:

• 1er carácter: Letra mayúscula (L)
• 2do carácter: Letra minúscula (a)
• 3er carácter: Letra minúscula (b)
• 4to carácter: Letra mayúscula (X)
• 5to carácter: Dígito (9)
• 6to carácter: Dígito (9)
• 7mo carácter: Carácter especial (!)

Primero, generemos el hash SHA1 para esta contraseña. La bandera -n en el comando echo es muy importante, ya que evita que se agregue un carácter de nueva línea a la cadena, lo que cambiaría el hash resultante.

Ejecute este comando en su terminal:

echo -n "LabX99!" | sha1sum

La salida será el hash SHA1 seguido de un guion:

0e6cc6531a1a5545942a38a9339571934219c5b0  -

Ahora, guarde este hash en un archivo llamado target_hash.txt. Este archivo será la entrada para Hashcat.

echo "0e6cc6531a1a5545942a38a9339571934219c5b0" > target_hash.txt

Puede verificar que el archivo se creó correctamente con cat target_hash.txt.

Construir un Comando de Ataque de Máscara para una Contraseña de Longitud Fija

En este paso, construirá el comando completo de Hashcat para realizar el ataque de máscara basándose en la información que tenemos.

Un comando de Hashcat para un ataque de máscara tiene varios componentes clave:

• -m <mode>: Esta bandera especifica el tipo de hash. Cada algoritmo de hash (como MD5, SHA1, bcrypt) tiene un número de modo único.
• -a <attack_mode>: Esta bandera establece el modo de ataque. Para un ataque de máscara, el modo es siempre 3.
• hash_file: La ruta al archivo que contiene el (los) hash(es) a descifrar.
• mask: El patrón de máscara que define la estructura de la contraseña.

Primero, necesitamos encontrar el modo correcto para SHA1. Puede encontrarlo buscando la salida de ayuda de Hashcat:

hashcat --help | grep "SHA1"

Verá una lista de tipos de hash. El modo para un hash SHA1 estándar es 100.

  100 | SHA1                                           | Raw Hash

A continuación, creemos la máscara para nuestra contraseña, LabX99!. Basándonos en la estructura que identificamos y los conjuntos de caracteres que aprendimos:

• L -> ?u
• ab -> ?l?l
• X -> ?u
• 99 -> ?d?d
• ! -> ?s

Combinando estos, nuestra máscara final es ?u?l?l?u?d?d?s.

Ahora podemos ensamblar el comando completo. También agregaremos la bandera --force, que le indica a Hashcat que se ejecute incluso si detecta un entorno no óptimo (como ejecutarse en una CPU en una VM), lo cual es necesario para este laboratorio.

La estructura final del comando es: hashcat -m 100 -a 3 target_hash.txt ?u?l?l?u?d?d?s --force. Lo ejecutaremos en el siguiente paso.

Ejecutar el Ataque de Máscara y Verificar el Resultado

En este paso, ejecutará el comando de ataque de máscara y verificará que Hashcat descifra la contraseña correctamente.

Ya ha construido el comando. Ahora, ejecútelo en su terminal para iniciar el ataque:

hashcat -m 100 -a 3 target_hash.txt ?u?l?l?u?d?d?s --force

Hashcat se iniciará. Puede mostrar algunas advertencias, que son seguras de ignorar porque usamos --force. El ataque comenzará y, dado que nuestra máscara es muy específica, debería finalizar casi instantáneamente. La salida mostrará el estado de la sesión y debería ver el estado final como Cracked.

...
Session..........: hashcat
Status...........: Cracked
Hash.Name........: SHA1
Hash.Target......: 0e6cc6531a1a5545942a38a9339571934219c5b0
Time.Started.....: ...
Time.Estimated...: 0 secs (0.00ms)
Guess.Mask.......: ?u?l?l?u?d?d?s [7]
Guess.Queue......: 1/1 (100.00%)
Speed.#1.........:   192.9 kH/s (0.01ms) @ Accel:128 Loops:1 Thr:1 Vec:8
Recovered........: 1/1 (100.00%) Digests
Progress.........: 11881376/11881376 (100.00%)
Rejected.........: 0/11881376 (0.00%)
Restore.Point....: 456976/456976 (100.00%)
Restore.Sub.#1...: Salt:0 Amplifier:0-1
Candidates.#1....: LuvX98! -> LuvX99#
Hardware.Mon.#1..: Temp: 46c
...

Una vez que se descifra una contraseña, Hashcat la guarda en un archivo llamado "potfile" (hashcat.potfile). Para ver la contraseña descifrada, puede usar la bandera --show con los argumentos del comando original.

Ejecute este comando para mostrar el resultado:

hashcat -m 100 target_hash.txt --show

La salida mostrará el hash y la contraseña en texto plano descifrada, separadas por dos puntos:

0e6cc6531a1a5545942a38a9339571934219c5b0:LabX99!

¡Felicitaciones, ha ejecutado con éxito un ataque de máscara!

Resumen

En este laboratorio, realizó con éxito un ataque de fuerza bruta con máscara utilizando Hashcat.

Ha aprendido a:

• Comprender el concepto central de un ataque de máscara como un método de fuerza bruta dirigido.
• Utilizar los conjuntos de caracteres integrados de Hashcat (?l, ?u, ?d, ?s) para definir la estructura de una contraseña.
• Generar un hash SHA1 para una contraseña objetivo.
• Construir un comando completo de Hashcat con el modo de hash, modo de ataque y máscara correctos.
• Ejecutar el ataque y ver la contraseña descifrada utilizando la opción --show.

Los ataques de máscara son una técnica fundamental en el descifrado de contraseñas y la auditoría de seguridad. Demuestran cómo incluso una pequeña cantidad de información sobre el patrón de una contraseña puede reducir drásticamente el tiempo y el esfuerzo necesarios para descifrarla.