Manual de Hashcat: Cómo Utilizarlo con Ejemplos para Descifrar Contraseñas

En el mundo digital actual, donde la seguridad de la información es crucial, el cifrado de contraseñas se ha convertido en una piedra angular para proteger los datos sensibles.

Sin embargo, incluso las medidas de seguridad más robustas pueden ser desafiadas por la tenacidad y la potencia del poder de cómputo moderno. Es aquí donde entra en juego Hashcat, una poderosa herramienta de recuperación de contraseñas que utiliza la potencia del procesamiento paralelo para descifrar incluso las contraseñas más intrincadas y aparentemente impenetrables.

Las siguientes instrucciones está diseñada para principiantes absolutos, con la esperanza de reducir la cantidad de preguntas “infantiles”.

Descargar Hashcat

Descarga hashcat desde el sitio oficial mediante el enlace: https://hashcat.net/hashcat/

Verás:

El sitio ofrece binarios de hashcat y fuentes de hashcat. Los primeros son archivos binarios (ejecutables), los segundos son el código fuente. Necesitamos los binarios, es decir, hashcat binaries.

Cómo Instalar Hashcat

Hashcat no requiere instalación, ya que es un programa portátil. Basta con descomprimir el archivo descargado. Si tienes problemas con la descompresión en formato .7z, utiliza el programa 7-Zip (un archivador con una alta relación de compresión).

Para ejecutar hashcat, es necesario tener instalados los controladores más recientes para las tarjetas de video.

Controladores para Hashcat

Nota: Si estás utilizando Linux, consulta el artículo “Cómo realizar ataques de fuerza bruta a contraseñas utilizando la GPU y la CPU en Linux” para obtener instrucciones sobre la instalación de los controladores y paquetes necesarios.

Se requieren los siguientes controladores de tarjetas gráficas:

Las tarjetas gráficas AMD en Windows requieren AMD Radeon Adrenalin 2020 Edition (20.2.2 o posterior). Los procesadores Intel requieren OpenCL Runtime para procesadores Intel Core e Intel Xeon (16.1.1 o posterior). Las tarjetas gráficas NVIDIA requieren Controlador NVIDIA (440.64 o posterior) y Kit de herramientas CUDA (9.0 o posterior).

Instalar el controlador NVIDIA:

Ve al sitio web oficial de NVIDIA https://www.nvidia.com/Download/index.aspx, descarga e instala el controlador.

Instalar el Kit de herramientas CUDA:

Accede al sitio web oficial https://developer.nvidia.com/cuda-downloads, descarga e instala este kit de herramientas.

Instalar el controlador de video para CPU Intel:

Visita el sitio web oficial https://www.intel.com/content/www/us/en/download/19344/intel-graphics-windows-dch-drivers.html, descarga e instala el controlador.

Instalar OpenCL Runtime para Intel:

Enlace directo a “Intel CPU Runtime for OpenCL Applications for Windows OS” en el sitio web de Intel: https://registrationcenter-download.intel.com/akdlm/IRC_NAS/faf10bb4-a1b3-46cf-ae0b-986b419e1b1c-opencl/w_opencl_runtime_p_2023.2.0.49500.exe

Cómo Ejecutar y Usar Hashcat (Una guía para hackear contraseñas)

Hashcat es un programa para hackear contraseñas, una aplicación poderosa con muchas funciones.

Sin embargo, no es el programa más fácil de usar, por lo que es necesario dedicar tiempo a aprenderlo. En este manual, se describen las situaciones más típicas con hashcat.

Consideraremos preguntas consideradas muy “infantiles”, como “cómo ejecutar hashcat“, y otras más complejas, como la composición correcta de máscaras, conjuntos de caracteres personalizados, opciones del programa, resolución de problemas, etc.

La peculiaridad de hashcat es su alta velocidad en la fuerza bruta de contraseñas, que se logra mediante el uso simultáneo de todas las tarjetas gráficas, así como los procesadores centrales en el sistema. Es posible trabajar con varias tarjetas gráficas o adaptadores de video de diferentes fabricantes instalados (por ejemplo, AMD y NVIDIA).

Cuando Hago Clic en hashcat.exe, aparece una ventana Negra y Luego Desaparece

Hashcat es una utilidad de línea de comandos, por lo que no tiene una interfaz gráfica en forma de una ventana familiar. Por lo tanto, los usuarios de Windows pueden pensar que el programa se está ejecutando de manera inusual.

Para iniciar el programa, abre la ventana de comandos (o PowerShell). Para hacerlo, presiona Win+x y selecciona Windows PowerShell:

Luego puedes actuar de dos maneras.

