Introduction
Dans ce laboratoire, vous apprendrez les fondamentaux du cassage de mots de passe avec Kali Linux, en vous concentrant sur l'outil puissant John the Ripper. L'objectif principal est de comprendre comment casser les hashs de mots de passe Linux, qui sont des représentations chiffrées des mots de passe généralement stockées dans le fichier /etc/shadow. Cette compétence est essentielle lors des tests d'intrusion pour identifier les mots de passe faibles et améliorer la sécurité des systèmes.
Lorsque vous ouvrez le terminal, vous serez automatiquement placé dans un shell de conteneur Kali Linux. Toutes les commandes de ce laboratoire doivent être exécutées dans cet environnement. Grâce à des instructions guidées étape par étape, vous travaillerez avec des fichiers de hashs exemples, créerez et utiliserez des listes de mots personnalisées, comparerez des outils de cassage comme John the Ripper et Hashcat, et enregistrerez vos résultats pour analyse. Ce laboratoire est conçu pour les débutants et offre une expérience d'apprentissage pratique et claire dans un environnement contrôlé.
Configuration de l'environnement et installation des outils
Dans cette première étape, nous allons préparer l'environnement Kali Linux en installant les outils nécessaires au cassage de mots de passe. Comme mentionné, votre session de terminal s'exécute déjà à l'intérieur d'un conteneur Kali Linux.
Nous utiliserons deux outils principaux : John the Ripper, un outil de cassage de mots de passe polyvalent et largement utilisé, et Hashcat, un autre outil puissant reconnu pour sa rapidité et sa flexibilité.
Tout d'abord, mettez à jour la liste des paquets pour vous assurer d'avoir accès aux dernières versions des logiciels.
apt update
Ensuite, installez John the Ripper et Hashcat à l'aide de la commande suivante. L'option -y confirme automatiquement l'installation.
apt install -y john hashcat
Le processus d'installation peut prendre quelques minutes. Une fois terminé, vous pouvez vérifier que John the Ripper est correctement installé en l'exécutant sans aucune option.
john
Vous devriez voir les informations d'aide et de version, ce qui confirme que l'outil est prêt. La sortie ressemblera à ceci :
John the Ripper 1.9.0-jumbo-1+bleeding-aec1328d6c 2021-11-02 10:45:52 +0100 OMP [linux-gnu 64-bit x86_64 AVX512BW AC]
Copyright (c) 1996-2021 by Solar Designer and others
Homepage: https://www.openwall.com/john/
Usage: john [OPTIONS] [PASSWORD-FILES]
...
Ensuite, vérifiez l'installation de Hashcat en consultant sa version.
hashcat --version
La sortie attendue affichera le numéro de version, par exemple :
v6.2.5
Avec les deux outils installés et vérifiés, votre environnement est maintenant prêt pour les exercices de cassage de mots de passe des étapes suivantes.
Création d'un fichier de hashs exemple
Maintenant que les outils sont installés, nous avons besoin de données sur lesquelles travailler. Dans cette étape, vous allez créer un fichier contenant de vrais hashs de mots de passe Linux que John the Ripper peut traiter. Ces hashs sont formatés pour imiter ceux trouvés dans le fichier /etc/shadow, qui stocke en toute sécurité les informations de mot de passe des utilisateurs sur les systèmes Linux. Cela vous permet de vous entraîner au cassage de manière sûre et contrôlée.
Toutes les opérations seront effectuées dans le répertoire /root du conteneur Kali. Nous allons créer le fichier de hashs directement avec des hashs réels pré-générés pour des mots de passe simples et courants qui peuvent être cassés rapidement.
Créez le fichier de hashs exemple directement avec la commande suivante :
cd /root
echo -e "user1:\$6\$randomsalt\$WS2qjCQ1JrmZv8otdbtntIYu6lRzkk2aIVhgIMdMexOcvD9bEAoxtKcyZLXbR3wlhOOPBscJbLCPUU/fYjFhM0:18234:0:99999:7:::\nuser2:\$6\$anothersalt\$ZffCt8y5Hl8gLYS79/rhyT76C12kNhuOvkFR8Ll0RXcjQz2Nzuh3VUdT//e21HYfH6fP9btOp2aG22O3S7q1z/:18234:0:99999:7:::" > sample_hashes.txt
Alternativement, vous pouvez créer le fichier manuellement en copiant et collant le contenu :
cd /root
cat > sample_hashes.txt << 'EOF'
user1:$6$randomsalt$WS2qjCQ1JrmZv8otdbtntIYu6lRzkk2aIVhgIMdMexOcvD9bEAoxtKcyZLXbR3wlhOOPBscJbLCPUU/fYjFhM0:18234:0:99999:7:::
user2:$6$anothersalt$ZffCt8y5Hl8gLYS79/rhyT76C12kNhuOvkFR8Ll0RXcjQz2Nzuh3VUdT//e21HYfH6fP9btOp2aG22O3S7q1z/:18234:0:99999:7:::
EOF
Le préfixe $6$ sur chaque ligne indique que le hash est un hash SHA-512 crypt, un standard courant pour les systèmes Linux modernes. Le format suit la structure du fichier shadow : username:hashed_password:last_change:min_age:max_age:warning:inactive:expire:reserved.
Pour confirmer que le fichier a été créé correctement, affichez son contenu à l'aide de la commande cat :
cat /root/sample_hashes.txt
La sortie devrait montrer les deux entrées utilisateur avec des valeurs de hash réelles :
user1:$6$randomsalt$WS2qjCQ1JrmZv8otdbtntIYu6lRzkk2aIVhgIMdMexOcvD9bEAoxtKcyZLXbR3wlhOOPBscJbLCPUU/fYjFhM0:18234:0:99999:7:::
user2:$6$anothersalt$ZffCt8y5Hl8gLYS79/rhyT76C12kNhuOvkFR8Ll0RXcjQz2Nzuh3VUdT//e21HYfH6fP9btOp2aG22O3S7q1z/:18234:0:99999:7:::
Notes importantes :
- Ce sont de vrais hashs SHA-512 correctement formatés que John the Ripper peut traiter.
- Les mots de passe sont
passwordet123456- des mots de passe très simples et courants qui sont garantis d'être dans la liste de mots par défaut de John. - Cela garantit un cassage rapide à des fins de démonstration, généralement en quelques secondes.
Avec ce fichier de données exemple prêt, vous avez maintenant une cible pour votre pratique du cassage de mots de passe. À l'étape suivante, vous utiliserez John the Ripper pour tenter de casser ces hashs.
Cassage de hashs avec le mode par défaut de John the Ripper
Avec le fichier de hashs exemple en place, il est temps de commencer le cassage avec John the Ripper. Par défaut, John utilise plusieurs modes, dont un mode "single crack" qui utilise le nom d'utilisateur et d'autres informations pour deviner les mots de passe, suivi d'un mode liste de mots avec sa liste de mots de passe intégrée. C'est un excellent point de départ pour identifier les mots de passe faibles et courants.
Exécutez la commande suivante pour démarrer le processus de cassage sur votre fichier sample_hashes.txt.
john /root/sample_hashes.txt
John chargera les hashs et commencera sa session de cassage. Vous verrez une sortie indiquant sa progression. Comme nous avons créé de vrais hashs avec des mots de passe très simples et courants (password et 123456), John devrait être capable de les casser rapidement en utilisant son mode liste de mots par défaut.
Using default input encoding: UTF-8
Loaded 2 password hashes with 2 different salts (sha512crypt, crypt(3) $6$ [SHA512 512/512 AVX512BW 8x])
Cost 1 (iteration count) is 5000 for all loaded hashes
Will run 2 OpenMP threads
Proceeding with single, rules:Single
Press 'q' or Ctrl-C to abort, almost any other key for status
Almost done: Processing the remaining buffered candidate passwords, if any.
Proceeding with wordlist:/usr/share/john/password.lst
...
Vous pouvez laisser John tourner pendant un moment pour tenter le cassage, ou arrêter le processus avec Ctrl-C si vous souhaitez vérifier les résultats rapidement. Pour voir les mots de passe qui ont été cassés, utilisez l'option --show.
john --show /root/sample_hashes.txt
Si les mots de passe sont cassés avec succès, la sortie devrait ressembler à ceci :
user1:password:18234:0:99999:7:::
user2:123456:18234:0:99999:7:::
2 password hashes cracked, 0 left
Comme nous avons utilisé des mots de passe très simples (password et 123456) qui sont presque certainement dans la liste de mots par défaut de John, ces hashs devraient être cassés très rapidement - souvent en quelques secondes. Ce succès démontre que John the Ripper fonctionne correctement avec notre fichier de hashs réel et montre à quelle vitesse les mots de passe faibles peuvent être compromis.
À l'étape suivante, nous explorerons comment fournir à John des listes de mots personnalisées et ajuster divers paramètres pour améliorer l'efficacité du cassage.
Utilisation d'une liste de mots personnalisée avec John the Ripper
Se fier aux paramètres par défaut n'est souvent pas suffisant. Une attaque ciblée utilisant une liste de mots personnalisée peut être bien plus efficace. Une liste de mots est simplement un fichier texte contenant un mot de passe potentiel par ligne. Dans cette étape, vous allez créer une petite liste de mots personnalisée et l'utiliser avec John the Ripper.
Créez un fichier nommé custom_wordlist.txt dans le répertoire /root avec quelques mots de passe courants, y compris ceux dont nous savons qu'ils sont dans notre fichier de hashs.
echo -e "password\n123456\nadmin123\ntest1234\nqwerty\npassword123" > /root/custom_wordlist.txt
Vérifiez le contenu de votre nouvelle liste de mots.
cat /root/custom_wordlist.txt
La sortie devrait afficher les six mots de passe que vous venez d'ajouter :
password
123456
admin123
test1234
qwerty
password123
Maintenant, exécutez John the Ripper à nouveau, mais cette fois, spécifiez votre liste de mots personnalisée en utilisant l'option --wordlist.
john --wordlist=/root/custom_wordlist.txt /root/sample_hashes.txt
Cette commande indique à John de tester chaque mot de passe de custom_wordlist.txt contre les hashs de sample_hashes.txt. Comme notre liste de mots contient les mots de passe réels (password et 123456) qui correspondent aux hashs de notre fichier, John devrait les casser très rapidement.
Une fois le processus terminé, vérifiez à nouveau les résultats.
john --show /root/sample_hashes.txt
Comme notre liste de mots contient les bons mots de passe, la sortie devrait maintenant afficher les identifiants cassés :
user1:password:18234:0:99999:7:::
user2:123456:18234:0:99999:7:::
2 password hashes cracked, 0 left
Cela démontre l'efficacité des attaques par liste de mots ciblée. En incluant les mots de passe réels dans notre liste de mots personnalisée, nous avons pu casser les hashs beaucoup plus rapidement qu'en nous fiant uniquement à la liste de mots par défaut de John. Cette technique est fondamentale pour les attaques par mot de passe ciblées. Ensuite, nous verrons comment effectuer une attaque similaire avec Hashcat.
Cassage de hashs avec Hashcat pour comparaison
Bien que John the Ripper soit un excellent outil, il est de bonne pratique de se familiariser avec des alternatives comme Hashcat. Hashcat est réputé pour sa vitesse, surtout sur les systèmes équipés de GPU. Ici, nous effectuerons la même attaque par dictionnaire en utilisant Hashcat.
Hashcat préfère un fichier propre contenant uniquement les valeurs de hash. Utilisez la commande awk pour extraire le deuxième champ (le hash) de sample_hashes.txt et enregistrez-le dans un nouveau fichier, clean_hashes.txt.
awk -F':' '{print $2}' /root/sample_hashes.txt > /root/clean_hashes.txt
Vérifiez le contenu du nouveau fichier.
cat /root/clean_hashes.txt
La sortie ne devrait contenir que les chaînes de hash :
$6$randomsalt$WS2qjCQ1JrmZv8otdbtntIYu6lRzkk2aIVhgIMdMexOcvD9bEAoxtKcyZLXbR3wlhOOPBscJbLCPUU/fYjFhM0
$6$anothersalt$ZffCt8y5Hl8gLYS79/rhyT76C12kNhuOvkFR8Ll0RXcjQz2Nzuh3VUdT//e21HYfH6fP9btOp2aG22O3S7q1z/
Maintenant, exécutez Hashcat. Vous devez spécifier le mode de hash (-m 1800 pour SHA-512 crypt) et le mode d'attaque (-a 0 pour une attaque par dictionnaire directe).
hashcat -m 1800 -a 0 /root/clean_hashes.txt /root/custom_wordlist.txt
Session..........: hashcat
Status...........: Cracked
Hash.Mode........: 1800 (sha512crypt $6$, SHA512 (Unix))
Hash.Target......: /root/clean_hashes.txt
Time.Started.....: Mon Sep 1 06:33:21 2025 (0 secs)
Time.Estimated...: Mon Sep 1 06:33:21 2025 (0 secs)
Kernel.Feature...: Pure Kernel
Guess.Base.......: File (/root/custom_wordlist.txt)
Guess.Queue......: 1/1 (100.00%)
Speed.#1.........: 226 H/s (5.08ms) @ Accel:8 Loops:1024 Thr:1 Vec:8
Recovered........: 2/2 (100.00%) Digests (total), 1/2 (50.00%) Digests (new), 2/2 (100.00%) Salts
Progress.........: 6/12 (50.00%)
Rejected.........: 0/6 (0.00%)
Restore.Point....: 0/6 (0.00%)
Restore.Sub.#1...: Salt:0 Amplifier:0-1 Iteration:4096-5000
Candidate.Engine.: Device Generator
Candidates.#1....: password -> password123
Avant de lancer l'attaque, confirmez que Hashcat peut détecter un backend OpenCL :
hashcat -I
Si cette commande signale qu'aucune plateforme OpenCL n'est disponible, installez le paquet runtime Intel OpenCL et vérifiez à nouveau :
apt update
apt install -y intel-opencl-icd
hashcat -I
Si Hashcat affiche toujours CL_PLATFORM_NOT_FOUND_KHR, installez le runtime Portable OpenCL et vérifiez à nouveau :
apt install -y pocl-opencl-icd
hashcat -I
Une fois OpenCL détecté, exécutez à nouveau la commande de cassage. Si Hashcat affiche un avertissement dans cet environnement conteneurisé, ajoutez --force.
hashcat -m 1800 -a 0 /root/clean_hashes.txt /root/custom_wordlist.txt --force
Une fois l'attaque terminée, affichez les mots de passe cassés en exécutant la commande avec l'option --show.
hashcat -m 1800 -a 0 /root/clean_hashes.txt /root/custom_wordlist.txt --show
Lorsque l'attaque réussit, Hashcat affiche chaque hash suivi du mot de passe cassé, séparés par deux-points :
$6$randomsalt$WS2qjCQ1JrmZv8otdbtntIYu6lRzkk2aIVhgIMdMexOcvD9bEAoxtKcyZLXbR3wlhOOPBscJbLCPUU/fYjFhM0:password
$6$anothersalt$ZffCt8y5Hl8gLYS79/rhyT76C12kNhuOvkFR8Ll0RXcjQz2Nzuh3VUdT//e21HYfH6fP9btOp2aG22O3S7q1z/:123456
Cette étape vous a présenté Hashcat comme une alternative puissante pour le cassage de mots de passe. Dans la dernière étape, vous apprendrez à documenter correctement vos découvertes.
Résumé
Dans ce laboratoire, vous avez acquis une expérience pratique des techniques fondamentales de cassage de mots de passe dans un environnement Kali Linux. Vous avez commencé par configurer votre espace de travail, en installant des outils essentiels comme John the Ripper et Hashcat. Vous avez ensuite appris à préparer les données cibles en créant un fichier de hashs exemple qui imite le format /etc/shadow de Linux.
Vous vous êtes exercé à utiliser John the Ripper avec ses paramètres par défaut et une liste de mots personnalisée, et vous avez exploré Hashcat comme une alternative puissante. Enfin, vous avez appris l'étape critique consistant à enregistrer vos découvertes pour la documentation et le rapport. Ces compétences constituent une base solide pour les tests d'intrusion et soulignent l'importance de mettre en œuvre des politiques de mots de passe robustes pour se défendre contre de telles attaques.
