Appliquer des règles aux listes de mots pour le cassage avancé

Introduction

Dans ce laboratoire, vous explorerez les puissantes capacités de cassage basées sur des règles de John the Ripper (JtR). Bien que les attaques par dictionnaire simples soient efficaces, les mots de passe du monde réel impliquent souvent des variations telles que la casse, des chiffres ajoutés ou des caractères spéciaux. Le moteur de règles de JtR vous permet de définir des transformations complexes à appliquer aux mots d'une liste de mots, augmentant ainsi considérablement les chances de casser des mots de passe qui ne sont pas directement présents dans le dictionnaire. Vous apprendrez la syntaxe de base des règles JtR, créerez vos propres règles personnalisées et les appliquerez à une liste de mots pour observer leur effet.

Comprendre la syntaxe des règles de John the Ripper

Dans cette étape, vous apprendrez la syntaxe de base des règles de John the Ripper (JtR). Les règles JtR sont définies dans un fichier de configuration, généralement john.conf, ou peuvent être passées directement via la ligne de commande pour des cas simples. Chaque règle est une séquence de commandes à caractère unique qui modifient un mot.

Les commandes de règles courantes incluent :

• c : Met la première lettre en majuscule.
• C : Met toutes les lettres en majuscule.
• l : Met la première lettre en minuscule.
• L : Met toutes les lettres en minuscule.
• t : Inverse la casse de la première lettre.
• T : Inverse la casse de toutes les lettres.
• p<N> : Ajoute le caractère <N> au début.
• a<N> : Ajoute le caractère <N> à la fin.
• s<old><new> : Remplace la première occurrence de <old> par <new>.
• S<old><new> : Remplace toutes les occurrences de <old> par <new>.
• x<N> : Extrait une sous-chaîne de longueur N depuis le début.
• z<N> : Extrait une sous-chaîne de longueur N depuis la fin.
• D : Supprime le premier caractère.
• M : Supprime le dernier caractère.
• r : Inverse le mot.

Commençons par visualiser le fichier john.conf par défaut pour voir quelques exemples de règles intégrées.

Ouvrez le fichier john.conf en utilisant nano :

nano /etc/john/john.conf

Faites défiler le fichier pour trouver la section [List.Rules:Wordlist]. Vous y verrez diverses ensembles de règles définis. Par exemple, vous pourriez voir des règles comme c (mettre la première lettre en majuscule) ou a[0-9] (ajouter un chiffre).

Appuyez sur Ctrl+X pour quitter nano.

Maintenant, essayons une règle simple directement depuis la ligne de commande en utilisant l'option --stdout de JtR, qui applique des règles à une liste de mots et affiche les résultats sur la sortie standard sans tenter de casser des hachages. Ceci est utile pour tester des règles.

Exécutez la commande suivante pour appliquer la règle c (mettre la première lettre en majuscule) à votre wordlist.txt :

john --wordlist=~/project/wordlist.txt --rules=single --stdout

Vous devriez voir les mots de votre wordlist.txt avec leur première lettre en majuscule. Par exemple, "password" devient "Password".

Password
Secret
Labex
Test

Ceci démontre comment une règle simple peut transformer des mots. Dans les étapes suivantes, vous créerez et combinerez des règles plus complexes.

Créer une règle simple pour la capitalisation

Dans cette étape, vous allez créer un fichier de règles personnalisé pour appliquer des règles de capitalisation. Bien que l'ensemble de règles single dans JtR inclue la capitalisation de base, la création de votre propre fichier de règles vous donne plus de contrôle et permet des transformations plus spécifiques.

Tout d'abord, créez un nouveau fichier nommé my_rules.rule dans votre répertoire ~/project. Ce fichier contiendra vos règles personnalisées.

nano ~/project/my_rules.rule

Ajoutez les lignes suivantes au fichier my_rules.rule. Ces règles vont :

• c : Mettre la première lettre en majuscule.
• C : Mettre toutes les lettres en majuscule.
• t : Inverser la casse de la première lettre (par exemple, "password" -> "Password", "Password" -> "password").

c
C
t

Enregistrez le fichier en appuyant sur Ctrl+O, puis Entrée, et quittez nano en appuyant sur Ctrl+X.

