Comprender la Estructura de Comandos de Hashcat

Introducción

Hashcat es una herramienta potente y versátil para la recuperación de contraseñas. Para utilizarla de manera efectiva, primero debes comprender su estructura de línea de comandos. Un único comando de Hashcat se compone de varios componentes clave que le indican al programa exactamente qué descifrar y cómo hacerlo.

En este laboratorio, aprenderás la estructura fundamental de un comando de Hashcat. Construiremos un comando completo y funcional pieza por pieza, cubriendo los cinco componentes esenciales: el ejecutable, el tipo de hash, el modo de ataque, el archivo de hash de entrada y la lista de palabras de entrada. Al final, podrás construir comandos básicos de Hashcat para ataques basados en diccionario.

Identificar los Componentes Principales de un Comando de Hashcat

En este paso, identificaremos la sintaxis básica de un comando de Hashcat. Comprender esta estructura es el primer paso para utilizar la herramienta.

Un comando típico de Hashcat sigue este patrón:

hashcat [opciones] archivo_hash [lista_palabras/máscara]

Analicemos estos componentes:

• hashcat: Este es el nombre del programa ejecutable en sí.
• [opciones]: Estas son banderas que modifican el comportamiento del programa. Las opciones más críticas son -m para el tipo de hash y -a para el modo de ataque, que cubriremos en los siguientes pasos.
• archivo_hash: Esta es la ruta al archivo que contiene el hash o los hashes que deseas descifrar.
• [lista_palabras/máscara]: Esta es la ruta a un archivo de entrada, como una lista de palabras para un ataque de diccionario, o un patrón de máscara para un ataque de fuerza bruta.

Para empezar, veamos el menú de ayuda integrado para familiarizarnos con la herramienta. Este comando lista todas las opciones e información disponibles.

Ejecuta el siguiente comando en tu terminal:

hashcat --help

Verás una salida extensa que detalla todas las características de Hashcat. Haremos referencia a esta información en los próximos pasos.

hashcat (v6.2.6) starting in help mode

Usage: hashcat [options]... hash|hashfile|hccapxfile [dictionary|mask|directory]...

...
-a,  --attack-mode              | Num    | Attack-mode, see references below.
-m,  --hash-type                | Num    | Hash-type, see references below.
...

Ahora que entendemos la estructura básica, podemos comenzar a construir nuestro comando.

Especificar el Tipo de Hash con la Bandera -m

En este paso, aprenderás cómo especificar el tipo de hash objetivo. Hashcat soporta cientos de algoritmos de hashing diferentes, y debes indicarle cuál estás intentando descifrar. Esto se hace utilizando la bandera -m seguida de un código numérico.

Nuestro entorno de laboratorio ha preparado un archivo llamado hashes.txt que contiene un hash MD5. Para encontrar el código correcto para MD5, puedes buscar en la salida de hashcat --help.

Utiliza el comando grep para filtrar el texto de ayuda buscando "MD5":

hashcat --help | grep MD5

La salida te mostrará todos los tipos de hash relacionados con MD5, junto con sus códigos correspondientes.

      0 | MD5                                            | Raw Hash, Salted and/or Iterated
   10 | md5($pass.$salt)                                 | Raw Hash, Salted and/or Iterated
   20 | md5($salt.$pass)                                 | Raw Hash, Salted and/or Iterated
...

Como puedes ver, el código para un hash MD5 estándar es 0. Ahora podemos añadir esto a nuestro comando. El comando actualmente se ve así:

hashcat -m 0 ...

En el siguiente paso, especificaremos el modo de ataque.

Especificar el Modo de Ataque con la Bandera -a

En este paso, aprenderás cómo establecer el modo de ataque utilizando la bandera -a. El modo de ataque le indica a Hashcat qué método utilizar para descifrar la contraseña.

Hashcat ofrece varios modos de ataque, pero los más comunes son:

• 0: Straight (Ataque de diccionario) - Compara hashes contra una lista de palabras.
• 1: Combination - Combina palabras de dos diccionarios diferentes.
• 3: Brute-force (Ataque de máscara) - Prueba todas las combinaciones posibles de caracteres basándose en un patrón definido (máscara).

Para este laboratorio, realizaremos un ataque Straight (de diccionario), por lo que utilizaremos el modo de ataque 0. Puedes encontrar la lista de todos los modos de ataque en el menú de ayuda.

Usemos grep nuevamente para encontrar la sección "Attack-Modes":

hashcat --help | grep "Attack-Modes" -A 10

