Présentation de Hashcat

Hashcat est présenté comme la référence d'utilitaire de récupération des mots de passe. Hashcat est sous licence MIT. L'outil s'appuie sur les évolutions techniques des architectures des processeurs, et principalement la technologie Cuda. Le code de l'application profite des possibilités offertes par les environnements d'exécution OpenCL. Hashcat supporte les runtimes : AMD,Appel,Intel,NVidia,POCL,ROCm).

Hashcat permet entre autres de réaliser une attaque par collision sur des empreintes cryptographiques. Le logiciel permet d'utiliser un ou plusieurs CPU, GPU, APU. De même Hashcat offre la possibilité de réaliser des grappes de calcul. Un ordinateur servant de « cerveau » (répartiteur de charges de travail) et les autres servant uniquement de puissance de calcul brute.

Hashcat supporte l'ensemble des algorithmes cryptographiques utilisés pour le cryptage irréversible des mots de passe (SHA512,HMAC-SHA512, etc.), même ceux considérés comme obsolètes (MD4,MD5,SHA1,etc.). Pas moins de 283 algorithmes sont supportés par Hashcat.

Hashcat permet de réaliser l'ensemble des modèles de mot de passe lors des attaques grâce aux différentes méthodes proposées :

  • Attaque par force brute et masque.
  • Attaque par dictionnaires.
  • Attaque par dictionnaires et règles.
  • Attaque par combinaison.
  • Attaque hybride.

Points abordés avec Hashcat :

Rappel sur le fonctionnement d'une sécurisation de mot de passe :

Pour comprendre l'intérêt d'un tel outil dans le cadre d'un audit de sécurité, il convient de comprendre le processus de sécurisation d'un mot de passe confié par l'utilisateur. Que ce soit dans le cas d'un processus correctement intégré, ou négligé.

Supposons un site internet où l'utilisateur s'enregistre avec le mot de passe : jean50$ Dans le cadre d'une intégration négligée, le mot de passe est simplement crypté (hasher) avec un algorithme irréversible. Il est ensuite stocké en base de données. L'empreinte du mot de passe stocké en base sera donc :

795a2b0847b3910d6c4e6b0bbdb219abb57d64cf3b5ad77b3c4419a25a4ad1ab61a669de9e0a8dd599838a6c0fbe8f25b74115afc6bd875b937e9a4586ddd9cc

