L’article 323-1 du code pénal sanctionne le piratage frauduleux d’au moins deux ans d’emprisonnement et de 60 000 euros d’amende.
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 :
- Fonctionnement d'une attaque par collision.
- Quand utiliser Hashcat.
- Les paramètres de Hashcat.
- Les masques de Hashcat.
- Les règles de Hashcat.
- Les attaques par brute force avec Hashcat.
- Les attaques par dictionnaire avec Hashcat.
- Les attaques par règles avec Hashcat.
- Les attaques combinatoires avec Hashcat.
- Les attaques hybrides 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 :
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
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)
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
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 12L'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.txtL'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.txtL'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.txtIci 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?dObservations 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.