Introduction
Dans ce laboratoire, vous allez explorer une technique spécifique de cassage de mot de passe connue sous le nom d'attaque par combinator, en utilisant Hashcat, un outil de récupération de mot de passe puissant et polyvalent. Une attaque par combinator est une méthode où deux listes de mots distinctes sont combinées pour générer des candidats de mot de passe. Par exemple, si une liste contient "password" et l'autre "123", l'attaque testera la combinaison "password123".
Cette approche est particulièrement efficace contre les mots de passe formés par la concaténation de deux mots, ou d'un mot et d'une séquence de chiffres ou de symboles. Tout au long de ce laboratoire, vous apprendrez à préparer des listes de mots, à construire la commande Hashcat appropriée, à exécuter l'attaque contre un hash d'échantillon et à vérifier les résultats.
Comprendre le concept d'attaque par combinator
Dans cette étape, vous allez découvrir le concept fondamental de l'attaque par combinator dans Hashcat. Cette attaque est désignée par le mode d'attaque -a 1. Elle fonctionne en prenant un mot de base de la première liste de mots et en y ajoutant un mot de la seconde liste de mots, créant ainsi un nouveau mot de passe candidat. Ce processus est répété pour chaque mot des deux listes.
Par exemple, si vous avez deux listes :
wordlist1.txt:admin,userwordlist2.txt:123,!
L'attaque par combinator générerait les candidats suivants : admin123, admin!, user123, user!.
Cette méthode élargit considérablement l'espace potentiel des mots de passe sans nécessiter un seul fichier dictionnaire massif. Commençons par confirmer le mode d'attaque dans le menu d'aide de Hashcat.
Exécutez la commande suivante pour filtrer la sortie d'aide et obtenir des informations sur l'attaque par combinator :
hashcat --help | grep "Combinator"
Vous devriez voir une ligne dans la sortie qui mentionne explicitement le mode d'attaque Combinator et son numéro correspondant.
-a, --attack-mode | ## | Attack-mode
...
| 1 | Combinator
...
Cela confirme que -a 1 est le drapeau (flag) correct à utiliser pour une attaque par combinator.
Créer deux listes de mots distinctes pour l'attaque
Dans cette étape, vous allez créer les deux listes de mots qui seront utilisées dans notre attaque par combinator. Pour ce laboratoire, nous allons créer deux petites listes de mots personnalisées. Dans un scénario réel, ces listes seraient beaucoup plus grandes et contiendraient des mots, des noms et des motifs plus courants.
Notre mot de passe cible est une combinaison d'un mot courant et d'une séquence de nombres. Nous placerons la partie mot dans wordlist1.txt et la partie nombre dans wordlist2.txt.
Tout d'abord, créez wordlist1.txt avec quelques mots de base potentiels. Utilisez la commande echo avec le drapeau -e pour gérer les sauts de ligne (\n) :
echo -e "admin\nuser\npassword\nguest" > wordlist1.txt
Ensuite, créez wordlist2.txt avec quelques suffixes numériques courants :
echo -e "2024\n!@#\n123\nxyz" > wordlist2.txt
Maintenant, vérifiez le contenu des deux fichiers en utilisant la commande cat pour vous assurer qu'ils ont été créés correctement.
Vérifiez la première liste de mots :
cat wordlist1.txt
Sortie attendue :
admin
user
password
guest
Vérifiez la seconde liste de mots :
cat wordlist2.txt
Sortie attendue :
2024
!@#
123
xyz
Avec ces deux listes de mots, Hashcat sera désormais capable de former le mot de passe candidat password123.
Construire la commande d'attaque par combinator avec deux listes de mots
Dans cette étape, vous allez construire la commande Hashcat complète pour l'attaque par combinator. Il est important de comprendre ce que fait chaque partie de la commande avant de l'exécuter.
La syntaxe générale pour une attaque par combinator est : hashcat [options] <fichier-hash> <liste-mots1> <liste-mots2>
Voici la décomposition de la commande que nous allons utiliser :
hashcat: Le programme exécutable.-m 0: Ceci spécifie le type de hash. Le mode0correspond à MD5.-a 1: Ceci définit le mode d'attaque à1, qui est l'attaque par Combinator.hash.txt: C'est le fichier contenant le hash que nous voulons casser. Il a été créé pour vous lors de la configuration du laboratoire.wordlist1.txt: La première liste de mots, contenant la partie gauche des candidats mots de passe.wordlist2.txt: La seconde liste de mots, contenant la partie droite des candidats mots de passe.
Avant d'exécuter l'attaque complète, il est de bonne pratique d'utiliser le drapeau --show. Ce drapeau indique à Hashcat d'afficher les hashes qui ont déjà été cassés et stockés dans le potfile, sans démarrer une nouvelle session de cassage.
Exécutons la commande avec --show pour voir que notre hash cible n'a pas encore été cassé :
hashcat -m 0 -a 1 hash.txt wordlist1.txt wordlist2.txt --show
Comme c'est la première fois que nous l'exécutons, la commande ne produira aucune sortie, ce qui est le résultat attendu. Cela confirme que nous sommes prêts à passer à l'attaque réelle.
Exécuter l'attaque et observer les combinaisons
Il est maintenant temps d'exécuter l'attaque par combinator sans le drapeau --show. Cela lancera le processus de cassage. Hashcat lira les deux listes de mots, les combinera, hachera les résultats et les comparera au hash cible dans hash.txt.
Exécutez la commande suivante dans votre terminal :
hashcat -m 0 -a 1 hash.txt wordlist1.txt wordlist2.txt
Hashcat s'initialisera et affichera un écran de statut. Comme nos listes de mots sont très petites, le processus se terminera presque instantanément. La sortie indiquera que le hash a été cassé.
Vous verrez une sortie similaire à la suivante (certains détails comme la vitesse et le temps peuvent varier) :
hashcat (v6.2.6) starting
...
Session..........: hashcat
Status...........: Cracked
Hash.Name........: MD5
Hash.Target......: e10adc3949ba59abbe56e057f20f883e
Time.Started.....: ...
Time.Estimated...: 0 secs (0.00ms)
Guess.Base.......: File (wordlist1.txt), File (wordlist2.txt)
Guess.Queue......: 2/2 (100.00%)
Speed.#*.........: ... H/s (...)
Recovered........: 1/1 (100.00%) Digests
Progress.........: 16/16 (100.00%)
Rejected.........: 0/16 (0.00%)
Restore.Point....: 4/4 (100.00%)
Restore.Sub.#*...: 4/4 (100.00%)
Candidates.#*....: 16
Cracked Hashes: 1/1
e10adc3949ba59abbe56e057f20f883e:password123
...
All hashes have been recovered
Started: ...
Stopped: ...
La ligne e10adc3949ba59abbe56e057f20f883e:password123 montre clairement le hash original et son mot de passe en clair cassé. Cela confirme que notre attaque a réussi.
Examiner le potfile pour les résultats de mots de passe combinés
Dans cette étape, vous allez examiner le potfile de Hashcat. Le potfile (hashcat.potfile) est un fichier texte brut où Hashcat stocke automatiquement les hashes cassés avec succès et leurs mots de passe correspondants. C'est une fonctionnalité utile qui vous évite de perdre du temps à recasser des hashes qui ont déjà été résolus.
Par défaut, le potfile est situé dans le répertoire ~/.local/share/hashcat/.
Utilisez la commande cat pour afficher le contenu du potfile et confirmer que notre résultat a été sauvegardé :
cat ~/.local/share/hashcat/hashcat.potfile
La sortie affichera le hash et son mot de passe cassé, séparés par un deux-points :
e10adc3949ba59abbe56e057f20f883e:password123
Cela confirme que l'attaque a été réussie et que le résultat est maintenant stocké de manière permanente dans le potfile. Si vous deviez exécuter la même attaque à nouveau, Hashcat utiliserait le drapeau --show pour récupérer instantanément le résultat de ce fichier au lieu de relancer l'intégralité du processus de cassage.
Résumé
Dans ce laboratoire, vous avez réussi à effectuer une attaque par combinator à l'aide de Hashcat.
Vous avez appris à :
- Comprendre le concept d'une attaque par combinator (
-a 1) dans Hashcat. - Créer deux listes de mots distinctes pour servir de base aux candidats mots de passe.
- Construire la commande Hashcat correcte, en spécifiant le mode d'attaque, le type de hash et les fichiers d'entrée.
- Exécuter l'attaque et casser avec succès un hash MD5 en combinant un mot et une séquence de nombres.
- Localiser et examiner le
hashcat.potfilepour voir les résultats stockés d'un cassage réussi.
L'attaque par combinator est une technique fondamentale dans le cassage de mots de passe, particulièrement utile lorsqu'il s'agit de mots de passe qui suivent des modèles de concaténation prévisibles.