Maintenant, appliquez ces règles personnalisées à votre wordlist.txt en utilisant l'option --rules, en spécifiant votre nouveau fichier de règles.

john --wordlist=~/project/wordlist.txt --rules=file:~/project/my_rules.rule --stdout

Observez la sortie. Vous devriez voir chaque mot de votre wordlist.txt transformé par chacune des règles que vous avez définies. Par exemple, "password" apparaîtra comme "Password", "PASSWORD", et "Password" (en raison de la règle t appliquée au "password" original).

Password
SECRET
LABEX
TEST
password
PASSWORD
secret
SECRET
labex
LABEX
test
TEST
Password
Secret
Labex
Test

Ceci démontre comment définir et utiliser un fichier de règles personnalisé. Chaque règle dans le fichier est appliquée séquentiellement à chaque mot de la liste de mots.

Appliquer des règles pour l'ajout de nombres

Dans cette étape, vous apprendrez comment ajouter des nombres aux mots en utilisant les règles de JtR. L'ajout de nombres est une variation de mot de passe très courante, et JtR fournit des commandes puissantes pour générer ces variations efficacement.

La commande a<N> ajoute un caractère <N>. Pour ajouter des chiffres, vous pouvez utiliser des plages de caractères comme a[0-9] pour ajouter un seul chiffre de 0 à 9. Vous pouvez également combiner cela avec d'autres règles.

Ajoutons des règles à my_rules.rule pour ajouter des nombres. Ouvrez à nouveau votre fichier de règles :

nano ~/project/my_rules.rule

Ajoutez les lignes suivantes à la fin du fichier. Ces règles vont :

• a[0-9] : Ajouter un seul chiffre (0-9) au mot.
• a[0-9][0-9] : Ajouter deux chiffres (00-99) au mot. Cette règle générera 100 variations pour chaque mot.

a[0-9]
a[0-9][0-9]

Enregistrez le fichier (Ctrl+O, Entrée) et quittez nano (Ctrl+X).

Maintenant, appliquez ces règles mises à jour à votre wordlist.txt. Comme a[0-9][0-9] génère de nombreuses variations, nous limiterons la sortie en utilisant head à des fins de démonstration.

john --wordlist=~/project/wordlist.txt --rules=file:~/project/my_rules.rule --stdout | head -n 50

Vous verrez des mots comme "password0", "password1", ..., "password00", "password01", etc. La commande head -n 50 limite la sortie aux 50 premières lignes, car la sortie complète serait très longue.

Password
SECRET
LABEX
TEST
password
PASSWORD
secret
SECRET
labex
LABEX
test
TEST
Password
Secret
Labex
Test
password0
password1
password2
password3
password4
password5
password6
password7
password8
password9
secret0
secret1
secret2
secret3
secret4
secret5
secret6
secret7
secret8
secret9
labex0
labex1
labex2
labex3
labex4
labex5
labex6
labex7
labex8
labex9
test0
test1
test2
test3
test4
test5

Ceci montre comment générer efficacement des variations avec des nombres ajoutés, ce qui est crucial pour casser des modèles de mots de passe courants.

Combiner plusieurs règles pour des transformations complexes

Dans cette étape, vous allez combiner plusieurs commandes de règles pour créer des transformations de mots de passe plus complexes. JtR vous permet de chaîner des commandes de règles sur une seule ligne, en les appliquant séquentiellement à chaque mot.

Créons une règle qui met la première lettre en majuscule, puis ajoute un seul chiffre.

Ouvrez à nouveau votre fichier my_rules.rule :

nano ~/project/my_rules.rule

Ajoutez la règle suivante à la fin du fichier. Cette règle ca[0-9] signifie :

1. c : Mettre la première lettre en majuscule.
2. a[0-9] : Ajouter un seul chiffre (0-9).

ca[0-9]

Enregistrez le fichier (Ctrl+O, Entrée) et quittez nano (Ctrl+X).

Maintenant, appliquez ces règles mises à jour à votre wordlist.txt et observez la sortie. Encore une fois, nous utiliserons head pour limiter la sortie.