La primera opción: simplemente puedes arrastrar y soltar el archivo ejecutable en la ventana de comandos. El archivo ejecutable es hashcat.exe o hashcat32.exe dependiendo de tu sistema.

La segunda opción: en la línea de comandos, puedes cambiar el directorio de trabajo actual al que contiene los archivos ejecutables de hashcat. Por ejemplo, mi programa está ubicado en la carpeta C:\Users\alexi\Desktop\hashcat-6.2.6, para cambiar la carpeta de trabajo actual, utiliza el comando cd, luego especifica la carpeta deseada. En mi caso, el comando se vería así:

cd C:\Users\alexi\Desktop\hashcat-6.2.6

Nota: 6.2.6 es la versión actual que utilizo en esta publicación. Variará el número según la última actualización que utilices.

Como puedes ver en la captura de pantalla, la carpeta C:\WINDOWS\system32 se cambia a C:\Users\alexi\Desktop\hashcat-6.2.6.

Ahora, para iniciar el programa, es suficiente con escribir el nombre del archivo ejecutable indicando la carpeta actual. La carpeta actual se indica con un punto (.), Luego debes colocar una barra diagonal invertida, se ve de la siguiente manera:

.\hashcat.exe

Dado que no ingresamos ninguna opción, no sucede nada, solo se muestra una breve indicación.

A lo largo de la instrucción, ejecutaremos el archivo ejecutable de hashcat con opciones. La opción más simple es -h, si la escribes, obtendrás una referencia para usar el programa:

.\hashcat.exe -h

Opciones de Hashcat

Trabajar con programas en la interfaz de línea de comandos (CLI) es muy diferente a trabajar en la interfaz gráfica de usuario (GUI). En la GUI, presionamos diferentes botones, movemos interruptores, etc. Esto no ocurre con los programas de interfaz de línea de comandos. Sin embargo, al mismo tiempo, una utilidad de línea de comandos puede tener incluso mayores capacidades que un programa similar con una interfaz de ventana. Para controlar la funcionalidad de las utilidades de consola, se utilizan opciones.

En la salida de la ayuda, probablemente hayas notado mucha información. Esta información se dedica en su mayoría a las opciones.

Las opciones se especifican después del nombre del archivo, separadas por un espacio. Algunas opciones requieren especificar un valor determinado. Algunas se utilizan sin valores (a estas opciones también se les llama “flags” o banderas).

Las opciones se pueden utilizar una a la vez o varias a la vez. Con la ayuda de las opciones, puedes configurar la programación con mucha precisión y utilizarla al máximo.

Ya hemos utilizado una opción, que es la opción -h, que muestra la ayuda del programa. Ahora conoceremos aún más opciones y sus posibles valores.

La siguiente es la opción -b.

Ejecución del Benchmark de Hashcat

La opción -b inicia el benchmark de hashcat. Este benchmark mide la velocidad a la que se verifican las contraseñas.

La ejecución del benchmark será exitosa solo si los controladores están instalados correctamente y todo está en orden. Por lo tanto, el benchmark también es una forma de verificar el sistema y hashcat.

Para ejecutar la verificación de velocidad de fuerza bruta en los algoritmos más populares en la línea de comandos, escribe:

.\hashcat.exe -b

Para detener prematuramente, presiona CTRL+c (dos veces). Este atajo detiene inmediatamente todas las utilidades de línea de comandos. ¡Recuerda esta combinación!

