Craquage de mots de passe Kali avec John

Introduction

Dans cet atelier, vous allez apprendre les bases du craquage de mots de passe sous Kali Linux, en vous concentrant sur l'outil puissant John the Ripper. L'objectif principal est de comprendre comment craquer les empreintes (hashes) 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 en test d'intrusion pour identifier les mots de passe faibles et renforcer la sécurité du système.

Lorsque vous ouvrirez le terminal, vous serez automatiquement placé dans un shell de conteneur Kali Linux. Toutes les commandes de cet atelier doivent être exécutées dans cet environnement. Grâce à des instructions guidées étape par étape, vous manipulerez des fichiers de hashes d'exemple, créerez et utiliserez des listes de mots (wordlists) personnalisées, comparerez des outils de craquage comme John the Ripper et Hashcat, et sauvegarderez vos résultats pour analyse. Cet atelier est conçu pour les débutants et offre une expérience d'apprentissage concrète et pratique 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 craquage de mots de passe. Comme mentionné précédemment, votre session terminal s'exécute déjà à l'intérieur d'un conteneur Kali Linux.

Nous utiliserons deux outils principaux : John the Ripper, un craqueur de mots de passe polyvalent et largement utilisé, et Hashcat, un autre outil puissant réputé pour sa rapidité et sa flexibilité. Tous deux sont indispensables à la panoplie de tout expert en tests d'intrusion.

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 s'afficher l'aide et les informations 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

Le résultat attendu affichera le numéro de version, par exemple :

v6.2.5

Une fois les deux outils installés et vérifiés, votre environnement est prêt pour les exercices de craquage de mots de passe des étapes suivantes.

Création d'un fichier de hashes d'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 véritables empreintes de mots de passe Linux que John the Ripper pourra traiter. Ces hashes sont formatés pour imiter ceux que l'on trouve dans le fichier /etc/shadow, lequel stocke de manière sécurisée les informations de mot de passe des utilisateurs sur les systèmes Linux. Cela vous permet de vous exercer au craquage 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 hashes directement avec des empreintes réelles pré-générées pour des mots de passe simples et courants qui peuvent être craqués rapidement.

Créez le fichier de hashes d'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$ dans chaque ligne indique que le hash est une empreinte cryptographique SHA-512, un standard courant pour les systèmes Linux modernes. Le format suit la structure du fichier shadow : nom_utilisateur:mot_de_passe_haché:dernière_modif:âge_min:âge_max:avertissement:inactif:expiration:réservé.

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 d'utilisateurs avec les 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 des hashes SHA-512 réels et correctement formatés que John the Ripper peut traiter.
Les mots de passe sont password et 123456 - des mots de passe très simples et courants qui sont garantis de figurer dans la liste de mots par défaut de John.
Cela garantit un craquage rapide à des fins de démonstration, généralement en quelques secondes.

Avec ce fichier de données d'exemple prêt, vous avez maintenant une cible pour votre pratique du craquage de mots de passe. Dans l'étape suivante, vous utiliserez John the Ripper pour tenter de craquer ces hashes.

Craquage de hashes avec le mode par défaut de John the Ripper

Une fois le fichier de hashes d'exemple en place, il est temps de commencer le craquage 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 propre liste 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 lancer le processus de craquage sur votre fichier sample_hashes.txt.

john /root/sample_hashes.txt

John chargera les hashes et commencera sa session de craquage. Vous verrez des informations indiquant sa progression. Comme nous avons créé des hashes réels avec des mots de passe très simples (password et 123456), John devrait être capable de les craquer 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 s'exécuter pendant un moment pour tenter le craquage, ou arrêter le processus avec Ctrl-C si vous souhaitez vérifier les résultats plus tôt. Pour afficher les mots de passe qui ont été craqués, utilisez l'option --show.

john --show /root/sample_hashes.txt

Si les mots de passe sont craqué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

Puisque nous avons utilisé des mots de passe très simples (password et 123456) qui figurent presque certainement dans la liste de mots par défaut de John, ces hashes devraient être craqués très rapidement, souvent en quelques secondes. Ce succès démontre que John the Ripper fonctionne correctement avec notre fichier de hashes réels et montre à quelle vitesse des mots de passe faibles peuvent être compromis.

Dans 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 craquage.

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 (wordlist) personnalisée peut être bien plus efficace. Une wordlist 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 que nous savons être dans notre fichier de hashes.

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 à nouveau John the Ripper, mais cette fois-ci, spécifiez votre liste de mots personnalisée à l'aide de 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 hashes de sample_hashes.txt. Comme notre liste contient les mots de passe réels (password et 123456) correspondant aux hashes de notre fichier, John devrait les craquer très rapidement.

Une fois le processus terminé, vérifiez à nouveau les résultats.

john --show /root/sample_hashes.txt

Puisque notre liste de mots contient les bons mots de passe, la sortie devrait maintenant afficher les identifiants craqué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ées. En incluant les mots de passe réels dans notre liste personnalisée, nous avons pu craquer les hashes beaucoup plus rapidement qu'en comptant uniquement sur la liste par défaut de John. Cette technique est fondamentale pour les attaques de mots de passe ciblées. Ensuite, nous verrons comment effectuer une attaque similaire avec Hashcat.

Craquage de hashes 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, en particulier sur les systèmes équipés de processeurs graphiques (GPU). Ici, nous allons effectuer la même attaque par dictionnaire en utilisant Hashcat.

Hashcat préfère un fichier propre ne contenant que 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 doit contenir que les chaînes de caractères des hashes :

$6$randomsalt$WS2qjCQ1JrmZv8otdbtntIYu6lRzkk2aIVhgIMdMexOcvD9bEAoxtKcyZLXbR3wlhOOPBscJbLCPUU/fYjFhM0
$6$anothersalt$ZffCt8y5Hl8gLYS79/rhyT76C12kNhuOvkFR8Ll0RXcjQz2Nzuh3VUdT//e21HYfH6fP9btOp2aG22O3S7q1z/

Maintenant, lancez Hashcat. Vous devez spécifier le mode de hachage (-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

Hashcat commencera la session de craquage. Comme notre liste de mots contient les bons mots de passe (password et 123456), Hashcat devrait craquer ces hashes très rapidement. Une fois terminé, visualisez les mots de passe craqués en exécutant la même commande avec l'option --show.

hashcat -m 1800 -a 0 /root/clean_hashes.txt /root/custom_wordlist.txt --show

Si l'attaque réussit, Hashcat affichera le hash suivi du mot de passe craqué, 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 craquage de mots de passe. Dans l'étape finale, vous apprendrez à documenter correctement vos découvertes.

Résumé

Dans cet atelier, vous avez acquis une expérience pratique des techniques fondamentales de craquage de mots de passe dans un environnement Kali Linux. Vous avez commencé par configurer votre espace de travail en installant des outils essentiels tels que John the Ripper et Hashcat. Vous avez ensuite appris à préparer les données cibles en créant un fichier de hashes d'exemple imitant le format /etc/shadow de Linux.

Vous vous êtes exercé à utiliser John the Ripper avec ses paramètres par défaut ainsi qu'avec une liste de mots personnalisée, et vous avez exploré Hashcat comme une alternative performante. Enfin, vous avez appris l'étape cruciale de la sauvegarde de vos découvertes pour la documentation et le reporting. 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.