Sur un site où la sécurité des informations des utilisateurs est prise au sérieux : le développeur aura pris la peine de générer une chaine de caractères aléatoires qui servira de salage (saltz) à l'aide d'un générateur de nombre pseudo aléatoire. (À l'aide de openssl_random_pseudo_bytes en PHP ou Rfc2898DeriveBytes en C# par exemple). Ce salage servira à renforcer la sécurité du mot de passe, car ainsi un même mot de passe n'aura pas deux fois la même empreinte en base de données. L'empreinte du mot de passe stocké en base sera donc :

1a156938fcece1c258dd7ef767023352d3d6af386c0f22beeb83696de4532874b5e8bba564604855d8a7b11e9dea53b29156ca47819953f537a46206f1ce5aa3

Le fonctionnement d'une attaque par collision

Le principe de l'attaque par collision est simple. Cette attaque vise à générer l'empreinte cryptographique d'une chaine de caractères (un mot) avec ou salage et de comparer le résultat ainsi obtenu avec l'empreinte cryptographique à casser.

Dans quel cas utiliser une attaque avec Hashcat ?

L'utilisation de Hashcat pour réaliser une attaque sur l'empreinte cryptographique d'un mot de passe se révèle pertinente principalement pour répondre à ces cas :

  • Attaque d'un hash exfiltré du SAM de Windows.
  • Attaque hors ligne d'un handshake lors d'une attaque sur un réseau WIFI en WPA.
  • Attaque sur une base de données compromises contenant des mots de passe utilisateurs/administrateur.
  • Attaque d'un hash d'un conteneur crypté (hors cryptage matériel).

Mise en œuvre d'attaques par collision avec Hashcat

Les paramètres à connaitre pour utiliser Hashcat :

Haschat examples d'utilisations

Les commandes de base à connaître pour exploiter le minimum de Hashcat :

  • --help = afficher plus de commande
  • -m = le type d'algorithme à utiliser pour réaliser l'attaque (valeur attendue : un entier).
  • -a = la méthode d'attaque (valeur attendue : un entier).
  • -O = optimisation du noyau.
  • --session = Le nom de la session de travail pour sauvegarder la progression de l'attaque.
  • -o = le fichier de sortie où sera stocké le résultat des collisions réussies (empreinte:mot de passe en clair).
  • --remove = pour dire à Hashcat de supprimer l'empreinte du fichier source si celle-ci est découverte.
  • --restore = restaurer la session de travail d'après son nom.
  • --increment = préciser l'attaque incrémentale par masque
  • --increment-min = nombre de caractères minimum pour le mot à essayer.
  • --increment-max = nombre de caractères maximum pour le mot à essayer.
  • -j = règle à appliquer à gauche.
  • -k = règle à appliquer à droite.

La table de transposition des types d'attaques :

  • 0 = Dictionnaire
  • 1 = Combinaison
  • 2 = Déclinaison
  • 3 = Force brute
  • 4 = Permutation
  • 6 = Hybride : mot du dictionnaire puis masque
  • 7 = Hybride : masque puis mot du dictionnaire

Hashcat examples

La table de transposition des principaux hash (liste complète disponible par --help) :

  • 0 = MD5
  • 1000 = Windows NT
  • 100 = SHA1
  • 1700 = SHA512
  • 20 = MD5 (saltz + password)
  • 30 = MD5 (password+saltz)

Hashcat type de hash supportés

Les masques et Hashcat :

Les masques répondent à une logique rédactionnelle très simple, un point d'interrogation suivie d'une lettre, chaque lettre correspondant à un type de jeu de caractères.

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

Ainsi pour générer un masque répondant au hash SHA512 de jean50$ il suffira de réaliser une attaque hybride par dictionnaire avec masque à droite :

hashcat64.exe -m 1700 -a 6 -O -o SHA512_Resolved.txt --remove SHA512_Hash_Password.hash prenoms.txt ?d?d?s

hashcat hash reverse

On constate qu'il n'aura même pas fallu plus d'une seconde à Hashcat pour résoudre cette empreinte cryptographique.

Les règles et Hashcat :

Pour générer des règles personnalisées pour Hashcat il faut un premier temps créer un nouveau fichier dans le dossier rules qui se trouve en racine du dossier de Hashcat. Les règles permettent d'effectuer toutes sortes de modifications sur les mots de passe fournies par un dictionnaire. Des concaténations, des découpages, des inversions de lettres, des remplacements, il n'y a pas de limite. Elles permettent également de refuser des mots qui ne correspondraient pas à un modèle spécifique (mot trop petit, mot trop grand, ou mot contenant une lettre ou un caractère particulier).

Fonctions de manipulation des chaines de caractères :
Nom Fonction Description Example Input Output
Rien : Ne rien faire : p@ssW0rd p@ssW0rd
Minuscule l Passe les lettres en minuscules l p@ssW0rd p@ssw0rd
Majuscule u Passe les lettres en majuscules u p@ssW0rd P@SSW0RD
Capitale c Passe la première lettre en majuscule, le reste en minuscule c p@ssW0rd P@ssw0rd
Invertion capitale C Première lettre en minuscule le reste en majuscule C p@ssW0rd p@SSW0RD
Inversation t Inverse majuscule et minuscule t p@ssW0rd P@SSw0RD
Inversation @ TN Inverse majuscule et minuscule à la position N T3 p@ssW0rd p@sSW0rd
Inverse le sens r Inverse l'ordre des lettres r p@ssW0rd dr0Wss@p
Duplique d Duplique l'ensemble du mot d p@ssW0rd p@ssW0rdp@ssW0rd
Duplique N pN Duplique le mot N fois p2 p@ssW0rd p@ssW0rdp@ssW0rdp@ssW0rd
Reflet f Inversion miroir f p@ssW0rd p@ssW0rddr0Wss@p
Reflet gauche { Pivote le mot vers la gauche { p@ssW0rd @ssW0rdp
Reflet droit } Pivote le mot vers la droite } p@ssW0rd dp@ssW0r
Suffixe un caractère $X Ajoute un caractère à la fin $1 p@ssW0rd p@ssW0rd1
Prefixe un caractère ^X Rajoute un caractère au début ^1 p@ssW0rd 1p@ssW0rd
Supprime à gauche [ Supprime le premier caractère [ p@ssW0rd @ssW0rd
Supprime à droite ] Supprime le dernier caractère ] p@ssW0rd p@assW0r
Supprime @ N DN Supprime le caractère à la position N D3 p@ssW0rd p@sW0rd
Garde un groupe xNM Garde M caractères depuis la position N x04 p@ssW0rd p@ss
Supprime un groupe ONM Supprime M caractères depuis la position N O12 p@ssW0rd psW0rd
Insertion @ N iNX Ajouter un caractère X depuis la position N i4! p@ssW0rd p@ss!W0rd
Remplace @ N oNX Remplace un caractère à la position N par la valeur de X o3$ p@ssW0rd p@s$W0rd
Découpe @ N 'N Découpe un mot depuis N '6 p@ssW0rd p@ssW0
Replace sXY Replace all instances of X with Y ss$ p@ssW0rd p@$$W0rd
Supprime instance @X Supprime toutes les occurences de X @s p@ssW0rd p@W0rd
Duplique début N zN Duplique le premier caractère N fois z2 p@ssW0rd ppp@ssW0rd
Duplique fin N ZN Duplique le dernier caractère N fois Z2 p@ssW0rd p@ssW0rddd
Duplique tout q Duplique chaque caractère q p@ssW0rd pp@@ssssWW00rrdd
Fonctions d'exclusions de Hashcat
Nom Fonction Description Exemple de règle
inférieur <N Rejet si la chaine de caractères est plus grand que N <G
supérieur >N Rejet si la chaine de caractères est plus petit que N >8
égal _N Rejet si la chaine de caractères n'est pas égal à N _7
contient !X Rejet si la chaine de caractères ne contient pas X !z
ne contient pas /X Rejet si le mot de passe contient X /e
débute par (X Rejet si le mot de passe ne commence pas par X (h
se termine par )X Rejet si le mot de passe ne se termine pas par X )t
charactère à la position =NX Rejet si la chaine de caractères ne contient pas le caractère X à la position N =1a
limite d'occurences %NX Rejet si la chaine de caractères contient le charactère X plus de N occurences %2a
L'attaque par force brute (ou attaque incrémentale) et masque avec Hashcat

L'attaque par force brute vise à essayer l'ensemble des possibilités lettre par lettre. Cette méthode est de loin la plus longue et la plus gourmande en ressource de calcul. Elle peut cependant être optimisée en modifiant l'ordre des tentatives incrémentales. Par exemple en adaptant l'ordre d'arrivée des lettres suivant les analyses fréquentielles par bigramme ou par trigramme pour la langue concernée. Elle n'en reste pas moins la plus efficace pour garantir la découverte d'un mot de passe même complexe.

Hashcat permet de générer des masques à utiliser sur une attaque incrémentale. Il est ainsi possible de limiter la plage de mot de passe qui sera générée lors de l'incrémentation par le logiciel. Ces masques servent à définir un modèle de mot de passe.

Dans l'exemple suivant, l'attaque incrémentale débute sur un AAAAAA et se terminera sur ZZZZZZZZZZZZ en essayant chaque possibilité.

hashcat64.exe -m 0 -a 3 -O --session md5_crack -o MD5_Resolved.txt --remove MD5_Hash_Passwords.hash -i --increment-min 6 --increment-max 12
L'attaque par dictionnaire avec Hashcat

La méthode par dictionnaire vise à essayer l'ensemble des mots présents dans un ou plusieurs fichiers en considérant chaque ligne comme un nouveau mot de passe.

hashcat64.exe -m 0 -a 0 -O -o MD5_Resolved.txt --remove MD5_Hash_Passwords.hash dico_optimize.txt
L'attaque par dictionnaire et règles avec Hashcat

Les attaques par dictionnaires et règles sont les plus complexes et les plus puissantes des possibilités offertes par Hashcat. Les règles se rédigent à la manière d'instructions d'un langage de développement. Il devient possible de modifier, couper ou concaténer des mots. De faire usage des opérateurs conditionnels pour valider ou invalider un mot de passe avant même d'essayer de générer son empreinte. L'attaque devient donc terriblement flexible, précise et efficace.

 

Il est possible d'utiliser un seul fichier de règle (comme dans l'exemple suivant) mais il est également possible d'utiliser plusieurs fichiers de règles différents comme dans le deuxième exemple :