La velocidad se muestra para cada dispositivo por separado, así como para todos los dispositivos combinados (línea Speed.Dev.#*).

Ejemplo:

-------------------------------------------------------------
* Hash-Mode 22000 (WPA-PBKDF2-PMKID+EAPOL) [Iterations: 4095]
-------------------------------------------------------------

Speed.#1.........:   106.3 kH/s (94.75ms) @ Accel:64 Loops:256 Thr:512 Vec:1
Speed.#3.........:     5809 H/s (59.10ms) @ Accel:4 Loops:256 Thr:64 Vec:1
Speed.#*.........:   112.1 kH/s

...

--------------------------------------------------------
* Hash-Mode 1500 (descrypt, DES (Unix), Traditional DES)
--------------------------------------------------------

Speed.#1.........:   198.9 MH/s (52.13ms) @ Accel:32 Loops:1024 Thr:64 Vec:1
Speed.#3.........: 11596.5 kH/s (506.19ms) @ Accel:2 Loops:1024 Thr:128 Vec:1
Speed.#*.........:   210.5 MH/s

El dispositivo que corresponde a un número se muestra al comienzo mismo cuando se ejecuta el programa, por ejemplo:

OpenCL API (OpenCL 3.0 CUDA 12.2.128) - Platform #1 [NVIDIA Corporation]
========================================================================
* Device #2: NVIDIA GeForce GTX 1050, skipped

OpenCL API (OpenCL 3.0 ) - Platform #2 [Intel(R) Corporation]
=============================================================
* Device #3: Intel(R) UHD Graphics 630, 1568/3226 MB (806 MB allocatable), 24MCU

Advertencias y Errores al Ejecutar hashcat

Inmediatamente después de iniciar el benchmark, pueden comenzar a aparecer errores. Por ejemplo:

* Device #3: Not a native Intel OpenCL runtime. Expect massive speed loss.
             You can use --force to override, but do not report related errors.

El error indica que no se está utilizando el entorno de tiempo de ejecución nativo de OpenCL, y se espera una pérdida significativa de velocidad. Por esta razón, los dispositivos OpenCL se omitirán (en la captura de pantalla a continuación, se puede ver la palabra “skipped”). Si deseamos usarlos de todos modos, necesitamos agregar la opción --force.

Ejecutando un benchmark con dos opciones:

.\hashcat.exe -b --force

Si aún falta algún dispositivo, puedes agregar una opción más, -D. Después de esta opción, debes agregar un número o números que indiquen el tipo de dispositivo:

# | Device Type
===+=============
 1 | CPU
 2 | GPU
 3 | FPGA, DSP, Co-Processor

Presta atención a un punto muy importante: se utiliza una letra mayúscula para la opción. Las opciones distinguen entre mayúsculas y minúsculas. Una letra mayúscula puede tener otro significado, incluso completamente diferente al de una letra minúscula.

Por lo tanto, 1 es el procesador central, y 2 es el procesador gráfico, luego el comando completo, junto con la selección de todos los dispositivos disponibles para mí, se verá así:

.\hashcat.exe -b --force -D 1,2

La GUI de Hashcat

No existen interfaces gráficas oficiales para hashcat. No obstante, hay varias interfaces que fueron creadas por entusiastas. Existe la CrackerJack. Y la más relevante es esta: hashcat.launcher

https://github.com/s77rt/hashcat.launcher/releases

Para instalar el GUI de hashcat, descarga el archivo comprimido desde la página enlazada arriba.

Descomprime el archivo descargado, ya incluye todo lo necesario.

Requisitos para el GUI de hashcat:

• Sistema operativo Windows
• Framework .NET: v4
• Versión de hashcat 3.00 o posterior

Hashcat, debe descargarlo por separado. También es necesario tener instalados los controladores necesarios.

Haz doble clic en el archivo hashcat.launcher.exe para iniciar el programa. Observa la interfaz gráfica de Hashcat:

En mi opinión, es complicado. En mi sentido subjetivo, es más fácil lograr el resultado deseado en la línea de comandos que en la interfaz gráfica, en la cual, por cierto, faltan algunas funciones.

Además, sin comprender los conceptos de Hashcat, es poco probable que puedas hacer algo incluso en la interfaz gráfica. Por lo tanto, continúa leyendo este artículo, y volveremos a la interfaz gráfica más adelante.

Cómo Usar Hashcat

El programa se ejecuta de la siguiente manera:

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

Aquí, “hashcat” es el nombre del archivo ejecutable. En mis ejemplos, es .\hashcat.exe.

Separados por un espacio, siguen las opciones después del archivo ejecutable.

El símbolo | (barra vertical) en este caso significa “OR lógico”. Por lo tanto, después de las opciones, le sigue hash OR archivo con hash OR archivo hccapx. Luego sigue diccionario OR máscara OR directorio, dependiendo del ataque elegido.

Consideremos el uso del programa en ejemplos específicos. Supongamos que tenemos un hash de c2f49cb8fc6a4259743930a920762f6f, que debe ser descifrado. Se sabe que este hash se obtuvo con el algoritmo de hash MD5 (es decir, es un hash MD5). También se sabe que la cadena encriptada consta solo de letras minúsculas del alfabeto inglés y tiene una longitud de seis a diez caracteres.

A continuación, te mostraremos cómo lanzar un ataque de contraseña utilizando varios trucos.

Especificar el Tipo de Hash

Diferentes hashes se calculan utilizando diferentes algoritmos. Del mismo modo, su descifrado se realiza mediante diferentes algoritmos. Para lanzar correctamente un ataque en Hashcat, debes especificar el tipo de hash atacado. Para hacer esto, usa la opción -m, después de la cual debes especificar un número correspondiente al tipo de hash seleccionado.

En la salida del comando de ayuda, encontramos [ Hash modes ]:

      # | Name                                                       | Category
  ======+============================================================+======================================
    900 | MD4                                                        | Raw Hash
      0 | MD5                                                        | Raw Hash
    100 | SHA1                                                       | Raw Hash
   1300 | SHA2-224                                                   | Raw Hash
   1400 | SHA2-256                                                   | Raw Hash
  10800 | SHA2-384                                                   | Raw Hash
   1700 | SHA2-512                                                   | Raw Hash
  17300 | SHA3-224                                                   | Raw Hash

Frente al hash encontrado, miramos la columna ‘#‘, es decir, el número. En este caso, este número es ‘0‘.

Por lo tanto, al comando de inicio de Hashcat, debes agregar -m 0, que es la opción y su valor.

Si se nos hubiera dado un hash SHA1, su número sería 100 y para el comando de inicio de Hashcat agregaríamos -m 100 y de manera similar para cualquier otro algoritmo.

Por lo general, el tipo de hash se conoce desde la fuente donde se obtuvo este hash. En caso de que el tipo de hash atacado no se conozca de manera confiable, puedes intentar adivinarlo con la ayuda de herramientas especializadas.

Modos de Ataque de Hashcat

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

• Ataque de diccionario, cuando se utiliza una lista de palabras como candidatas a contraseñas.
• Ataque de máscara (fuerza bruta), cuando las candidatas a contraseñas se generan en función de los criterios descritos.

Usa la opción -a para especificar el modo de ataque. Con ella, puedes especificar cualquier tipo de ataque admitido en Hashcat, el más popular es el ataque de diccionario que se indica con el número 0, y el ataque de máscara (fuerza bruta) que se indica con el número 3.

Entonces, si ejecutamos un ataque de diccionario, especificamos -a 0, y si ejecutamos un ataque de máscara, especificamos -a 3.

Ataque de Diccionario en Hashcat

El ataque comienza con el diccionario de la siguiente manera:

hashcat [options] hash|hashfile|hccapxfile path_to_dictionary

Para descifrar nuestro hash, crea un pequeño diccionario: un archivo de texto ordinario llamado diccionario.txt y copia en él:

00001080
00001111
85be028
85cheyenne
85e6196a
85gpn
aaaa1111
aaaa1113
aaaaa
aaaaaa
aaaaaa1
aaaaaa55
aaaaaaA1
aaaaaaa
aaaaaaa7
aaaaaaaa
aaaaaaaaaa
aaabbb
aaabbbc
aaasss
aaawin
aab
aabbccdd
dancing2009
danciotu
dandan1243
dandan44
dandans
dandik06
dandy
dandy624
esgeeks
nord8899
nordeng86
norderst
nordikmix
nordmann25
nordrein
nordvik81
nordwich
yw123123
yw19920
ywa5115
ywab1402
ywhjia4f
ywidv
ywj7516
ywjpheej

Nota: Por cierto, con Hashcat viene un ejemplo de diccionario, se llama example.dict.

https://github.com/hashcat/hashcat/blob/master/example.dict

Por lo tanto, en esta etapa tenemos todo lo necesario para lanzar un ataque de diccionario. Reunimos todo junto:

.\hashcat.exe -m 0 -a 0 c2f49cb8fc6a4259743930a920762f6f diccionario.txt

Aquí:

• .\hashcat.exe es un archivo ejecutable
• -m 0 es una opción que establece el tipo de hash MD5
• -a 0 es una opción, cuyo valor activa un ataque de diccionario
• c2f49cb8fc6a4259743930a920762f6f es un hash a descifrar
• diccionario.txt es la ruta al archivo de diccionario.

Dado que el diccionario es muy pequeño, el programa finalizará su trabajo muy rápidamente:

El resultado del programa:

c2f49cb8fc6a4259743930a920762f6f:esgeeks
  
Session..........: hashcat
Status...........: Cracked
Hash.Mode........: 0 (MD5)
Hash.Target......: c2f49cb8fc6a4259743930a920762f6f
Time.Started.....: Wed Aug 16 14:38:12 2023 (0 secs)
Time.Estimated...: Wed Aug 16 14:38:12 2023 (0 secs)
Kernel.Feature...: Pure Kernel
Guess.Base.......: File (diccionario.txt)
Guess.Queue......: 1/1 (100.00%)
Speed.#1.........:    29652 H/s (0.06ms) @ Accel:1024 Loops:1 Thr:64 Vec:1
Speed.#3.........:        0 H/s (0.00ms) @ Accel:128 Loops:1 Thr:64 Vec:1
Speed.#*.........:    29652 H/s
Recovered........: 1/1 (100.00%) Digests (total), 1/1 (100.00%) Digests (new)
Progress.........: 48/48 (100.00%)
Rejected.........: 0/48 (0.00%)
Restore.Point....: 0/48 (0.00%)
Restore.Sub.#1...: Salt:0 Amplifier:0-1 Iteration:0-1
Restore.Sub.#3...: Salt:0 Amplifier:0-0 Iteration:0-1
Candidate.Engine.: Device Generator
Candidates.#1....: 00001080 -> ywjpheej
Candidates.#3....: [Copying]
Hardware.Mon.#1..: Temp: 50c Util:  0% Core:1354MHz Mem:3504MHz Bus:16
Hardware.Mon.#3..: N/A

La primera línea es c2f49cb8fc6a4259743930a920762f6f: esgeeks, donde se encuentra el hash atacado y después de los dos puntos, la contraseña descifrada, en este caso es esgeeks.

Cuando se logra el descifrado exitoso, la línea dirá Status………..: Cracked.

No es necesario especificar el hash en la línea de comandos; se puede escribir en un archivo y, luego, al lanzar el ataque, se especifica la ruta al archivo que contiene el hash. Por ejemplo, crea un archivo llamado hashmd5.txt y copia en él c2f49cb8fc6a4259743930a920762f6f.

Luego, el comando para ejecutar será:

.\hashcat.exe -m 0 -a 0 hashmd5.txt diccionario.txt

El comando contiene las mismas opciones que el anterior, pero en lugar de especificar directamente el hash, hemos indicado la ruta al archivo que contiene el hash a descifrar.

Nota: dado que con fines educativos desciframos el mismo hash de diferentes formas, en caso de que repitas los ejemplos, verás el mensaje:

INFO: All hashes found in potfile! Use --show to display them.

Significa que el hash que estás intentando descifrar ya ha sido descifrado antes. Todos los hashes comprometidos se almacenan en el archivo hashcat.potfile en el mismo directorio que Hashcat. Este es un archivo de texto plano, puedes abrirlo y ver el contenido, en mi caso es:

c2f49cb8fc6a4259743930a920762f6f:esgeeks

Este archivo puede ser eliminado para comenzar un nuevo ataque en el mismo hash de diferentes maneras.

También está la opción --show, después de la cual debes especificar el hash de interés:

.\hashcat.exe --show -m 0 c2f49cb8fc6a4259743930a920762f6f

y si se encuentra en el archivo hashcat.potfile, entonces se mostrará información sobre la contraseña descifrada.

Ataque de Máscara en Hashcat (Ataque de fuerza bruta en hashcat)

En Hashcat no existe un modo llamado fuerza bruta. Fue asimilado por el ataque de máscara. Este es un tipo de ataque más flexible, que te permite implementar la fuerza bruta a través de criterios finamente ajustados.

En general, el ataque de máscara tiene la siguiente forma:

hashcat [options]... hash|hashfile|hccapxfile mask

Por lo tanto, es similar al anterior, pero en lugar de usar un diccionario se indica una máscara.

Cómo Crear Máscaras en Hashcat

Para componer máscaras, se utilizan conjuntos de caracteres. Los conjuntos de caracteres en Hashcat vienen en dos tipos:

• Conjuntos de caracteres integrados
• Conjuntos de caracteres definidos por el usuario

Comencemos nuestro conocimiento con los conjuntos de caracteres integrados, que en muchos casos son suficientes.

? | Charset
===+=========
 l | abcdefghijklmnopqrstuvwxyz
 u | ABCDEFGHIJKLMNOPQRSTUVWXYZ
 d | 0123456789
 h | 0123456789abcdef
 H | 0123456789ABCDEF
 s |  !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
 a | ?l?u?d?s
 b | 0x00 - 0xff

La primera columna denota un conjunto de símbolos simbólicos. Para su uso en máscaras, se debe colocar un signo de interrogación antes de esta designación. Por ejemplo, ?u significa todas las letras mayúsculas, ?d significa todos los dígitos numéricos.

Supongamos que sabemos que la contraseña consta de cuatro caracteres, los dos primeros caracteres son letras mayúsculas, y los tercer y cuarto caracteres son dígitos. Entonces, la máscara será la siguiente:

?l?l?h?h

Para descifrar la contraseña de nuestro hash dado como ejemplo, necesitamos crear una máscara compuesta por siete caracteres, cada uno de los cuales es una letra minúscula. Esta es la máscara: ?l?l?l?l?l?l?l

.\hashcat.exe -m 0 -a 3 c2f49cb8fc6a4259743930a920762f6f ?l?l?l?l?l?l?l

Aquí:

• .\hashcat.exe es un archivo ejecutable.
• -m 0 es una opción que establece el tipo de hash MD5.
• -a 3 es una opción cuyo valor activa el ataque de máscara.
• c2f49cb8fc6a4259743930a920762f6f es un hash a descifrar.
• ?l?l?l?l?l?l?l?l es una máscara que especifica la generación de contraseñas de ocho caracteres compuestas por letras minúsculas.

En menos de un minuto, la contraseña fue descifrada con éxito:

Presta atención a la línea:

Progress.........: 2732720128/8031810176 (34.02%)

Es decir, se probaron 2732720128 variantes de contraseñas de 8031810176 del número total de variantes.

Máscara para Longitud de Contraseña Desconocida

La longitud de la contraseña no siempre se conoce exactamente. Incluso según la condición de nuestra tarea, la contraseña tiene una longitud de seis a diez caracteres.

Para generar contraseñas de diferentes longitudes, están disponibles las siguientes opciones:

Options Short / Long           | Type | Description                         | Example
-i,  --increment               |      | Enable mask increment mode          |
     --increment-min           | Num  | Start mask incrementing at X        | --increment-min=4
     --increment-max           | Num  | Stop mask incrementing at X         | --increment-max=8

La opción -i es opcional. Si se usa, significa que la longitud de los candidatos a contraseñas no debe ser fija, sino que debe aumentar por el número de caracteres.

La opción --increment-min también es opcional. Determina la longitud mínima de los candidatos a contraseñas. Si se usa la opción -i, el valor predeterminado de --increment-min es 1.

Y la opción --increment-max también es opcional. Determina la longitud máxima de los candidatos a contraseñas. Si se especifica la opción -i, pero se omite la opción --increment-max, entonces su valor predeterminado es la longitud de la máscara.

Reglas para usar las opciones de incremento de máscara:

• Antes de usar --increment-min y --increment-max, debes especificar la opción -i.
• El valor de la opción --increment-min puede ser menor o igual al valor de la opción --increment-max, pero no puede superarlo.
• La longitud de la máscara puede ser mayor en el número de caracteres o igual al número de caracteres especificados por la opción --increment-max, pero la longitud de la máscara no puede ser menor que la longitud de caracteres establecida por --increment-max.

Entonces, corregiremos el comando de inicio para nuestra tarea (la contraseña tiene una longitud de seis a diez caracteres):

.\hashcat.exe -m 0 -a 3 -i --increment-min=6 --increment-max=10 c2f49cb8fc6a4259743930a920762f6f ?l?l?l?l?l?l?l?l?l?l

Este comando es similar al anterior, pero se han agregado tres nuevas opciones (explicadas justo arriba):

• -i
• --increment-min=6
• --increment-max=10

Además, la longitud de la máscara se ha aumentado a 10 caracteres: ?l?l?l?l?l?l?l?l?l?l (como lo requieren las reglas para usar las opciones de incremento).

Se necesitó un poco más de tiempo para completar la búsqueda, ya que se probaron candidatos a contraseñas de 6 (+0 segundos en mi caso) y 7 símbolos (+1 segundo) además:

Observa el nuevo valor de la línea de Status:

Status...........: Exhausted

Significa que se probaron todos los candidatos a contraseñas, pero ninguno resultó válido.

Descifrado de Contraseñas Cuando se Conocen Algunos Caracteres

Hay situaciones en las que se conocen algunos de los símbolos de la contraseña. Por ejemplo, se nos da el mismo hash c2f49cb8fc6a4259743930a920762f6f y de alguna manera nos enteramos de que los primeros tres caracteres de la contraseña son ‘esg‘. En este caso, puedes especificar directamente estos caracteres en la máscara:

esg?l?l?l?l?l?l?l

El comando es:

.\hashcat.exe -m 0 -a 3 -i --increment-min=6 --increment-max=10 c2f49cb8fc6a4259743930a920762f6f esg?l?l?l?l?l?l?l

Los símbolos conocidos pueden ubicarse en cualquier parte de la máscara: al principio, en el medio, al final; pueden ser caracteres individuales o grupos de caracteres.

Conjuntos de Caracteres Definidos por el Usuario en Hashcat

Arriba, ya se enumeraron los conjuntos de caracteres integrados, que generalmente son suficientes. Sin embargo, puedes especificar hasta cuatro conjuntos personalizados propios.

Supongamos que sabemos que los tres primeros caracteres en la contraseña son dígitos, y no todos, sino solo los números del 0 al 4; el cuarto carácter son solo letras mayúsculas, y los quinto y sexto caracteres son las letras de la ‘a’ a la ‘h’, así como los números del 5 al 9.

Si en la máscara para los primeros tres caracteres simplemente indicamos los números, entonces obviamente también se probarán candidatos inapropiados para contraseñas (que contengan en las tres primeras posiciones números que no estén en el rango del 0 al 4). Debemos excluir las contraseñas obviamente inapropiadas. Esto se puede hacer usando conjuntos de caracteres personalizados.

En total hay cuatro conjuntos de caracteres definidos por el usuario. Se especifican en las opciones y se representan por números. Pero en las opciones, se coloca un guion antes del dígito (por ejemplo, el primer conjunto de usuario es -1), y se coloca un signo de interrogación en la máscara antes del dígito (por ejemplo, el uso de los símbolos del primer conjunto de usuario es ?1).

Por lo tanto, para resolver el problema, comenzamos configurando el número requerido de conjuntos de usuario en las opciones. Estos conjuntos pueden consistir en caracteres listados directamente, también puedes usar conjuntos de caracteres integrados, como ?l o ?d o ?u (en cualquier combinación).

El primer conjunto de caracteres personalizado para nuestra tarea (solo números del 0 al 4):

-1 01234

El segundo conjunto de caracteres definido por el usuario (letras de ‘a’ a ‘h’, así como números del 5 al 9):

-2 abcdefgh56789

Permíteme recordarte: los conjuntos de caracteres personalizados se escriben entre las opciones (antes de la máscara y antes del hash).

Ahora crea una máscara (los tres primeros caracteres de la contraseña son números, no todos, sino solo los números del 0 al 4; el cuarto carácter son solo letras mayúsculas, y los quinto y sexto caracteres son las letras de ‘a’ a ‘h’, así como los números del 5 al 9):

?1?1?1?u?2?2

Descompondremos la máscara: los tres primeros caracteres se designan como ?1?1?1 (estos son dígitos ‘1’ y no la letra minúscula ‘L’, son dígitos ‘1’) son símbolos del primer conjunto de usuario. Luego sigue ?u, que es un conjunto de caracteres integrado que denota solo letras mayúsculas. Los dos caracteres siguientes se designan como ?2?2, que son símbolos del segundo conjunto de usuario.

Cuando especifiques conjuntos personalizados, puedes usar la notación de conjuntos de caracteres integrados, por ejemplo:

-1 ?l?u

denota el primer conjunto de usuario que consiste únicamente de letras latinas mayúsculas y minúsculas.

Y

-1 ?l?u?d

significa el primer conjunto de usuario que consiste únicamente de letras latinas mayúsculas y minúsculas, así como números.

Como se mostró anteriormente, puedes usar conjuntos de caracteres personalizados y predefinidos en cualquier combinación en la máscara.

Cómo Mostrar Contraseñas (Crear un Diccionario) en Hashcat sin Iniciar un Descifrado

Después de crear máscaras complejas, especialmente con el uso de conjuntos de caracteres personalizados, es posible que deseemos verificar si lo hicimos todo correctamente. Además, gracias a la flexibilidad de la sintaxis de Hashcat, es conveniente usarlo para generar diccionarios según cualquier criterio.

Para mostrar solo contraseñas sin iniciar un descifrado, se utiliza la opción --stdout. Esta opción requiere -a 3 (modo de ataque de máscara). Dado que el descifrado no se inicia en este caso, no es necesario especificar ningún hash.

Un ejemplo de generación de contraseñas para la tarea mencionada anteriormente (se sabe que los tres primeros caracteres de la contraseña son números, no todos, sino solo números del 0 al 4; el cuarto carácter es solo letras mayúsculas, y los quinto y sexto caracteres son letras de ‘a’ a ‘h’, así como números del 5 al 9):

.\hashcat.exe --stdout -a 3 -1 01234 -2 abcdefgh56789 ?1?1?1?u?2?2

Dado que se crearán muchas contraseñas (más de medio millón), en lugar de mostrarlas en la pantalla, se pueden guardar en un archivo. Para hacerlo, después del comando principal, debes colocar el símbolo > (que significa redirigir la salida a un archivo) y escribir el nombre del archivo. Por ejemplo, para guardar todas las contraseñas en el archivo lab1.dic, que se creará en la misma carpeta que el ejecutable hashcat.exe:

.\hashcat.exe --stdout -a 3 -1 01234 -2 abcdefgh56789 ?1?1?1?u?2?2 > lab1.dic

Cómo Crear una Máscara si No se Sabe nada sobre la Contraseña

Si no sabes qué caracteres están en la contraseña, ni cuál es su longitud, deberás probar todas las posibles candidatas de contraseñas.

Podemos hacer tres suposiciones condicionales:

• La contraseña puede contener números, así como letras mayúsculas y minúsculas.
• La contraseña puede contener números, letras mayúsculas y minúsculas, así como otros símbolos (puntos, guiones, comas, comillas, espacios, signos de porcentaje, almohadillas, etc.).
• La contraseña puede contener números, letras mayúsculas y minúsculas, otros símbolos (puntos, guiones, comas, comillas, espacios, signos de porcentaje, almohadillas, etc.), así como letras de alfabetos nacionales (cirílico, jeroglíficos, etc.).

¿Cuál es el problema con buscar una contraseña para todos los caracteres a la vez? Vamos a recurrir a la fórmula para el número de combinaciones posibles:

número de caracteres(longitud de la contraseña)

Es decir, el número de caracteres posibles en la contraseña elevado a un número, que es la longitud de la contraseña. Además, si no conocemos la longitud, entonces es necesario realizar un ataque de fuerza bruta de la siguiente manera:

(número de caracteres)¹ + (número de caracteres)² + (número de caracteres)³ + (número de caracteres)⁴ + (número de caracteres)⁵ + …

Esto significa que debes iterar sobre todas las contraseñas que tienen una longitud de un carácter, luego todas las contraseñas que tienen una longitud de dos caracteres, y así sucesivamente.

En la práctica, para muchos algoritmos de descifrado, esto significa que es imposible adivinar la contraseña en un tiempo razonable.

Por lo tanto, si no tienes idea sobre la contraseña, quizás puedas comenzar con un ataque de diccionario. Puede resultar más eficiente que esperar miles de millones de años para fuerza bruta de contraseñas.

Sin embargo, si necesitas ejecutar un ataque de fuerza bruta, cuando la contraseña puede contener letras latinas mayúsculas y minúsculas, así como números y la longitud de la contraseña puede ser de 1 a 12, debes usar las siguientes opciones y máscara:

-i --increment-min=1 --increment-max=12 -1 ?l?u?d ?1?1?1?1?1?1?1?1?1?1?1?1

Para enumerar todas las posibles contraseñas o guardarlas en un diccionario:

hashcat --stdout -a 3 -i --increment-min=1 --increment-max=12 -1 ?l?u?d ?1?1?1?1?1?1?1?1?1?1?1?1

Si necesitas ejecutar un ataque de fuerza bruta cuando la contraseña puede contener letras latinas mayúsculas y minúsculas, números y símbolos !"#$%&'()*+,-./:;<=>?@[]^_`{|}~ y la longitud de la contraseña puede ser de 1 a 12, debes usar las siguientes opciones y máscara:

-i --increment-min=1 --increment-max=12 ?a?a?a?a?a?a?a?a?a?a?a?a

Para enumerar todas las posibles contraseñas o almacenarlas en un diccionario:

hashcat --stdout -a 3 -i --increment-min=1 --increment-max=12 ?a?a?a?a?a?a?a?a?a?a?a?a

Ejemplos de Hashes

El programa Hashcat incluye no solo ayuda, sino también ejemplos de hashes. Pueden ser útiles si tienes dificultades para escribir correctamente el formato del hash.

Para mostrar todos los ejemplos de hashes de una vez, ejecuta el programa con la opción –example-hashes:

.\hashcat.exe --example-hashes

Puedes ver una muestra de un hash específico. Por ejemplo, si necesitas saber cómo se ve un hash para descifrar una contraseña RAR5, puedes consultar la página de ayuda del programa y buscar “RAR5”. Ahí encontrarás que el número de este hash es 13000. Luego, ejecutas el programa con la opción --example-hashes y la opción ya conocida -m (después de la cual se especifica el número del modo de hash).

.\hashcat.exe --example-hashes -m 13000

Entonces, para descifrar contraseñas de archivos RAR5, el hash debería lucir así:

1
$rar5$16$38466361001011015181344360681307$15$00000000000000000000000000000000$8$cc7a30583e62676a

En conclusión, Hashcat emerge como una herramienta esencial en el campo de la seguridad informática, capaz de desentrañar el enigma de las contraseñas cifradas con una potencia impresionante.

A través de este manual, hemos explorado desde los fundamentos hasta ejemplos concretos, brindándote las habilidades necesarias para enfrentar desafíos criptográficos.

Recuerda siempre actuar con responsabilidad y ética al utilizar Hashcat, aprovechando su poder para proteger sistemas y mejorar la seguridad digital.