Cracking de contraseñas con hashcat

Vamos a hablar de la obtención de contraseñas mediante la herramienta Hashcat, posiblemente la

herramienta más extendida y eficaz para este propósito, al alcance de cualquier persona interesada en el
tema.

Para ello vamos a utilizar la versión 3.00 de la misma, ya que a partir de esta versión se deja de lado la
separación entre ataques basados en la potencia de la CPU(antiguo Hashcat) y los ataques basados en la
potencia de las tarjetas gráficas (HaschatOCL), para unir en una sola herramienta ambas opciones, aunque la
mayor parte de los ataques que se explicarán en este artículo son válidos en versiones anteriores de esta
herramienta.

Una de las tareas más importantes a la hora de crackear contraseñas cuando no disponemos de tiempo
infinito (que suele ser bastante a menudo), es la planificación del propio ataque. Para ello, deberemos medir
el tiempo que tenemos para el mismo, y en función de éste, limitar nuestras opciones de crackeo a aquellas
tipologías de contraseña que creamos más probables de obtener en el tiempo que disponemos. Ésta no es
una tarea sencilla, ya que la tipología de las contraseñas utilizadas puede depender de muchos factores
entre los que se encuentra, por ejemplo, el país y el lenguaje de los usuarios de esas contraseñas o la edad
media de los mismos, por lo que cuanta más información de contexto tengamos más podremos afinar en
nuestra planificación.

Aun así, todos sabemos que la raza humana, con toda la diversidad de civilizaciones, etnias, ideologías,
niveles socioculturales y económicos que la conforman, converge en un único pensamiento cuando de forma
inesperada, recibe estas solemnes palabras: “Inserta tu nueva contraseña”: “Pues pongo mi nombre”
Afortunadamente, existieroncd /pwd personas antes que nosotros que se dieron cuenta de este hecho y
pusieron límites a este pensamiento, haciendo obligatorio que la respuesta a esa pregunta contuviera, por
ejemplo, mayúsculas, minúsculas y algún número. Pero una vez más, gran parte de la humanidad se unió
telepáticamente para dar una repuesta única: “Pues mi nombre en mayúscula y mi año de nacimiento”.

Evidentemente he exagerado un poco en esa respuesta única, todas las personas no son iguales, por lo que
existen distintas variantes de esa respuesta en las que se puede cambiar el nombre de la persona por el
nombre de la mascota o el nombre del pueblo natal y la fecha de nacimiento por la edad en años, con la
ventaja añadida de que se puede cambiar cada año de contraseña simplemente sumándole un año a la del
año anterior. Todas estas variantes hacen del crackeo de contraseñas un ejercicio bastante entretenido.
A modo de ejemplo para este post, elegiremos nos centraremos en el objetivo de obtener las contraseñas de
un máximo de 12 caracteres, que empiecen por un nombre seguido de la fecha de nacimiento, e intentaremos
optimizar esta búsqueda mediante las distintas opciones que nos ofrece hashcat.

En primer lugar, partiremos de la base que ya disponemos de la herramienta hashcat en nuestro equipo y de
que tenemos un archivo hashdump.txt con hashes de contraseñas obtenidos en una auditoria a equipos
Windows mediante la herramienta hashdump, el cual tiene el siguiente formato:
user1:7362:aad3b435b51404eeaad3b435b51404ee:b562d5031359813a06914d562d421acd:::
user2:7787:aad3b435b51404eeaad3b435b51404ee:3b7a5bb9f8a12f74dadb7adf740cf7c1:::
user3:7788:aad3b435b51404eeaad3b435b51404ee:2501dd5aa075d4854559a5ee023df798:::
user4:7789:aad3b435b51404eeaad3b435b51404ee:11cdb1cb2b21aba701d1113fcf6e3c4f:::
user5:7790:aad3b435b51404eeaad3b435b51404ee:722ab3c822cb6a49bf89830bb5ffaea9:::
user6:7800:aad3b435b51404eeaad3b435b51404ee:79aff34e34c1fa16fffc7c6765e23636:::
user7:7801:aad3b435b51404eeaad3b435b51404ee:73366d77424b259794cac80f4e3fc8c9:::
user8:7803:aad3b435b51404eeaad3b435b51404ee:e2ad4eff06322cf9240ab93288fda61c:::

Este formato contiene, para cada línea, los siguientes campos separados por ‘:’

(Usuario):(SID):(hash LM):(hashNTLM):::

Como podemos observar, el tercer campo (hash en formato LM) es siempre el mismo para todas las entradas
(aad3b435b51404eeaad3b435b51404ee). Este hash corresponde con el hash LM de la cadena vacía, e indica
que el sistema de donde hemos obtenido la tiene deshabilitado los hashes LM (deshabilitado por defecto a
partir del Windows Vista), por lo que nos centraremos en el cuarto campo (hash NTLM).

