Descifrar contraseñas con Hashcat

Uso básico de Hashcat

Hashcat es un software que automatiza la labor de hallar hashes con el objeto de descifrar contraseñas. Hashcat contiene varios modos de ataque (por diccionario, fuerza bruta, etc) y múltiples tipos de hashes soportados, la principal limitación para estos programas es el hardware ya que son procesos que suelen consumir muchos recursos.
En cuanto al hardware necesario para que este programa pueda descifrar algo, se aplica la misma regla que a cualquier otro software del estilo, necesitamos una buena gráfica, o en su defecto un buen procesador, el motivo de este requerimiento es poder comprobar el mayor número de hashes por segundo posible, debemos tener en cuenta esto porque en el caso de hacerlo por fuerza bruta nos podrá requerir mucho tiempo si comprueba unos 500 hashes por segundo, por ejemplo. En el caso de los handshakes de WPA, si una clave tuviera 20 caracteres tardaría una media de 300 días con un procesador intel i5, si hacemos la prueba, comprobaremos que un buen hardware es decisivo para ésta clase de tareas. Si no disponemos de una máquina con suficiente capacidad, existen soluciones como cloudcracker.com en la cual podremos suministrar el handshake a descifrar por un precio determinado. Para reducir el tiempo podemos aprovechar la gpu de nuestra tarjeta gráfica en el caso que tengamos un chipset compatible (como cuda, por ejemplo), en este caso la herramienta se llama oclHashcat, la cual podremos instalar desde los repositorios de Kali Linux.
Para comenzar nos salta un problema, al instalarlo desde el repositorio de kali e iniciarlo, nos suelta: “El software está desactualizado”.

captura_desactualizacion

Así que para evitarnos problemas, nos vamos a su página oficial y nos bajamos la última versión.
Una vez lo descarguemos, descomprimimos e ingresamos en el directorio creado. Si estamos usando GNU/Linux debemos usar el archivo binario (.bin), en Windows usaremos el archivo ejecutable (.exe). La forma de uso es la misma que cualquier comando de Linux. En el caso de Microsoft Windows, lo ejecutaremos desde el símbolo del sistema (CMD), podemos ver la ayuda ejecutando:

./hashcat-cli64.bin –help

Hashcat maneja una serie de referencias numéricas para algunos modificadores que están descritas aquí abajo.

* Outfile formats:

1 = hash[:salt]
2 = plain
3 = hash[:salt]:plain
4 = hex_plain
5 = hash[:salt]:hex_plain
6 = plain:hex_plain
7 = hash[:salt]:plain:hex_plain
8 = plain:position

* Debug mode output formats (for hybrid mode only, by using rules):

1 = save finding rule
2 = save original word
3 = save original word and finding rule

* Built-in charsets:

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

* Attack modes:

0 = Straight
1 = Combination
2 = Toggle-Case
3 = Brute-force
4 = Permutation
5 = Table-Lookup

* Hash types:

0 = MD5
10 = md5($pass.$salt)
20 = md5($salt.$pass)
30 = md5(unicode($pass).$salt)
40 = md5($salt.unicode($pass))
50 = HMAC-MD5 (key = $pass)
60 = HMAC-MD5 (key = $salt)
100 = SHA1
110 = sha1($pass.$salt)
120 = sha1($salt.$pass)
130 = sha1(unicode($pass).$salt)
140 = sha1($salt.unicode($pass))
150 = HMAC-SHA1 (key = $pass)
160 = HMAC-SHA1 (key = $salt)
200 = MySQL
300 = MySQL4.1/MySQL5
400 = phpass, MD5(WordPress), MD5(phpBB3)
500 = md5crypt, MD5(Unix), FreeBSD MD5, Cisco-IOS MD5
800 = SHA-1(Django)
900 = MD4
1000 = NTLM
1100 = Domain Cached Credentials, mscash
1400 = SHA256
1410 = sha256($pass.$salt)
1420 = sha256($salt.$pass)
1430 = sha256(unicode($pass).$salt)
1440 = sha256($salt.unicode($pass))
1450 = HMAC-SHA256 (key = $pass)
1460 = HMAC-SHA256 (key = $salt)
1600 = md5apr1, MD5(APR), Apache MD5
1700 = SHA512
1710 = sha512($pass.$salt)
1720 = sha512($salt.$pass)
1730 = sha512(unicode($pass).$salt)
1740 = sha512($salt.unicode($pass))
1750 = HMAC-SHA512 (key = $pass)
1760 = HMAC-SHA512 (key = $salt)
1800 = SHA-512(Unix)
2400 = Cisco-PIX MD5
2500 = WPA/WPA2
2600 = Double MD5
3200 = bcrypt, Blowfish(OpenBSD)
3300 = MD5(Sun)
3500 = md5(md5(md5($pass)))
3610 = md5(md5($salt).$pass)
3710 = md5($salt.md5($pass))
3720 = md5($pass.md5($salt))
3810 = md5($salt.$pass.$salt)
3910 = md5(md5($pass).md5($salt))
4010 = md5($salt.md5($salt.$pass))
4110 = md5($salt.md5($pass.$salt))
4210 = md5($username.0.$pass)
4300 = md5(strtoupper(md5($pass)))
4400 = md5(sha1($pass))
4500 = sha1(sha1($pass))
4600 = sha1(sha1(sha1($pass)))
4700 = sha1(md5($pass))
4800 = MD5(Chap)
5000 = SHA-3(Keccak)
5100 = Half MD5
5200 = Password Safe SHA-256
5300 = IKE-PSK MD5
5400 = IKE-PSK SHA1
5500 = NetNTLMv1-VANILLA / NetNTLMv1-ESS
5600 = NetNTLMv2
5700 = Cisco-IOS SHA256
5800 = Samsung Android Password/PIN
6300 = AIX {smd5}
6400 = AIX {ssha256}
6500 = AIX {ssha512}
6700 = AIX {ssha1}
6900 = GOST, GOST R 34.11-94
7000 = Fortigate (FortiOS)
7100 = OS X v10.8
7200 = GRUB 2
7300 = IPMI2 RAKP HMAC-SHA1
7400 = sha256crypt, SHA256(Unix)
9999 = Plaintext