john --wordlist=~/project/wordlist.txt --rules=file:~/project/my_rules.rule --stdout | head -n 50

Vous devriez voir des variations comme "Password0", "Password1", "Secret0", "Secret1", etc.

Password
SECRET
LABEX
TEST
password
PASSWORD
secret
SECRET
labex
LABEX
test
TEST
Password
Secret
Labex
Test
password0
password1
password2
password3
password4
password5
password6
password7
password8
password9
secret0
secret1
secret2
secret3
secret4
secret5
secret6
secret7
secret8
secret9
labex0
labex1
labex2
labex3
labex4
labex5
labex6
labexex7
labex8
labex9
test0
test1
test2
test3
test4
test5
Password0
Password1
Password2
Password3
Password4
Password5
Password6
Password7
Password8
Password9

Ceci démontre la puissance de la combinaison de règles. Vous pouvez créer des ensembles de règles très spécifiques et efficaces en chaînant des commandes. Par exemple, s@a!ca[0-9] substituerait '@' par '!', mettrait la première lettre en majuscule, puis ajouterait un chiffre.

Tester des règles personnalisées sur une liste de mots

Dans cette dernière étape, vous utiliserez vos règles personnalisées pour tenter de casser un hash factice. Cela simulera un scénario de cassage de mot de passe réel.

Rappelez-vous que lors de la configuration, un hash pour le mot "password" a été créé et enregistré dans ~/project/hashes.txt. Le hash est user1:5f4dcc3b5aa765d61d8327deb882cf99 (hash MD5 de "password").

Tout d'abord, assurons-nous que votre fichier my_rules.rule contient une règle qui générerait "password" ou une de ses variations qui correspond au hash. Pour cet exemple, nous supposerons que le hash correspond au mot original "password". Si vous aviez un hash pour "Password0", votre règle ca[0-9] serait utile.

Pour cette démonstration, nous utiliserons le wordlist.txt original et votre my_rules.rule pour essayer de casser le hash.

Exécutez John the Ripper avec votre fichier de hashes, votre liste de mots et vos règles personnalisées :

john ~/project/hashes.txt --wordlist=~/project/wordlist.txt --rules=file:~/project/my_rules.rule

John the Ripper commencera à traiter la liste de mots, en appliquant vos règles et en comparant les mots générés au hash. S'il trouve une correspondance, il affichera le mot de passe cassé.

Vous devriez voir une sortie similaire à celle-ci, indiquant que le mot de passe a été cassé :

Using default input encoding: UTF-8
Loaded 1 password hash (md5crypt, crypt(3) $1$ [MD5 SSSP])
Will run 4 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
password         (user1)
1g 0:00:00:00 DONE (2023-10-27 10:30) 100% (ETA: 00:00:00)
Session completed.

Pour afficher à nouveau le mot de passe cassé, vous pouvez utiliser l'option --show :

john --show ~/project/hashes.txt

Cette commande affichera tous les mots de passe que JtR a réussi à casser et à stocker dans son fichier pot.

user1:password

1 password hash cracked, 0 left

Cette dernière étape démontre l'application pratique des règles personnalisées dans le cassage de mots de passe. En créant intelligemment des règles, vous pouvez améliorer considérablement l'efficacité de vos attaques par dictionnaire contre divers modèles de mots de passe.

Résumé

Dans ce laboratoire, vous avez appris avec succès à exploiter le puissant moteur de règles de John the Ripper pour le cassage de mots de passe avancé. Vous avez commencé par comprendre la syntaxe de base des règles de JtR, y compris les commandes pour la mise en majuscule et l'inversion de casse. Vous avez ensuite créé votre propre fichier de règles personnalisé et ajouté des règles pour ajouter des nombres, une variation courante de mot de passe. Enfin, vous avez combiné plusieurs commandes de règles pour créer des transformations plus complexes et appliqué vos règles personnalisées pour casser un hash factice, simulant un scénario réel. Cette expérience pratique vous a doté des connaissances nécessaires pour définir et appliquer des ensembles de règles sophistiqués, améliorant considérablement votre capacité à casser des mots de passe qui ne sont pas directement présents dans une liste de mots standard.