Hashcat : Force Brute avec Attaques par Masque

Introduction

Hashcat est un outil de récupération de mots de passe de renommée mondiale, capable de casser une grande variété de hachages à des vitesses incroyables. Bien que les attaques par dictionnaire soient courantes, elles ne sont efficaces que si le mot de passe existe dans une liste de mots donnée. Une attaque par force brute pure, qui essaie toutes les combinaisons de caractères possibles, est souvent trop lente pour être pratique.

C'est là qu'intervient l'attaque par masque (mask attack). Une attaque par masque est une forme très efficace d'attaque par force brute utilisée lorsque vous avez une certaine connaissance de la structure du mot de passe. Par exemple, vous pourriez connaître la longueur du mot de passe, ou savoir qu'il commence par une majuscule et se termine par un chiffre.

Dans ce laboratoire, vous apprendrez les bases de l'exécution d'une attaque par masque avec Hashcat. Vous commencerez par comprendre le concept, apprendrez à utiliser des ensembles de caractères pour construire des masques, et appliquerez ces connaissances pour casser des hachages de mots de passe avec des motifs connus.

Comprendre le concept d'une attaque par masque (-a 3)

Dans cette étape, vous apprendrez le concept de base de l'attaque par masque dans Hashcat. Le mode d'attaque par masque est spécifié à l'aide de l'option -a 3. Ce mode indique à Hashcat de générer des candidats de mots de passe basés sur un modèle, ou "masque", que vous définissez.

Ceci est différent d'une attaque par dictionnaire (-a 0), qui utilise une liste de mots préétablie. Une attaque par masque crée ses propres candidats à la volée.

Voyons comment un masque génère des candidats. Nous pouvons utiliser l'option --stdout pour afficher les mots de passe générés à l'écran au lieu d'essayer de casser un hachage. Nous utiliserons ?d comme simple espace réservé pour un chiffre (0-9).

Exécutez la commande suivante pour générer tous les nombres possibles à 3 chiffres :

hashcat -a 3 ?d?d?d --stdout

Hashcat générera toutes les combinaisons possibles de 3 chiffres. Notez que l'ordre de sortie peut paraître aléatoire en raison des algorithmes d'optimisation de Hashcat, mais il générera toutes les combinaisons de 000 à 999.

...
476
576
876
976
...

Ceci démontre l'idée centrale : le masque ?d?d?d agit comme un modèle, et Hashcat le remplit systématiquement avec toutes les combinaisons possibles à partir de l'ensemble de caractères spécifié.

Apprendre les ensembles de caractères intégrés (?l, ?u, ?d, ?s)

Dans cette étape, vous allez découvrir les blocs de construction fondamentaux des masques : les jeux de caractères intégrés (built-in character sets). Ce sont des espaces réservés qui représentent un groupe spécifique de caractères.

Hashcat fournit plusieurs jeux de caractères intégrés pratiques :

Vous pouvez combiner ces espaces réservés pour créer des masques complexes. La longueur du masque détermine directement la longueur des candidats de mot de passe générés.

Essayons de générer des candidats pour un mot de passe composé d'une lettre majuscule suivie d'un chiffre. Le masque pour cela serait ?u?d.

Utilisez à nouveau l'option --stdout pour visualiser la sortie :

hashcat -a 3 ?u?d --stdout

Hashcat générera toutes les combinaisons d'une lettre majuscule suivie d'un chiffre. Notez que l'ordre de sortie peut paraître aléatoire en raison des algorithmes d'optimisation de Hashcat, mais il générera toutes les combinaisons de A0 à Z9.

...
B4
C7
D2
...

En combinant ces jeux de caractères, vous pouvez définir un modèle précis pour les mots de passe que vous souhaitez tester.

Lancer une attaque par masque pour un code PIN à 3 chiffres (hash NTLM)

Dans cette étape, vous appliquerez vos connaissances à un scénario réel : casser un code PIN à 3 chiffres. Nous avons un fichier nommé pin_hash.txt qui contient un hachage de mot de passe au format NTLM. Nous suspectons que le mot de passe original est un nombre à 3 chiffres.

Tout d'abord, visualisons le contenu du fichier de hachage :

cat pin_hash.txt

Vous verrez le hachage NTLM :

D2063C28444B9B742B9B89C282395EBF

Pour casser ce hachage, nous devons indiquer trois choses à Hashcat :

1. Le mode d'attaque est l'attaque par masque (-a 3).
2. Le type de hachage est NTLM (-m 1000).
3. Le masque pour un code PIN à 3 chiffres est ?d?d?d.

Maintenant, combinez ces éléments dans une seule commande pour démarrer l'attaque :

hashcat -a 3 -m 1000 pin_hash.txt ?d?d?d

Hashcat démarrera, et comme l'espace de clés (000-999) est très petit, il trouvera le mot de passe presque instantanément.

...
D2063C28444B9B742B9B89C282395EBF:137
...
Status...........: Cracked
...

Hashcat a récupéré avec succès le mot de passe : 137. Une fois qu'un mot de passe est cassé, Hashcat l'enregistre dans un fichier appelé "potfile". Vous pouvez visualiser tous les mots de passe cassés pour ce type de hachage avec l'option --show :

hashcat -m 1000 pin_hash.txt --show

Sortie :

D2063C28444B9B742B9B89C282395EBF:137