* Specific hash types:

11 = Joomla
21 = osCommerce, xt:Commerce
101 = nsldap, SHA-1(Base64), Netscape LDAP SHA
111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA
112 = Oracle 11g
121 = SMF > v1.1
122 = OS X v10.4, v10.5, v10.6
123 = EPi
131 = MSSQL(2000)
132 = MSSQL(2005)
141 = EPiServer 6.x < v4
1441 = EPiServer 6.x > v4
1711 = SSHA-512(Base64), LDAP {SSHA512}
1722 = OS X v10.7
1731 = MSSQL(2012)
2611 = vBulletin < v3.8.5
2711 = vBulletin > v3.8.5
2811 = IPB2+, MyBB1.2+
3721 = WebEdition CMS
7600 = Redmine Project Management Web App

Una vez vista la ayuda sólo tenemos que formar el comando según nuestras necesidades. El uso de hashcat es similiar a cualquier comando en linux:

hashcat [options] hashfile [mask|wordfiles|directories]

Primero las opciones o modificadores, luego indicamos la ruta del archivo donde se encuentra el hash, y podremos indicarle una máscara, o un archivo o serie de archivos o un directorio. Hashcat cuenta con una serie de modificadores algunos de los más comunes son los siguientes:

-m Le indicamos el tipo de hash que queremos desencriptar, los hashes y sus respectivos números están definidos en la ayuda más arriba.

-a Con este modificador le indicamos el tipo de ataque que vamos a emplear, entre otros tipos encontramos fuerza bruta o permutación, con ellos podremos comprobar a base de diccionario, haciendo combinaciones entre uno o varios diccionarios e incluso alterando las propias palabras del diccionario, como por ejemplo cambiar las “o” por “0” o la “E” por “3”.

-V Nos mostrará la version actual de hashcat.

-n Controlamos el número de hilos (threads) que va a lanzar hashcat. Debemos tener en cuenta que cuantos más threads, más consumo y más calentamiento para nuestra máquina.

-o Definimos el fichero de salida.

–output-format=NUM definimos el formato de salida con un número, podemos ver la lista de formatos más arriba, en la ayuda.

Cuando introducimos el comando correctamente nos irá mostrando el proceso como se ve en la siguiente captura.

Hashcat_Proceso

Ataque con Máscaras

Una parte importante de hashcat son las máscaras y el control que podemos tener sobre ellas, con esto, podremos indicar qué tipo de caracteres queremos probar y así ahorramos comprobaciones con tipos de caracteres que no tenga. Los tipos de caracteres que podemos probar son:

?a - Mayúsculas, minúsculas, numéricos y especiales
?u - Mayúsculas
?l - Minúsculas
?d - Números
?s - Caracteres especiales
?b - Bytes  
?1-4 - Caracteres personalizados

La longitud a probar la indicamos con la longitud de la máscara, aunque también tenemos modificadores para comenzar desde un número de caracteres determinado o poner un límite de caracteres máximos, para ello podemos usar el modificador increment, que irá sumando 1 a la longitud de caracteres a probar:

--increment                   Habilita el modo autoincremento
--increment-min=NUM           Comienza el incremento en el NUM
--increment-max=NUM           Detiene el incremento en el NUM

Un ejemplo de una máscara para un password es el siguiente:

Password: **ABc99  ---  Máscara: ?s?s?u?u?l?d?d
 Password: Manolo  ---  Máscara: ?u?l?l?l?l?l
 Password: 001234  ---  Máscara: ?d?d?d?d?d?d

También podemos crearnos un juego de caracteres personalizado, para ello usaremos los modificadores -1, -2, -3 y -4, con ellos podemos dejar otro carácter predefinido en las opciones para luego usarlo en nuestra máscara. Un ejemplo podría ser el siguiente:

./hashcat-cli64.bin -m11 -a3 -1?dABCDEF archivo.hccap ?1?1?1?1?1?1?1

En este caso le estamos indicando con -1 que cuente con números (?d) y letras mayúsculas de la A a la F. Ahora tan sólo nos queda fabricarnos una máscara “eficiente” y comprobar cuanto tiempo tardaría en probar todas las combinaciones posibles.