La bandera -A 10 le indica a grep que muestre las 10 líneas posteriores a la coincidencia, proporcionándote la lista completa.

- [ Attack-Modes ] -

  ## | Mode
 ===+======
  0 | Straight
  1 | Combination
  3 | Brute-force
  6 | Hybrid dict + mask
  7 | Hybrid mask + dict

Ahora hemos identificado nuestro modo de ataque. Añadámoslo a nuestro comando, que ahora se convierte en:

hashcat -m 0 -a 0 ...

A continuación, proporcionaremos el archivo que contiene el hash que queremos descifrar.

Proporcionar el Archivo de Hash de Entrada

En este paso, especificarás el archivo de entrada que contiene el hash a descifrar. Este argumento va después de las opciones.

El script de configuración para este laboratorio ya ha creado un archivo llamado hashes.txt en tu directorio actual (~/project). Este archivo contiene un único hash MD5.

Veamos el contenido de este archivo usando el comando cat:

cat hashes.txt

Deberías ver la siguiente salida:

5f4dcc3b5aa765d61d8327deb882cf99

Este es el hash que vamos a descifrar. Para añadirlo a nuestro comando, simplemente colocamos el nombre del archivo después de las opciones. Nuestro comando ahora se ve así:

hashcat -m 0 -a 0 hashes.txt ...

La última pieza es proporcionar la lista de palabras (wordlist) para nuestro ataque de diccionario.

Proporcionar la Lista de Palabras o Máscara de Entrada

En este último paso, proporcionarás el último componente requerido para nuestro ataque de diccionario: la lista de palabras (wordlist). Una lista de palabras es un archivo de texto plano donde cada línea es una contraseña potencial.

El entorno del laboratorio incluye una lista de palabras simple llamada wordlist.txt. Examinemos su contenido:

cat wordlist.txt

La salida será:

test
hello
password
123456

Hashcat utilizará esta lista de palabras para probar contra el hash. El archivo de lista de palabras es el argumento final en nuestro comando.

Ahora, ensamblemos y ejecutemos el comando completo:

hashcat -m 0 -a 0 hashes.txt wordlist.txt

Hashcat comenzará. Dado que nuestro hash y lista de palabras son muy simples, terminará casi instantáneamente. La salida mostrará el estado de la sesión de descifrado.

...
Session..........: hashcat
Status...........: Cracked
Hash.Name........: MD5
Hash.Target......: 5f4dcc3b5aa765d61d8327deb882cf99
Time.Started.....: ...
Time.Estimated...: 0 secs (0.00ms)
Guess.Base.......: File (wordlist.txt)
Guess.Queue......: 1/1 (100.00%)
Speed.#1.........:   496.9 kH/s (0.00ms) @ Accel:128 Loops:1 Thr:1 Vec:8
Recovered........: 1/1 (100.00%) Digests
Progress.........: 4/4 (100.00%)
Rejected.........: 0/4 (0.00%)
Restore.Point....: 4/4 (100.00%)
Restore.Sub.#1...: Salt:0 Amplifier:0-1 Iteration:0-1
Candidates.#1....: test -> 123456
Hardware.Mon.#1..: Util: 99%
...

La línea Status...........: Cracked confirma el éxito. Para ver la contraseña descifrada, puedes ejecutar el mismo comando nuevamente con la bandera --show.

hashcat -m 0 -a 0 hashes.txt wordlist.txt --show

La salida mostrará claramente el hash y su contraseña en texto plano correspondiente:

5f4dcc3b5aa765d61d8327deb882cf99:password

¡Felicitaciones, has construido y ejecutado con éxito un comando completo de Hashcat!

Resumen

En este laboratorio, aprendiste la estructura de comandos fundamental de Hashcat construyendo un comando desde cero. Has descifrado con éxito un hash MD5 utilizando un ataque de diccionario.

Ahora comprendes los cinco componentes principales de un comando básico de Hashcat:

1. Ejecutable: hashcat
2. Tipo de Hash: Especificado con -m (por ejemplo, -m 0 para MD5).
3. Modo de Ataque: Especificado con -a (por ejemplo, -a 0 para un ataque de diccionario).
4. Archivo de Hash: El archivo que contiene los hashes objetivo (por ejemplo, hashes.txt).
5. Lista de Palabras/Máscara: La entrada para el ataque (por ejemplo, wordlist.txt).

La estructura de comando final que aprendiste es: hashcat -m <tipo_hash> -a <modo_ataque> <archivo_hash> <lista_palabras>. Este conocimiento proporciona una base sólida para explorar funciones más avanzadas de Hashcat.