Créer un masque personnalisé pour un modèle de mot de passe connu

Dans cette étape, vous allez vous attaquer à un mot de passe plus complexe. Imaginez qu'une entreprise ait une politique de mot de passe : "Les mots de passe doivent être composés exactement de 5 lettres minuscules." Un exemple de mot de passe serait labex.

Nous avons le hachage NTLM pour un tel mot de passe dans le fichier pattern_hash.txt.

Tout d'abord, traduisons la politique de mot de passe en un masque Hashcat :

• Les 5 caractères doivent tous être des lettres minuscules : ?l?l?l?l?l

Ceci nous donne le masque final : ?l?l?l?l?l.

Maintenant, utilisons ce masque pour casser le hachage dans pattern_hash.txt. La commande est similaire à l'étape précédente, mais avec notre nouveau masque.

hashcat -a 3 -m 1000 pattern_hash.txt ?l?l?l?l?l

Hashcat commencera à tester toutes les combinaisons qui correspondent à ce modèle spécifique. C'est beaucoup plus efficace qu'une attaque par force brute pure essayant toutes les combinaisons de 5 caractères. Après un court instant, il trouvera le mot de passe.

...
2BF7D33EC706798E0308F5DF34BC7D2F:labex
...
Status...........: Cracked
...

Vous avez réussi à casser un mot de passe avec un modèle spécifique en créant un masque personnalisé qui correspond précisément à la politique requise de 5 lettres minuscules.

Comparer les performances des attaques par masque par rapport aux attaques par dictionnaire

Dans cette dernière étape, nous allons comparer l'attaque par masque que vous venez d'effectuer avec une attaque par dictionnaire traditionnelle afin de comprendre leurs forces respectives.

Une attaque par dictionnaire (-a 0) est très rapide si le mot de passe se trouve dans la liste de mots (wordlist). Nous disposons d'un petit fichier de dictionnaire nommé dict.txt qui contient le mot de passe de l'étape précédente.

Exécutons une attaque par dictionnaire contre pattern_hash.txt :

hashcat -a 0 -m 1000 pattern_hash.txt dict.txt

Comme labex se trouve dans dict.txt, Hashcat le trouve presque instantanément.

hashcat (v6.2.5) starting

OpenCL API (OpenCL 2.0 pocl 1.8  Linux, None+Asserts, RELOC, LLVM 11.1.0, SLEEF, DISTRO, POCL_DEBUG) - Platform #1 [The pocl project]
=====================================================================================================================================
* Device #1: pthread-Intel(R) Xeon(R) Platinum 8575C, 6808/13680 MB (2048 MB allocatable), 4MCU

Minimum password length supported by kernel: 0
Maximum password length supported by kernel: 256

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

Started: Sat Oct 11 16:05:20 2025
Stopped: Sat Oct 11 16:05:20 2025

Hashcat nous informe que le hachage a déjà été trouvé et stocké dans le fichier potfile. Pour voir le mot de passe déchiffré, nous pouvons utiliser l'option --show :

hashcat -a 0 -m 1000 pattern_hash.txt dict.txt --show

Sortie :

2bf7d33ec706798e0308f5df34bc7d2f:labex

Alors, quand une attaque par masque a-t-elle l'avantage ? Une attaque par dictionnaire ne réussira que si le mot de passe exact existe dans la liste de mots. Si le mot de passe avait été testx au lieu de cela, et que cela n'était pas dans notre dictionnaire, l'attaque aurait échoué.

Cependant, l'attaque par masque de l'Étape 4 (?l?l?l?l?l) réussirait toujours car elle génère et teste systématiquement tous les mots de passe qui correspondent au modèle, qu'ils soient dans un dictionnaire ou non. Elle testerait labex, testx, hello, et ainsi de suite.

Conclusion :

• Attaque par dictionnaire (-a 0) : Idéale pour déchiffrer des mots de passe courants ou lorsque vous disposez d'une liste de mots ciblée et de haute qualité. Elle est rapide mais limitée par le contenu du dictionnaire.
• Attaque par masque (-a 3) : Idéale lorsque vous connaissez la structure ou le modèle du mot de passe (par exemple, à partir d'une politique de mot de passe connue). Elle est bien plus complète qu'une attaque par dictionnaire et infiniment plus efficace qu'une attaque par force brute pure.

Résumé

Dans ce laboratoire, vous avez acquis une expérience pratique avec l'une des fonctionnalités les plus puissantes de Hashcat : l'attaque par masque.

Vous avez appris :

• Le concept fondamental de l'attaque par masque (-a 3) et comment elle génère des candidats de mot de passe basés sur un modèle (pattern).
• Comment utiliser les ensembles de caractères intégrés de Hashcat (?l, ?u, ?d, ?s) pour construire des masques.
• Comment appliquer un masque simple pour casser un code PIN à 3 chiffres.
• Comment créer un masque personnalisé basé sur une politique de mot de passe connue (5 lettres minuscules) pour casser un mot de passe avec un modèle spécifique.
• Les différences clés et les avantages stratégiques de l'utilisation d'une attaque par masque par rapport à une attaque par dictionnaire standard.

Les attaques par masque sont une compétence essentielle pour tout professionnel de la sécurité, offrant un équilibre parfait entre la vitesse d'une attaque par dictionnaire et l'exhaustivité d'une attaque par force brute pure.