Introduction
John the Ripper (JtR) est un outil populaire de cassage de mots de passe. Lorsqu'il réussit à casser un mot de passe, il stocke le résultat dans un fichier nommé john.pot, souvent appelé "potfile". Cela évite à JtR de perdre du temps à essayer de recasser le même hash à l'avenir.
Dans ce laboratoire, vous travaillerez dans un scénario où une tentative de cassage de mot de passe a déjà été partiellement effectuée par John the Ripper. Votre tâche consiste à identifier quels hashes n'ont pas été cassés, puis à utiliser un autre outil puissant, Hashcat, pour tenter de casser les hashes restants. Ce flux de travail est courant dans les tests d'intrusion et les audits de sécurité, où plusieurs outils sont utilisés pour maximiser les résultats.
Vous apprendrez à :
- Localiser et comprendre le potfile de JtR.
- Utiliser des outils en ligne de commande pour extraire et comparer des listes de hashes.
- Utiliser Hashcat pour effectuer une attaque par dictionnaire sur les hashes restants.
Localiser un Potfile John the Ripper Existant
Dans cette étape, vous allez localiser et inspecter le fichier john.pot. Ce fichier est automatiquement créé par John the Ripper pour stocker les hashes qu'il a réussi à casser, ainsi que leurs mots de passe en clair. L'emplacement par défaut de ce fichier se trouve dans un répertoire caché nommé .john dans le répertoire personnel de l'utilisateur.
Notre environnement de laboratoire a été pré-configuré avec un fichier john.pot issu d'une session de cassage simulée précédente. Visualisons son contenu.
Utilisez la commande cat pour afficher le contenu du potfile. Tout votre travail sera effectué dans le répertoire par défaut ~/project, mais le potfile se trouve dans /home/labex/.john/.
cat ~/.john/john.pot
Vous devriez voir la sortie suivante, qui montre les hashes et les mots de passe correspondants que JtR a déjà trouvés.
$1$abc$gqNud23o1vjR/pYd9gH7k/:password123
$1$def$H9g2s3kLd/fG1hJkLpQ9r/:labex
$1$ghi$aB4c5dE6fG7hI8jK9lM0n/:secret
Comprendre le Format d'un Potfile JtR
Dans cette étape, nous allons analyser la structure du fichier john.pot. Comprendre ce format est essentiel pour traiter ses données.
Comme vous l'avez vu à l'étape précédente, chaque ligne du potfile a un format spécifique :
HASH:MOT_DE_PASSE_EN_CLAIR
Analysons la première ligne de notre fichier :
$1$abc$gqNud23o1vjR/pYd9gH7k/:password123
$1$abc$gqNud23o1vjR/pYd9gH7k/: Il s'agit de la chaîne de hash complète qui a été cassée. Ce format (commençant par$1$) indique qu'il s'agit d'un hash MD5-crypt, couramment utilisé dans les anciens systèmes Linux.:: Un deux-points est utilisé comme délimiteur, séparant le hash du mot de passe.password123: C'est le mot de passe en clair qui correspond au hash.
Notre objectif est de découvrir quels hashes de notre liste originale (all_hashes.txt) ne sont pas présents dans ce potfile. Pour ce faire, nous devons d'abord isoler uniquement la partie hash de chaque ligne dans john.pot. Nous le ferons à l'étape suivante. Cette étape actuelle est destinée à la compréhension conceptuelle, il n'y a donc pas de commandes à exécuter.
Extraire les Hashes du Potfile JtR
Dans cette étape, vous allez extraire uniquement les valeurs de hash du fichier john.pot. Nous pouvons utiliser la commande cut, un utilitaire Linux standard pour découper des sections de chaque ligne d'un fichier.
Nous allons indiquer à cut d'utiliser le deux-points (:) comme délimiteur et d'extraire le premier champ (-f1). Nous redirigerons la sortie vers un nouveau fichier nommé cracked_hashes.txt dans votre répertoire actuel (~/project).
Exécutez la commande suivante dans votre terminal :
cut -d: -f1 ~/.john/john.pot > cracked_hashes.txt
Maintenant, vérifiez que le fichier a été créé correctement en visualisant son contenu :
cat cracked_hashes.txt
La sortie devrait contenir uniquement les chaînes de hash :
$1$abc$gqNud23o1vjR/pYd9gH7k/
$1$def$H9g2s3kLd/fG1hJkLpQ9r/
$1$ghi$aB4c5dE6fG7hI8jK9lM0n/
Reformater les Hashes pour une Attaque Hashcat
Dans cette étape, vous allez identifier les hashes que JtR n'a pas réussi à casser. Vous avez un fichier avec tous les hashes originaux (all_hashes.txt) et un fichier avec les hashes qui ont déjà été cassés (cracked_hashes.txt). En comparant ces deux fichiers, vous pouvez créer une nouvelle liste contenant uniquement les hashes non cassés.
Nous utiliserons la commande grep pour accomplir cela. Les options que nous utiliserons sont :
-v: Inverse la correspondance, sélectionnant les lignes non correspondantes.-F: Traite les motifs comme des chaînes fixes, et non comme des expressions régulières.-f file: Obtient les motifs à partir du fichier spécifié.
Cette commande lira les motifs à partir de cracked_hashes.txt et supprimera toutes les lignes correspondantes de all_hashes.txt, en sauvegardant le résultat dans uncracked_hashes.txt.
grep -v -F -f cracked_hashes.txt all_hashes.txt > uncracked_hashes.txt
Maintenant, vérifiez le contenu de votre nouveau fichier. Il devrait contenir les trois hashes qui n'étaient pas dans le potfile.
cat uncracked_hashes.txt
Vous devriez voir la sortie suivante :
user4:$1$jkl$oP1qR2sT3uV4wX5yZ6a7b/
user5:$1$mno$c8d9e0f1g2h3i4j5k6l7m/
user6:$1$pqr$n9o8p7q6r5s4t3u2v1w0x/
Ce fichier est maintenant prêt à être utilisé avec Hashcat.
Utiliser Hashcat pour Tenter de Casser les Hashes Manqués par JtR
Dans cette dernière étape, vous utiliserez Hashcat pour attaquer les hashes restants. Hashcat est un outil de cassage de mots de passe très rapide et polyvalent qui peut exploiter les GPUs pour des gains de performance massifs.
La syntaxe de base pour une attaque par dictionnaire avec Hashcat est hashcat -m <mode> <fichier_hash> <fichier_liste_de_mots>.
-m 500: Ceci spécifie le type de hash.500correspond à MD5-crypt, qui est le type de hash avec lequel nous travaillons.--force: Cette option est souvent nécessaire dans les environnements virtualisés ou conteneurisés comme ce laboratoire pour contourner les avertissements et forcer Hashcat à s'exécuter.
Maintenant, exécutez Hashcat contre le fichier uncracked_hashes.txt en utilisant le fichier wordlist.txt fourni.
hashcat -m 500 --force uncracked_hashes.txt wordlist.txt
Hashcat va démarrer. Vous verrez des informations de statut pendant son exécution. Étant donné que notre liste de mots est petite et contient les bons mots de passe, le processus sera très rapide.
...
Session..........: hashcat
Status...........: Running
Hash.Name........: md5crypt, MD5 (Unix), Cisco-IOS $1$ (MD5)
Hash.Target......: uncracked_hashes.txt
...
Approaching final keyspace - workload adjusted.
Session..........: hashcat
Status...........: Cracked
...
Une fois qu'Hashcat a terminé, il stocke les mots de passe cassés dans son propre potfile. Pour afficher les nouveaux mots de passe cassés, vous pouvez utiliser l'option --show.
hashcat -m 500 --force --show uncracked_hashes.txt
La sortie affichera les hashes et leurs mots de passe en clair nouvellement découverts.
$1$jkl$oP1qR2sT3uV4wX5yZ6a7b/:dragon
$1$mno$c8d9e0f1g2h3i4j5k6l7m/:qwerty
$1$pqr$n9o8p7q6r5s4t3u2v1w0x/:sunshine
Félicitations, vous avez utilisé avec succès la sortie d'un outil de cassage pour guider l'entrée d'un autre !
Résumé
Dans ce laboratoire, vous avez appris un flux de travail pratique pour combiner les forces de différents outils de cassage de mots de passe. Vous avez commencé avec un potfile John the Ripper préexistant, qui représente les résultats d'une session de cassage précédente.
Vous avez réussi à :
- Localiser et interpréter le contenu d'un fichier
john.pot. - Utiliser la commande
cutpour extraire des champs de données spécifiques. - Utiliser la commande
greppour comparer deux listes et isoler les hashes non cassés. - Lancer une attaque par dictionnaire Hashcat sur les hashes restants et les casser avec succès.
Ce processus d'identification du travail restant et de transmission à un autre outil est une stratégie très efficace dans les évaluations de sécurité du monde réel, vous permettant de couvrir plus de terrain et d'augmenter vos chances de succès.