Lo primero que haremos crear un archivo ntlm.hp que contenga únicamente ese campo, mediante cualquier
herramienta que nos lo permita, por ejemplo AWK:
awk –F’:’ ‘{print $4 >> ntlm.hp}’ hashdump.txt

Ahora necesitamos indicarle a hashcat el tipo de hash que le estamos proporcionando, y lo haremos
utilizando el parámetro –m (hash mode). Observando el apartado [ Hash modes ] con el
comando ./hashcat64.bin -h podemos obtener este valor (1000):
Con todo esto, lo siguiente será elegir entre los distintos tipos de ataques que nos proporciona Hashcat, los
cuales los podemos ver en el apartado [ Attack Modes ] de la misma ayuda.

0 – Straight

Este ataque es el que conocemos como ataque por diccionario. Haschat comprobara si la contraseña
corresponde con alguna de las palabras del diccionario que le pasemos como argumento.

1 – Combination
En este caso, hashcat recibirá dos diccionarios como argumentos, y comprobará si la contraseña
corresponde con la combinación de cada uno de los términos del primer diccionario con cada uno de los
términos del segundo.

3 – Brute-force
Al contrario de los casos anteriores, en este caso el propio hashcat será el encargado de generar las
contraseñas que comprobara contra los hashes. Para esto, se basará en las llamadas máscaras, mediante las
cuales podremos indicarle que tipo de contraseñas queremos que genere.

4 – Hybrid
Hashcat nos permite combinar la potencia de los ataques por diccionario y los ataques por fuerza bruta
(mask atacks). En los ataques híbridos, podremos generar parte de una contraseña con los términos de un
diccionario y completarla mediante máscaras.

Como hemos adelantado anteriormente, a continuación intentaremos cumplir nuestro objetivo de obtener
todas aquellas contraseñas que contengan un nombre seguido de una fecha de nacimiento mediante los
tipos de ataque mostrados anteriormente.
Brute-force (Ataque con máscaras)

Para ejecutar esta modalidad de ataque sobre nuestro archivo de hashes NTLM, únicamente necesitaremos
decirle a hashcat que el tipo de hashes que contiene el archivo es NTLM (-m 1000) y que queremos ejecutar
un ataque por fuerza bruta (-a 3).v
hashcat64.bin –m 1000 –a 3 ntlm.hp

Si ejecutamos este comando, hashcat generará y comprobará contraseñas a partir de una serie de máscaras
predefinidas por defecto, pero para el objetivo de este artículo, crearemos nuestras propias máscaras.

¿Pero que es una máscara? Una máscara es un conjunto de reglas que indican como están formadas las
contraseñas que queremos generar. Más concretamente, una máscara especificará, para cada posición de la
contraseña, el conjunto de caracteres que puede tener.

Cada posición de nuestra máscara puede contener un carácter fijo o un charset, que no es más que un
conjunto caracteres.

Al contrario de los caracteres fijos, los charsets irán precedidos del signo de interrogación.

En la propia ayuda de hashcat podemos observar los charsets predefinidos de hashcat:

Como se puede observar, todos los charsets son una serie de caracteres definidos, excepto el charset ?a, que
está formado por la combinación de los charsets ?l,?u,?d y ?s.

La razón de esto es que hashcat permite definir un charset como la combinación de otros charsets, por
ejemplo, si quisiéramos definir un charset que contuviera tanto mayúsculas como minúsculas podríamos
definirlo de la siguiente manera: ?l?u
Ejemplos de ataques utilizando máscaras:

hashcat64.bin –m 1000 –a 3 ntlm.hp pass1234

Comprobaría únicamente la contraseña (pass1234), mientras que el comando:
hashcat64.bin –m 1000 –a 3 ntlm.hp pass?d?d?d?d
Comprobaría todo el espectro de contraseñas que empezaran por “pass” y cuyos cuatro siguientes caracteres
fueran dígitos decimales (pass0000-pass9999)

Mediante la máscara ?a?a?a?a?a?a?a?a?a?a?a?a, podemos simular un típico ataque por fuerza bruta para
comprobar todas las contraseñas de 12 caracteres de cualquier combinación de dígitos decimales, signos,
mayúsculas y minúsculas.

Además, para no tener que crear una máscara para cada longitud de contraseña que queramos probar,
hashcat nos proporciona el argumento –i (–increment), con el que hashcat irá probando iterativamente las n
primeras posiciones de la máscara para cada iteración hasta el máximo de caracteres que hayamos
especificado con el argumento –increment-max o el tamaño de la máscara en caso de que no se lo hayamos
especificado.
Por ejemplo para el comando:
./hashcat64.bin –m 1000 –a 3 ntlm.ph ?a?a?a?a?a –i –increment—min 2 increment—max
4