hashcat64.exe -m 0 -a 0 -O -o MD5_Resolved.txt --remove MD5_Hash_Passwords.hash dico_optimize.txt -r rules/best64.rule 
hashcat64.exe -m 0 -a 0 -O --session md5_crack_master -o MD5_Resolved.txt --remove MD5_Hash_Passwords.hash dico_optimize.txt -r rules/best64.rule -r rules/custom.rule 
L'attaque combinatoire avec Hashcat

L'attaque combinatoire permet d'utiliser l'ensemble des mots d'un dictionnaire et d'en décliner une nouvelle liste, dans laquelle chaque mot a été concaténé avec chaque autre mot présent dans la liste.

hashcat64.exe -m 0 -a 1 -O -o MD5_Resolved.txt --remove MD5_Hash_Passwords.hash dico_optimize_1.txt dico_transpo.txt
L'attaque hybride avec Hashcat

L'attaque hybride permet d'utiliser un dictionnaire et un masque. Il est possible de définir un masque avant le mot qui provient du dictionnaire ou un mot après. Cette attaque est terriblement efficace sur des modèles standardisés de mot de passe.

Ici exemple d'une attaque hybride avec placement des masques à gauche du mot de passe à essayer.

hashcat64.exe -m 0 -a 7 -O -o MD5_Resolved.txt --remove MD5_Hash_Passwords.hash ?d?d dico_optimize.txt

Ici exemple d'une attaque hybride avec placement des masques à droite du mot de passe à essayer.

hashcat64.exe -m 0 -a 6 -O  -o MD5_Resolved.txt --remove MD5_Hash_Passwords.hash dico_optimize.txt ?d?d
Observations sur la structuration des mots de passe et entropie.

D'une manière générale, plus une personne ou un groupe dispose de mots de passe générés par un cerveau humain, plus il peut concevoir des règles performantes pour trouver un maximum de mot de passe par collision en un minimum de temps. J'ai souvent constaté lors d'audit de sécurité des mots de passe répondant aux critères de sécurisation des entreprises, mais ne répondant pas au principe d'entropie. Ainsi la (trop) grande majorité des mots de passe répondent aux modèles :

  • nom avec la première lettre en majuscule + 2 chiffres + 1 caractère spécial
  • 2 chiffres + nom avec la première lettre en majuscule + 1 caractère spécial

Il est impératif de prendre conscience de l'importance de l'entropie dans le processus de sécurisation, ainsi que de la multiplication des facteurs permettant de s'authentifier sur un système.