Introduction
John the Ripper (JtR) est un outil puissant et populaire de cassage de mots de passe open-source. L'une de ses forces principales réside dans son extensibilité. Bien qu'il prenne en charge un grand nombre de types de hachage prêts à l'emploi, vous pourriez occasionnellement rencontrer un schéma de hachage personnalisé ou obscur que JtR ne reconnaît pas. Dans de tels cas, vous pouvez créer votre propre format personnalisé pour apprendre à JtR comment le casser.
Dans ce laboratoire, vous apprendrez les concepts fondamentaux de la création d'un format JtR personnalisé. Ce laboratoire est conceptuel et se concentre sur la structure et le processus, vous fournissant les connaissances de base nécessaires pour développer des formats entièrement fonctionnels. Vous n'écrirez ni ne compilerez un format entièrement fonctionnel, mais vous comprendrez toutes les étapes nécessaires.
Comprendre la structure des formats John the Ripper
Dans cette étape, vous apprendrez la structure fondamentale d'un format John the Ripper. Comprendre cette structure est la première et la plus cruciale partie de la création d'un format personnalisé.
Les formats JtR sont définis dans des fichiers source C (.c) et sont construits autour d'une structure C centrale nommée struct fmt_main. Cette structure agit comme un modèle, informant JtR de tout ce qu'il doit savoir sur le type de hachage.
Les champs clés de struct fmt_main incluent :
fmt_label: Une chaîne courte et unique que vous utilisez pour spécifier le format avec l'option de ligne de commande--format=(par exemple,md5raw).fmt_tag: Un identifiant unique utilisé en interne par JtR pour distinguer le format dans les fichiers de session sauvegardés (par exemple,$dynamic_0$).algorithm_name: Une chaîne décrivant l'algorithme de hachage et ses propriétés, utilisée à des fins d'information.plaintext_length: La longueur maximale du mot de passe que le format peut gérer.binary_size: La taille du hachage binaire brut. Pour MD5, ce serait 16 octets.salt_size: La taille du sel, si le type de hachage en utilise un.methods: Il s'agit d'une structure imbriquée contenant des pointeurs vers diverses fonctions qui implémentent la logique du format. Les fonctions les plus importantes sont :valid(): Vérifie si une chaîne de hachage donnée provenant d'un fichier d'entrée est valide pour ce format. C'est le premier gardien.split(): Si une chaîne de hachage contient plus que le hachage lui-même (comme un nom d'utilisateur), cette fonction sépare les composants.binary(): Convertit la chaîne de hachage hexadécimale ou base64 en sa représentation binaire brute.salt(): Extrait le sel de la chaîne de hachage.crypt_all(): La fonction principale. Elle prend un ensemble de mots de passe candidats, les hache et les prépare pour la comparaison.cmp_all(): Compare les hachages nouvellement calculés parcrypt_all()avec le hachage cible pour voir s'il y a une correspondance.
Cette étape est purement théorique. Vous n'avez pas besoin d'exécuter de commandes. Dans l'étape suivante, nous examinerons un fichier de format réel pour voir cette structure en action.
Identifier les définitions de formats existants
Dans cette étape, vous localiserez le code source des formats existants dans l'arborescence source de John the Ripper. Examiner ces fichiers est la meilleure façon d'apprendre à construire les vôtres.
Le script d'installation de ce laboratoire a déjà cloné le code source de JtR dans le répertoire ~/project/john.
Tout d'abord, naviguez dans le répertoire src où se trouvent les fichiers source.
cd ~/project/john/src
Maintenant, listez tous les fichiers qui définissent un format. Par convention, ces fichiers se terminent par _fmt_plug.c.
ls *_fmt_plug.c
Vous verrez une longue liste de fichiers, chacun correspondant à un type de hachage différent que JtR prend en charge.
7z_fmt_plug.c des_fmt_plug.c lotus5_fmt_plug.c ...
afs_fmt_plug.c django_fmt_plug.c mdc2_fmt_plug.c
aix_smd5_fmt_plug.c dmg_fmt_plug.c md4_fmt_plug.c
aix_ssha_fmt_plug.c dominosec_fmt_plug.c md5_fmt_plug.c
...et bien d'autres...
Jetons un coup d'œil à un fichier relativement simple, md5_fmt_plug.c, pour voir la struct fmt_main dont nous avons parlé. Nous utiliserons cat combiné avec head pour afficher uniquement la partie supérieure du fichier.
cat md5_fmt_plug.c | head -n 50
Dans la sortie, vous pourrez voir la définition de struct fmt_main fmt_MD5, avec son label, son tag, son nom d'algorithme et ses pointeurs de méthodes, exactement comme nous l'avons décrit à l'étape précédente.
Créer un format personnalisé simple (Conceptuel)
Dans cette étape, nous allons créer conceptuellement un nouveau fichier source C pour un format personnalisé simple. Cet exercice illustrera comment structurer un nouveau fichier de format.
Notre objectif est de créer un format qui reconnaît les hachages avec un préfixe spécial : labex_md5$. Par exemple, un hachage comme labex_md5$87e4e494b2399b0921d44e03693518f9.
Assurez-vous d'être toujours dans le répertoire ~/project/john/src. Nous utiliserons l'éditeur de texte nano pour créer notre nouveau fichier.
nano labex_md5_fmt_plug.c
Maintenant, copiez et collez le code C suivant dans l'éditeur nano. Il s'agit d'un squelette simplifié et ce n'est pas un format entièrement fonctionnel, mais il démontre les composants essentiels.
#if FMT_EXTERNS_H
extern struct fmt_main fmt_labex_md5;
#elif FMT_REGISTERS_H
john_register_one(&fmt_labex_md5);
#else
#include <string.h>
#include "arch.h"
#include "common.h"
#include "formats.h"
#define FORMAT_LABEL "labex-md5"
#define FORMAT_NAME "LabEx Custom MD5"
#define ALGORITHM_NAME "MD5 32/64"
#define PLAINTEXT_LENGTH 32
#define BINARY_SIZE 16
#define SALT_SIZE 0
#define TAG_PREFIX "labex_md5$"
#define TAG_LENGTH (sizeof(TAG_PREFIX) - 1)
// Cette fonction vérifie si une chaîne de hachage est valide pour notre format
static int valid(char *ciphertext, struct fmt_main *self)
{
if (strncmp(ciphertext, TAG_PREFIX, TAG_LENGTH))
return 0;
char *p = ciphertext + TAG_LENGTH;
if (hexlenu(p, 0) != 32)
return 0;
return 1;
}
struct fmt_main fmt_labex_md5 = {
{
FORMAT_LABEL,
FORMAT_NAME,
ALGORITHM_NAME,
BENCHMARK_COMMENT,
BENCHMARK_LENGTH,
0,
PLAINTEXT_LENGTH,
BINARY_SIZE,
BINARY_ALIGN,
SALT_SIZE,
SALT_ALIGN,
MIN_KEYS_PER_CRYPT,
MAX_KEYS_PER_CRYPT,
FMT_CASE | FMT_8_BIT,
{ NULL },
{ TAG_PREFIX },
NULL
}, {
/* init */ init,
/* done */ done,
/* reset */ reset,
/* prepare */ prepare,
/* valid */ valid,
/* split */ split,
/* binary */ binary,
/* salt */ salt,
{ NULL },
/* source */ source,
{
/* get_hash* */ get_hash_0,
/* get_hash* */ get_hash_1,
/* get_hash* */ get_hash_2,
/* get_hash* */ get_hash_3,
/* get_hash* */ get_hash_4,
/* get_hash* */ get_hash_5,
/* get_hash* */ get_hash_6
},
/* cmp_all */ cmp_all,
/* cmp_one */ cmp_one,
/* cmp_exact */ cmp_exact
}
};
#endif
Après avoir collé le code, sauvegardez le fichier et quittez nano en appuyant sur Ctrl+X, puis Y, et enfin Entrée.
Vous avez maintenant créé le fichier source d'un nouveau format. La partie la plus importante est la fonction valid(), qui vérifie simplement notre préfixe labex_md5$ et s'assure que le hachage qui suit a une longueur de 32 caractères.
Compiler John the Ripper avec un nouveau format (Conceptuel)
Maintenant que vous avez un fichier de format conceptuel, cette étape explique comment l'intégrer au processus de compilation de John the Ripper et le compiler.
Tout d'abord, assurez-vous d'être dans le répertoire src.
cd ~/project/john/src
La première étape de la compilation de JtR consiste à exécuter le script configure. Ce script vérifie votre système pour les bibliothèques requises et configure l'environnement de compilation.
./configure
Une fois la configuration terminée, vous pouvez compiler le code source en utilisant la commande make. Nous utiliserons make clean pour supprimer les compilations précédentes et make -sj4 pour exécuter la compilation en utilisant 4 tâches parallèles, ce qui accélère le processus.
make -s clean && make -sj4
La compilation prendra une minute ou deux.
Note importante : Dans un scénario réel, la simple création du fichier .c ne suffit pas. Vous devriez également modifier un fichier de configuration (comme Makefile.in) pour indiquer au système de construction d'inclure votre nouveau fichier objet labex_md5_fmt_plug.o lors de l'édition des liens de l'exécutable final john. Nous sautons cette modification pour simplifier ce laboratoire. Par conséquent, la compilation réussira, mais notre nouveau format ne sera pas réellement inclus dans le binaire final. Ceci illustre une étape critique du processus de développement.
Tester le format personnalisé (Conceptuel)
Dans cette dernière étape, nous allons discuter de la manière dont vous testeriez votre format personnalisé avec l'exécutable John the Ripper nouvellement compilé.
Le binaire john compilé se trouve dans le répertoire ~/project/john/run/. Naviguons-y.
cd ~/project/john/run
Vous pouvez lister tous les formats pris en charge par votre version compilée de JtR.
./john --list=formats
Faites défiler la liste. Vous remarquerez que notre format labex-md5 n'est pas présent. C'est attendu, car comme mentionné à l'étape précédente, nous n'avons pas modifié les fichiers de construction pour l'inclure.
Maintenant, créons un fichier de hachage d'exemple et une liste de mots pour voir comment nous utiliserions le format s'il avait été compilé avec succès.
Tout d'abord, créez un fichier nommé hashes.txt dans le répertoire racine de votre projet contenant un hachage qui correspond à notre format personnalisé. Le hachage 87e4e494b2399b0921d44e03693518f9 est le hachage MD5 du mot de passe "labex".
echo "labex_md5$87e4e494b2399b0921d44e03693518f9" > ~/project/hashes.txt
Ensuite, créez une liste de mots simple contenant le mot de passe correct.
echo "labex" > ~/project/wordlist.txt
Enfin, voici la commande que vous exécuteriez pour casser le hachage en utilisant le format personnalisé.
./john --format=labex-md5 --wordlist=~/project/wordlist.txt ~/project/hashes.txt
Lorsque vous exécutez cette commande, JtR signalera une erreur car le format est inconnu, confirmant notre compréhension du processus de compilation.
Unknown format name: "labex-md5"
Ceci conclut notre présentation conceptuelle de la création et du test d'un format JtR personnalisé.
Résumé
Dans ce laboratoire, vous avez exploré le processus conceptuel de création de formats personnalisés pour John the Ripper. Vous avez acquis une compréhension fondamentale des étapes clés impliquées dans l'extension des capacités de JtR.
Vous avez appris :
- La structure centrale
struct fmt_mainqui définit chaque format JtR. - Comment localiser et examiner les définitions de formats existantes dans le code source de JtR.
- Le processus de création d'un nouveau fichier source de format avec une fonction
valid()de base. - La procédure standard pour compiler JtR en utilisant
./configureetmake. - L'étape critique (et intentionnellement omise) de modification des fichiers de construction pour inclure un nouveau format.
- Comment tester un format en utilisant le drapeau
--formatet un fichier de hachage d'exemple.
Bien que ce laboratoire n'ait pas abouti à un format personnalisé entièrement fonctionnel, il vous a fourni les connaissances essentielles et une feuille de route claire pour développer vos propres formats afin de traiter des schémas de hachage de mots de passe uniques.