Se probarán secuencialmente las máscaras:

?a?a
?a?a?a

?a?a?a?a
Como podemos observar en la línea Progres y Time.estimated de la imagen, al ejecutar el ataque mediante la
máscara ?a?a?a?a?a?a?a?a?a?a?a?a, se generarán y se comprobarán un total de 180602555536776954753
combinaciones, que en nuestra máquina, que dispone de 2 potentes tarjetas gráficas, tardaría más de 10 años
en completarse.
Con el fin de reducir las combinaciones posibles para nuestro objetivo, podríamos utilizar la
máscara ¿u?l?l?l?l?l?l?l?ld?d?d?d que comprendería todo el espectro de contraseñas desde Aaaaaaaa0000
hasta Zzzzzzzz9999.

Esto incluiría prácticamente todos los nombres posibles de hasta 8 letras seguidos de todas las fechas de
nacimiento desde el año 0 hasta el 9999 D.C.
Aunque hemos reducido considerablemente el tiempo necesario para probar todas las posibles
combinaciones de nuestro objetivo de más de 10 años a menos de 2 días, todavía estamos probando muchas
contraseñas que no se ajustan a nuestro objetivo, como por ejemplo todas aquellas que contengan una
fecha de nacimiento anterior a 1900 o posterior a 2017, por lo que todavía podemos intentar reducir este
tiempo creando una máscara que descarte las mismas, y para ello, será necesario definir nuestros
propios charsets.
Hashcat permite utilizar para cada ataque 4 charsets (custom-charsets) personalizables por el usuario,
mediante los argumentos -1, -2, -3 y -4.
En este caso, necesitaremos crear 2 máscaras, una para aquellas contraseñas que contengan la fecha de
nacimiento desde 1900 hasta 1999:

./hashcat64.bin -m 1000 -a 3 ntlm.hp ?u?l?l?l?l?l?l?l19?d?d

Y otra para aquellas del 2000 al 2017.

./hashcat64.bin -m 1000 -a 3 ntlm.hp -1 01 -2 012345678 ?u?l?l?l?l?l?l?l20?1?2

Para esta última, hemos definidos 2 charsets propios:
-1 01, que utilizaremos para decirle a la máscara que el carácter que representa las decenas de la fecha de
nacimiento solo podrá contener el valor 0 o 1, y así evitar que genere aquellas fechas desde 2020.
-2 012345678, que utilizaremos para evitar que genere la contraseña 2019.
EDIT: También elimina la 2009

Con esto, habremos reducido el tiempo de cerca de 2 días a menos de 30 minutos.

Hay que tener en cuenta que para nuestro objetivo, no podemos utilizar la opción –incremental, ya que esta
opción no cumpliría nuestros requisitos al ir eliminando las últimas posiciones de la máscara, por lo que
tendremos que crear una máscara distinta para cada longitud de contraseña de la siguiente manera:

¿u?l?l?l?l?l?l?l?ld?d?d?d
¿u?l?l?l?l?l?l?ld?d?d?d

¿u?l?l?l?l?l?ld?d?d?d

….

¿u?l?d?d?d?d
Para complicar algo más la cosa, algunos administradores, han tenido la valentía enfrentarse a la furia de los
usuarios y les han obligado a crear contraseñas que contengan al menos, un signo de puntuación.

Para contemplar esta opción, podríamos añadir a nuestra máscara la opción de que se los nombres también
contuvieran signos de puntuación.

Para ello añadiremos los customs-charsets:

-3 ?u?s : Donde antes habían mayúsculas ahora también pueden haber símbolos
-4 ?l?s : Donde antes habían minúsculas ahora también pueden haber símbolos
Como podemos observar, al añadir estas opciones volveremos a aumentar el tiempo estimado en 2 días,
¿podríamos optimizar esto un poquito más?
Una de las cosas a tener en cuenta con este ataque, es que obtendríamos aquellas contraseñas como
Paquito.2010, pero también cosas como ##_*#.-##2010.

Aunque en algunos contextos puede valer la pena comprobar este tipo de contraseñas, Según nuestra teoría
del pensamiento universal, la mayoría de gente intentará realizar el mínimo esfuerzo para cumplir con las
políticas de contraseña, por lo que optarán con poner un solo símbolo de puntuación.

Con esta premisa, crearemos una máscara para cada posición en la que pueda estar el signo de puntuación,
evitando así la generación de contraseñas en las que haya más de un signo de puntuación.

Con una media de 5 minutos y 30 segundos para cada máscara con un signo de puntuación, necesitaremos
cerca de 60 minutos para comprobar todas las posibles posiciones del signo de puntuación.

