Introduction
Bienvenue dans ce laboratoire sur la réalisation d'une attaque par masque avec Hashcat. Hashcat est un outil de récupération de mots de passe puissant et polyvalent, largement utilisé en cybersécurité pour tester la robustesse des mots de passe et récupérer des mots de passe perdus.
Une attaque par force brute standard tente de deviner un mot de passe en essayant toutes les combinaisons possibles de caractères, ce qui peut être incroyablement lent. Une attaque par masque est un type d'attaque par force brute plus intelligent et plus efficace. Elle est utilisée lorsque vous disposez d'informations sur la structure du mot de passe, telles que sa longueur ou les types de caractères utilisés dans des positions spécifiques (par exemple, "commence par une lettre majuscule, se termine par deux chiffres").
Dans ce laboratoire, vous apprendrez à définir la structure d'un mot de passe à l'aide d'un masque et à utiliser Hashcat pour casser un hachage SHA1 d'exemple, démontrant ainsi la puissance et l'efficacité de cette approche ciblée.
Comprendre le Concept d'une Attaque par Masque
Dans cette étape, vous allez apprendre le concept fondamental d'une attaque par masque. Comme mentionné dans l'introduction, cette attaque est une forme spécialisée d'attaque par force brute.
Imaginez que vous devez casser un mot de passe, mais vous avez quelques indices :
- Vous savez que le mot de passe a exactement 6 caractères.
- Vous savez que le premier caractère est une lettre majuscule.
- Vous savez que les deux derniers caractères sont des chiffres.
Une attaque par force brute standard perdrait du temps à essayer des combinaisons comme "aaaaaa" ou "123456". Une attaque par masque, en revanche, vous permet de définir un "masque" ou un modèle qui indique à l'outil de cassage de n'essayer que les combinaisons qui correspondent à votre modèle connu. Pour l'exemple ci-dessus, le masque spécifierait [Lettre Majuscule][N'importe quoi][N'importe quoi][N'importe quoi][Chiffre][Chiffre].
Cela réduit considérablement le nombre de possibilités, rendant le processus de cassage nettement plus rapide et plus efficace. Dans l'étape suivante, vous apprendrez la syntaxe spécifique qu'Hashcat utilise pour créer ces masques puissants. Cette étape est purement conceptuelle, et aucune commande n'est nécessaire.
Apprendre les Jeux de Caractères Intégrés comme ?l ?u ?d ?s
Dans cette étape, vous allez découvrir les jeux de caractères intégrés d'Hashcat, qui sont les éléments constitutifs d'un masque.
Hashcat utilise des espaces réservés spéciaux, appelés "charsets" (jeux de caractères), pour définir le type de caractère à chaque position dans un masque de mot de passe. Voici les jeux de caractères intégrés les plus courants :
?l: Représente toutes les lettres minuscules (aàz).?u: Représente toutes les lettres majuscules (AàZ).?d: Représente tous les chiffres (0à9).?s: Représente tous les caractères spéciaux standard (par exemple,!@#$%^&*).?a: Représente tous les caractères ci-dessus (?l?u?d?s).
Par exemple, si nous savons qu'un mot de passe a 4 caractères et qu'il est composé d'une lettre majuscule, suivie de deux lettres minuscules, puis d'un chiffre, le masque serait ?u?l?l?d. Cela générerait des candidats tels que Pass9, Word1, Test0, etc.
Vous pouvez voir ces définitions dans le menu d'aide d'Hashcat. Exécutez la commande suivante dans votre terminal pour afficher les informations d'aide relatives aux masques :
hashcat --help | grep "?l"
Vous verrez une section qui liste les jeux de caractères intégrés, ce qui confirme les informations ci-dessus.
?l | abcdefghijklmnopqrstuvwxyz | Lowercase letters
Créer un Hash SHA1 d'Exemple pour un Modèle Connu
Dans cette étape, vous allez créer un hash SHA1 cible pour un mot de passe que nous allons casser dans les étapes à venir. Pour effectuer une attaque de mot de passe, nous avons d'abord besoin d'un hash à attaquer.
Choisissons un mot de passe qui correspond à un modèle clair : LabX99!. Ce mot de passe a la structure suivante :
- 1er caractère : Lettre majuscule (
L) - 2ème caractère : Lettre minuscule (
a) - 3ème caractère : Lettre minuscule (
b) - 4ème caractère : Lettre majuscule (
X) - 5ème caractère : Chiffre (
9) - 6ème caractère : Chiffre (
9) - 7ème caractère : Caractère spécial (
!)
Tout d'abord, générons le hash SHA1 pour ce mot de passe. L'option -n dans la commande echo est très importante, car elle empêche l'ajout d'un caractère de nouvelle ligne à la chaîne, ce qui modifierait le hash résultant.
Exécutez cette commande dans votre terminal :
echo -n "LabX99!" | sha1sum
La sortie sera le hash SHA1 suivi d'un tiret :
0e6cc6531a1a5545942a38a9339571934219c5b0 -
Maintenant, enregistrez ce hash dans un fichier nommé target_hash.txt. Ce fichier sera l'entrée pour Hashcat.
echo "0e6cc6531a1a5545942a38a9339571934219c5b0" > target_hash.txt
Vous pouvez vérifier que le fichier a été créé correctement avec cat target_hash.txt.
Construire une Commande d'Attaque par Masque pour un Mot de Passe de Longueur Fixe
Dans cette étape, vous allez construire la commande Hashcat complète pour effectuer l'attaque par masque en fonction des informations dont nous disposons.
Une commande Hashcat pour une attaque par masque comporte plusieurs composants clés :
-m <mode>: Cette option spécifie le type de hash. Chaque algorithme de hash (comme MD5, SHA1, bcrypt) a un numéro de mode unique.-a <attack_mode>: Cette option définit le mode d'attaque. Pour une attaque par masque, le mode est toujours3.hash_file: Le chemin vers le fichier contenant le(s) hash(es) à casser.mask: Le modèle de masque définissant la structure du mot de passe.
Tout d'abord, nous devons trouver le mode correct pour SHA1. Vous pouvez le trouver en consultant la sortie d'aide de Hashcat :
hashcat --help | grep "SHA1"
Vous verrez une liste de types de hash. Le mode pour un hash SHA1 standard est 100.
100 | SHA1 | Raw Hash
Ensuite, créons le masque pour notre mot de passe, LabX99!. En fonction de la structure que nous avons identifiée et des jeux de caractères que nous avons appris :
L->?uab->?l?lX->?u99->?d?d!->?s
En combinant ceux-ci, notre masque final est ?u?l?l?u?d?d?s.
Nous pouvons maintenant assembler la commande complète. Nous ajouterons également l'option --force, qui indique à Hashcat de s'exécuter même s'il détecte un environnement non optimal (comme une exécution sur CPU dans une VM), ce qui est nécessaire pour ce laboratoire.
La structure de commande finale est : hashcat -m 100 -a 3 target_hash.txt ?u?l?l?u?d?d?s --force. Nous exécuterons cela dans la prochaine étape.
Exécuter l'Attaque par Masque et Vérifier le Résultat
Dans cette étape, vous allez exécuter la commande d'attaque par masque et vérifier que Hashcat a réussi à casser le mot de passe.
Vous avez déjà construit la commande. Maintenant, exécutez-la dans votre terminal pour lancer l'attaque :
hashcat -m 100 -a 3 target_hash.txt ?u?l?l?u?d?d?s --force
Hashcat va démarrer. Il peut afficher quelques avertissements, qui peuvent être ignorés sans risque car nous avons utilisé --force. L'attaque va commencer, et comme notre masque est très spécifique, elle devrait se terminer presque instantanément. La sortie affichera l'état de la session, et vous devriez voir l'état final comme Cracked (Cassé).
...
Session..........: hashcat
Status...........: Cracked
Hash.Name........: SHA1
Hash.Target......: 0e6cc6531a1a5545942a38a9339571934219c5b0
Time.Started.....: ...
Time.Estimated...: 0 secs (0.00ms)
Guess.Mask.......: ?u?l?l?u?d?d?s [7]
Guess.Queue......: 1/1 (100.00%)
Speed.#1.........: 192.9 kH/s (0.01ms) @ Accel:128 Loops:1 Thr:1 Vec:8
Recovered........: 1/1 (100.00%) Digests
Progress.........: 11881376/11881376 (100.00%)
Rejected.........: 0/11881376 (0.00%)
Restore.Point....: 456976/456976 (100.00%)
Restore.Sub.#1...: Salt:0 Amplifier:0-1
Candidates.#1....: LuvX98! -> LuvX99#
Hardware.Mon.#1..: Temp: 46c
...
Une fois qu'un mot de passe est cassé, Hashcat l'enregistre dans un fichier appelé "potfile" (hashcat.potfile). Pour afficher le mot de passe cassé, vous pouvez utiliser l'option --show avec les arguments de la commande d'origine.
Exécutez cette commande pour afficher le résultat :
hashcat -m 100 target_hash.txt --show
La sortie affichera le hash et le mot de passe en clair cassé, séparés par un deux-points :
0e6cc6531a1a5545942a38a9339571934219c5b0:LabX99!
Félicitations, vous avez réussi à exécuter une attaque par masque !
Résumé
Dans ce laboratoire, vous avez réussi à effectuer une attaque par masque par force brute à l'aide de Hashcat.
Vous avez appris à :
- Comprendre le concept fondamental d'une attaque par masque comme méthode de force brute ciblée.
- Utiliser les jeux de caractères intégrés de Hashcat (
?l,?u,?d,?s) pour définir la structure d'un mot de passe. - Générer un hash SHA1 pour un mot de passe cible.
- Construire une commande Hashcat complète avec le bon mode de hash, le bon mode d'attaque et le bon masque.
- Exécuter l'attaque et afficher le mot de passe cassé en utilisant l'option
--show.
Les attaques par masque sont une technique fondamentale dans le cassage de mots de passe et l'audit de sécurité. Elles démontrent comment même une petite quantité d'informations sur le modèle d'un mot de passe peut réduire considérablement le temps et l'effort nécessaires pour le casser.
