Introduction
John the Ripper (JtR) est un outil populaire et puissant de sécurité des mots de passe et de récupération de mots de passe open-source. Il peut effectuer le cassage de mots de passe en utilisant plusieurs modes, tels que le mode "single crack", le mode "wordlist" et le mode "incremental".
Au-delà de ces modes standards, JtR offre un "External Mode" incroyablement flexible. Ce mode vous permet d'utiliser un programme ou un script externe pour générer des candidats de mots de passe. Cela vous donne un contrôle total sur la logique de génération de mots de passe, vous permettant de créer des modèles de mots de passe hautement personnalisés et complexes qui ne sont pas possibles avec d'autres modes.
Dans ce laboratoire, vous apprendrez les bases du mode externe de JtR. Vous commencerez par comprendre les concepts de base, puis vous écrirez, compilerez et utiliserez votre propre programme C personnalisé pour générer des mots de passe. Vous apprendrez également des techniques de débogage de base et appliquerez vos connaissances à un scénario plus pratique.
Comprendre les bases du mode externe
Dans cette étape, vous apprendrez les concepts fondamentaux du mode externe de John the Ripper. Ce mode fonctionne en exécutant un programme externe que vous définissez. John the Ripper lit ensuite la sortie standard de ce programme, traitant chaque ligne comme un candidat mot de passe potentiel.
Ces modes externes sont définis dans le fichier de configuration john.conf, généralement situé à /etc/john/john.conf. Chaque mode externe est défini dans une section telle que [List.External:ModeName].
Inspectons une définition de mode externe existante dans le fichier de configuration par défaut pour voir comment elle est structurée. Nous rechercherons le mode Keyboard, qui simule des candidats mots de passe basés sur des modèles de frappe au clavier.
Exécutez la commande suivante pour afficher la configuration du mode Keyboard :
grep -A 10 "\[List.External:Keyboard\]" /etc/john/john.conf
Vous verrez un bloc de code de type C. La fonction la plus importante est generate(), qui est responsable de la production des candidats mots de passe.
Pour voir un mode externe en action, vous pouvez exécuter john avec l'indicateur --stdout. Cela indique à John d'afficher les candidats générés à l'écran au lieu d'essayer de casser un hash. Testons le mode Keyboard.
john --stdout --external=Keyboard | head -n 5
Cette commande sélectionne le mode externe Keyboard et redirige sa sortie vers head, qui vous montre les 5 premiers candidats mots de passe générés. La sortie sera une séquence de caractères représentant des modèles de clavier.
q
w
e
r
t
Cela démontre le principe de base : John the Ripper exécute la logique définie dans le mode externe et utilise sa sortie comme source de mots de passe. Dans les étapes suivantes, nous créerons notre propre programme pour servir de source.
Écrire un script simple pour le mode externe
Dans cette étape, vous allez écrire et compiler votre premier script simple pour le mode externe en utilisant le langage de programmation C. Notre objectif est de créer un programme qui génère une liste fixe de mots de passe, puis de configurer John the Ripper pour l'utiliser.
Tout d'abord, créons un fichier source C nommé simple_gen.c à l'aide de l'éditeur nano.
nano simple_gen.c
Maintenant, copiez et collez le code C suivant dans l'éditeur nano. Ce programme affichera simplement trois mots de passe différents sur la sortie standard, chacun sur une nouvelle ligne.
#include <stdio.h>
int main() {
printf("pass1\n");
printf("pass2\n");
printf("pass3\n");
return 0;
}
Appuyez sur Ctrl+X, puis Y, et Entrée pour enregistrer le fichier et quitter nano.
Ensuite, compilez ce code C en un fichier exécutable nommé simple_gen à l'aide du compilateur gcc.
gcc -o simple_gen simple_gen.c
Maintenant que nous avons notre exécutable, nous devons indiquer à John the Ripper comment l'utiliser. Nous allons le faire en créant une copie locale du fichier de configuration dans notre répertoire de projet et en ajoutant une nouvelle définition de mode externe.
cp /etc/john/john.conf ./my_john.conf
Ouvrez le nouveau fichier my_john.conf avec nano.
nano my_john.conf
Faites défiler jusqu'à la toute fin du fichier et ajoutez le bloc de configuration suivant. Cela définit un nouveau mode externe appelé MySimple qui exécute notre programme simple_gen.
[List.External:MySimple]
void generate()
{
exec("./simple_gen");
}
Enregistrez et quittez nano (Ctrl+X, Y, Entrée).
Enfin, testons notre nouveau mode externe. Nous utiliserons à nouveau l'indicateur --stdout pour voir la sortie, et l'indicateur --config pour indiquer à John notre fichier de configuration personnalisé.
john --stdout --external=MySimple --config=./my_john.conf
Vous devriez voir la sortie exacte de notre programme C, confirmant que John the Ripper exécute avec succès notre script personnalisé.
pass1
pass2
pass3
Implémenter une logique de génération de mots de passe personnalisée
Dans cette étape, vous allez améliorer votre script pour implémenter une logique de génération de mots de passe plus dynamique. Au lieu d'une liste fixe, nous allons générer des mots de passe basés sur un modèle : un mot de base suivi d'une séquence de nombres. C'est un modèle courant pour les mots de passe faibles.
Modifions notre programme C pour générer des mots de passe comme labex0, labex1, labex2, et ainsi de suite.
Ouvrez à nouveau le fichier simple_gen.c avec nano.
nano simple_gen.c
Remplacez le code existant par le suivant. Cette nouvelle version utilise une boucle for pour ajouter les nombres de 0 à 199 au mot de base "labex".
#include <stdio.h>
int main() {
char *base_word = "labex";
for (int i = 0; i < 200; i++) {
printf("%s%d\n", base_word, i);
}
return 0;
}
Enregistrez et quittez nano. Maintenant, recompilez le programme avec gcc pour appliquer les modifications.
gcc -o simple_gen simple_gen.c
Testons le générateur mis à jour avec l'indicateur --stdout pour voir un échantillon de la nouvelle sortie.
john --stdout --external=MySimple --config=./my_john.conf | head -n 5
La sortie devrait maintenant afficher le nouveau modèle.
labex0
labex1
labex2
labex3
labex4
Maintenant, le vrai test. Nous allons utiliser notre mode externe personnalisé pour casser le hash de mot de passe que nous avons préparé lors de la configuration. Le mot de passe pour testuser est labex123. Notre script génère ce candidat, il devrait donc trouver une correspondance.
Exécutez la commande suivante pour démarrer le processus de cassage. Notez que nous avons supprimé --stdout et ajouté le chemin de notre fichier de hash, hashes.txt.
john --external=MySimple --config=./my_john.conf ./hashes.txt
John exécutera votre script, générera des candidats et les testera contre le hash. Il devrait trouver rapidement le mot de passe. La sortie ressemblera à ceci :
Using default input encoding: UTF-8
Loaded 1 password hash (sha512crypt, $6$ [SHA512 256/256 AVX2 4x])
Cost 1 (iteration count) is 5000 for all loaded hashes
Will run 4 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
labex123 (testuser)
1g 0:00:00:00 DONE (2024-05-20 08:30) 100.0g/s 12300p/s 12300c/s 12300C/s labex123..labex130
Use the "--show" option to display all of the cracked passwords reliably
Session completed
Pour confirmer le mot de passe cassé, utilisez l'option --show.
john --show ./hashes.txt
Cela affichera le mot de passe cassé à côté du nom d'utilisateur.
testuser:labex123:1001:1001::/home/testuser:/bin/sh
1 password hash cracked, 0 left
Déboguer les scripts en mode externe
Dans cette étape, vous allez apprendre quelques techniques de base pour déboguer vos scripts en mode externe. Lorsqu'un script ne fonctionne pas comme prévu, il peut être difficile à diagnostiquer car il est exécuté par un autre programme (John the Ripper).
Une méthode de débogage courante et efficace consiste à écrire des messages de journalisation depuis votre script dans un fichier séparé. Cela vous permet de suivre son flux d'exécution et d'inspecter les valeurs des variables.
Modifions notre programme C pour écrire dans un fichier journal nommé debug.log. Ouvrez simple_gen.c avec nano.
nano simple_gen.c
Remplacez le code par la version suivante. Ce code ouvre debug.log en écriture, puis utilise fprintf pour y écrire des messages d'état pendant l'exécution.
#include <stdio.h>
#include <stdlib.h>
int main() {
FILE *log_file = fopen("debug.log", "w");
if (log_file == NULL) {
// Cannot open log file, exit
return 1;
}
fprintf(log_file, "Debug: Script started.\n");
char *base_word = "labex";
for (int i = 0; i < 200; i++) {
printf("%s%d\n", base_word, i);
fprintf(log_file, "Debug: Generated candidate %s%d\n", base_word, i);
}
fprintf(log_file, "Debug: Script finished.\n");
fclose(log_file);
return 0;
}
Enregistrez et quittez nano, puis recompilez le programme.
gcc -o simple_gen simple_gen.c
Maintenant, exécutez à nouveau John the Ripper. Nous n'avons pas besoin de voir les candidats de mots de passe, nous pouvons donc rediriger la sortie standard vers /dev/null. L'important est que notre script s'exécute et crée le fichier journal.
john --stdout --external=MySimple --config=./my_john.conf > /dev/null
La commande s'exécutera pendant un moment et se terminera. Maintenant, un fichier debug.log devrait exister dans votre répertoire de projet. Visualisons son contenu.
cat debug.log | head -n 5
Vous devriez voir les messages de débogage que nous avons ajoutés à notre programme.
Debug: Script started.
Debug: Generated candidate labex0
Debug: Generated candidate labex1
Debug: Generated candidate labex2
Debug: Generated candidate labex3
Cette technique est inestimable pour trouver des problèmes dans votre logique, tels que des boucles incorrectes, des valeurs de variables erronées ou des erreurs d'accès aux fichiers, sans l'interférence de la propre sortie de John the Ripper.
Appliquer le mode externe à des scénarios spécifiques
Dans cette étape, vous allez appliquer vos connaissances à un scénario plus pratique. Au lieu d'utiliser un mot de base codé en dur, votre script lira une liste de mots de base à partir d'un fichier et générera des variations pour chacun d'eux. C'est une approche beaucoup plus puissante et réaliste.
Tout d'abord, créons un fichier de liste de mots simple nommé words.txt contenant quelques mots de base potentiels.
echo "admin" > words.txt
echo "user" >> words.txt
echo "guest" >> words.txt
Ensuite, nous allons modifier notre programme C pour lire ce fichier. Le programme devra accepter le nom du fichier de liste de mots comme argument de ligne de commande. Ouvrez simple_gen.c avec nano.
nano simple_gen.c
Remplacez le code par le suivant. Cette version lit un nom de fichier depuis la ligne de commande, ouvre ce fichier, et pour chaque mot qu'il lit, il génère trois candidats de mot de passe : le mot lui-même, le mot suivi de "123", et le mot suivi de "2024".
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char *argv[]) {
if (argc < 2) {
fprintf(stderr, "Usage: %s <wordlist_file>\n", argv[0]);
return 1;
}
FILE *file = fopen(argv[1], "r");
if (file == NULL) {
perror("Error opening file");
return 1;
}
char line[256];
while (fgets(line, sizeof(line), file)) {
// Remove newline character from the end of the line
line[strcspn(line, "\n")] = 0;
// Generate variations for the word
printf("%s\n", line);
printf("%s123\n", line);
printf("%s2024\n", line);
}
fclose(file);
return 0;
}
Enregistrez, quittez et recompilez le programme.
gcc -o simple_gen simple_gen.c
Maintenant, nous devons mettre à jour notre fichier my_john.conf pour passer le nom du fichier words.txt comme argument à notre script. Créons un nouveau mode externe appelé MyAdvanced pour cela. Ouvrez my_john.conf avec nano.
nano my_john.conf
Faites défiler jusqu'à la fin du fichier et ajoutez cette nouvelle section. Notez comment "words.txt" est passé comme second paramètre à la fonction exec.
[List.External:MyAdvanced]
void generate()
{
exec("./simple_gen", "words.txt");
}
Enregistrez et quittez nano. Enfin, testez votre nouveau mode externe avancé.
john --stdout --external=MyAdvanced --config=./my_john.conf
La sortie devrait maintenant être une liste de candidats de mots de passe générés à partir des mots de votre fichier words.txt, avec les variations spécifiées appliquées à chacun.
admin
admin123
admin2024
user
user123
user2024
guest
guest123
guest2024
Vous avez créé avec succès un générateur de mots de passe flexible et piloté par fichier pour John the Ripper.
Résumé
Félicitations pour avoir terminé ce laboratoire ! Vous avez exploré avec succès le puissant mode externe de John the Ripper.
Dans ce laboratoire, vous avez appris :
- Le concept de base du mode externe de John the Ripper et comment il utilise des programmes externes pour générer des candidats de mots de passe.
- Comment écrire, compiler et utiliser un programme C simple comme générateur de mots de passe.
- Comment configurer un mode externe personnalisé dans le fichier
john.conf. - Comment implémenter une logique de génération de mots de passe dynamique basée sur des modèles.
- Comment utiliser votre mode personnalisé pour réussir à casser un hash de mot de passe.
- Une technique de base mais efficace pour déboguer vos scripts externes en enregistrant dans un fichier.
- Comment créer un script plus avancé et pratique qui lit des mots de base à partir d'un fichier.
Les compétences que vous avez acquises fournissent une base pour créer des règles de cassage de mots de passe hautement spécialisées, adaptées à des cibles et des scénarios spécifiques. Vous pouvez explorer davantage ce sujet en utilisant d'autres langages de script comme Python ou Perl, ou en implémentant une logique de mutation et de génération de mots de passe encore plus complexe.