Como hemos observado, para optimizar nuestra búsqueda, ha sido necesario crear distintas máscaras, lo
que genera el inconveniente de tener que estar pendientes de que acabe un ataque con una máscara para
ejecutar la otra.

Para evitar esta situación, hashcat permite pasarle como argumento un archivo de máscaras (una por línea),
que ejecutara secuencialmente, para ello dispone del directorio masks, donde podemos encontrar ejemplos
de máscaras. Además, esto nos permitirá tener almacenadas las diferentes estrategias de ataque que
vayamos creando para utilizarlas cuando más nos convenga. En nuestro caso, el archivo con las máscaras
tendría esta forma.
Como podemos observar en las últimas máscaras de la imagen, cuando especificamos nuestros
propios charsets para cada máscara en un fichero, no lo haremos de la misma manera que en la línea de
comandos. Sino que separaremos cada uno de los custom-charsets por comas.
Por ejemplo, donde antes teníamos los ataques:

./hashcat64.bin –m 1000 –a 3 -1 ABC -2 aeiou ?1?1?1?1?2?2?2?2

./hashcat64.bin –m 1000 –a 3 -1 ?l?u ?a?a?a?a?1?1?1?1

Ahora tendremos un fichero ejemplo.hcmask que contendrá las líneas:

ABC,aeiou,?1?1?1?1?2?2?2?2
?l?u,?a?a?a?a?1?1?1?1

Y ejecutaremos el ataque con el siguiente comando.

./hashcat64.bin –m 1000 –a 3 ejemplo.hcmask

Los charsets que definamos, también puedes que pueden ser almacenados en ficheros .hcchr para poder
utilizarlos posteriormente. Encontraremos ejemplos de estos ficheros en el directorio charsets.

Straight (Ataque por diccionario)

Aunque hemos conseguido optimizar bastante nuestra búsqueda mediante ataques basados en máscaras,
las probabilidades de que exista alguna persona que se llame Aaaaaaaaa o Zxcfdcvilio son bastante bajas, así
que todavía tenemos opciones de optimizar nuestro ataque.

Cuando tenemos una lista de palabras que puedan ser candidatas a formar parte de las contraseñas que
estamos buscando, existe la opción de realizar un ataque por diccionario. Para nuestro ejercicio, por
ejemplo, podemos utilizar los datos que nos proporciona el instituto nacional de estadística en su página
web www.ine.es/daco/daco42/nombyapel/nombyapel.htm, donde tenemos un listado con todos los
nombres femeninos y masculinos junto con datos estadísticos, lo que nos permitirá además, crear un
diccionario ordenado con los nombres de mayor a menor frecuencia, aumentando así la probabilidad de
encontrar más contraseñas en un tiempo menor.

Para ejecutar este ataque únicamente necesitaremos indicarle el tipo de hash seguido del archivo de hashes
y el archivo que contenga el diccionario, que en este caso será un archivo que contendrá los 9098 nombres
más comunes de España.

./hashcat64.bin -m 1000 -a 0 ntlm.hp nombres.dict

Como podemos observar en la hora de inicio y fin del ataque, la finalización del mismo es casi instantánea.

Pero con este ataque, no estamos cumpliendo con el requisito de que las contraseñas que finalicen con una
fecha de nacimiento. Para cumplir con este requisito, tendríamos la opción de modificar el diccionario
añadiendo a cada nombre incluido en el todas las fechas posibles, pero hashcat nos facilita esta tarea mediante
los ataques híbridos.

Ataques híbridos ( diccionario + máscara)

Hashcat dispone de dos variantes de ataques híbridos, la opción -6 (dict + mask), en la que generará
contraseñas añadiendo la máscara al final de cada término de diccionario, y la opción -7, en los que generará
contraseñas añadiendo la máscara al inicio de cada termino.

Para el objetivo que nos traemos entre manos, bastaría ejecutar un ataque hibrido -6 (dict+mask) con el fin
de añadir todas las posibles fechas a cada nombre del diccionario. Teniendo en cuenta que la ejecución del
ataque por diccionario ha sido instantánea, nos permitiremos el lujo de utilizar como mascara todas las
combinaciones de 4 dígitos (d?d?d?d).

./haschat64.bin -m 1000 -a 6 ntlm.hp nombres.dict ?d?d?d?d

Este ataque también finaliza instantáneamente.

Aunque los tiempos obtenidos mediante el ataque por diccionario y los ataques híbridos han sido con
diferencia los más bajos de todas las pruebas, estos ataques ofrecen poca flexibilidad para generar
contraseñas con patrones más complejos, como por ejemplo, para añadir que la primera letra del nombre
sea en mayúscula (habría que añadir todos los nuevos nombres con la inicial en mayúscula al diccionario), o
considerar la opción de que haya un signo de puntuación presente en la contraseña.