Création de règles avancées pour John the Ripper

Introduction

Dans ce laboratoire, vous explorerez les capacités avancées du moteur de règles de John the Ripper. John the Ripper est un outil puissant de cassage de mots de passe, et son moteur de règles permet des attaques hautement personnalisées et efficaces. Comprendre comment créer des règles efficaces est crucial pour maximiser son potentiel. Vous apprendrez le chaînage de règles, la création de règles pour des transformations courantes comme le Leet Speak, le développement de règles pour des modèles de mots de passe typiques, le test d'ensembles de règles complexes et l'optimisation des performances des règles. À la fin de ce laboratoire, vous aurez une solide compréhension de la manière d'exploiter le moteur de règles de John the Ripper pour des scénarios de cassage de mots de passe plus sophistiqués.

Comprendre le chaînage de règles

Dans cette étape, vous apprendrez le chaînage de règles dans John the Ripper. Le chaînage de règles vous permet de combiner plusieurs règles pour créer des transformations plus complexes. Ceci est particulièrement utile lorsque vous devez appliquer une séquence de modifications à une entrée de liste de mots.

Tout d'abord, assurons-nous que John the Ripper est installé. Sinon, vous pouvez l'installer en utilisant apt.

sudo apt update
sudo apt install -y john

Ensuite, nous allons créer un fichier de liste de mots simple nommé wordlist.txt dans votre répertoire ~/project.

echo "password" > ~/project/wordlist.txt
echo "secret" >> ~/project/wordlist.txt

Maintenant, créons un fichier de règles nommé chain_rules.rule dans ~/project qui démontre le chaînage de règles de base. Cette règle ajoutera d'abord "123" au mot, puis mettra en majuscule la première lettre.

nano ~/project/chain_rules.rule

Ajoutez le contenu suivant au fichier chain_rules.rule :

: A123 c

• : (deux-points) indique le début d'une règle.
• A123 ajoute "123" à la fin du mot.
• c met en majuscule la première lettre du mot.

Enregistrez le fichier en appuyant sur Ctrl+X, puis Y, puis Entrée.

Maintenant, utilisons John the Ripper avec ce fichier de règles. Nous utiliserons l'option --stdout pour voir les mots transformés sans réellement casser de mots de passe.

john --wordlist=~/project/wordlist.txt --rules=~/project/chain_rules.rule --stdout

Vous devriez voir une sortie similaire à celle-ci :

Password123
Secret123

Ceci démontre comment les règles sont chaînées : A123 est appliqué en premier, puis c est appliqué au résultat.

Créer des règles pour les transformations Leet Speak

Dans cette étape, vous allez créer des règles pour effectuer des transformations Leet Speak. Le Leet Speak (ou "1337 Speak") est une pratique courante où les lettres sont remplacées par des chiffres ou des symboles qui leur ressemblent (par exemple, 'a' devient '4', 'e' devient '3', 's' devient '5'). C'est une technique fréquente utilisée dans les mots de passe.

Nous allons créer un nouveau fichier de règles nommé leet_rules.rule dans votre répertoire ~/project. Ce fichier contiendra des règles pour convertir les lettres courantes en leurs équivalents Leet Speak.

nano ~/project/leet_rules.rule

Ajoutez le contenu suivant au fichier leet_rules.rule :

: s/a/4 s/e/3 s/i/1 s/o/0 s/s/5

• s/ancien/nouveau est une règle de substitution. Elle remplace la première occurrence de ancien par nouveau.
• Nous chaînons plusieurs règles de substitution pour appliquer plusieurs transformations Leet Speak.

Enregistrez le fichier en appuyant sur Ctrl+X, puis Y, puis Entrée.

Maintenant, testons ces règles avec notre wordlist.txt.

john --wordlist=~/project/wordlist.txt --rules=~/project/leet_rules.rule --stdout

Vous devriez voir une sortie similaire à celle-ci :

p4ssw0rd
s3cr3t

Ceci démontre comment vous pouvez créer des règles pour gérer les variations courantes du Leet Speak, ce qui peut améliorer considérablement l'efficacité de vos efforts de cassage de mots de passe contre les utilisateurs qui utilisent ces substitutions.

Développer des règles pour les modèles de mots de passe courants

Dans cette étape, vous allez développer des règles qui ciblent les modèles de mots de passe courants, tels que l'ajout d'années ou de nombres courants, ou la mise en majuscule de la première lettre. Ces modèles sont fréquemment utilisés par les utilisateurs pour rendre leurs mots de passe "plus forts" sans réellement augmenter leur entropie.

Créons un nouveau fichier de règles nommé pattern_rules.rule dans votre répertoire ~/project. Ce fichier combinera plusieurs transformations courantes.

nano ~/project/pattern_rules.rule

Ajoutez le contenu suivant au fichier pattern_rules.rule :

: c A2023
: c A!
: c A@

• c met en majuscule la première lettre.
• A2023 ajoute l'année "2023".
• A! ajoute un point d'exclamation.
• A@ ajoute un symbole arobase (@).

Chaque ligne représente une règle distincte. John the Ripper appliquera chaque règle à chaque mot de la liste de mots indépendamment.

Enregistrez le fichier en appuyant sur Ctrl+X, puis Y, puis Entrée.

Maintenant, testons ces règles avec notre wordlist.txt.

john --wordlist=~/project/wordlist.txt --rules=~/project/pattern_rules.rule --stdout

Vous devriez voir une sortie similaire à celle-ci :

Password2023
Secret2023
Password!
Secret!
Password@
Secret@

Ceci démontre comment vous pouvez créer un ensemble de règles pour couvrir les modèles de mots de passe courants, élargissant ainsi considérablement votre surface d'attaque au-delà des simples mots du dictionnaire.

Tester des ensembles de règles complexes

Dans cette étape, vous allez combiner les concepts appris jusqu'à présent pour tester un ensemble de règles plus complexe. Cela implique la création d'un fichier de règles qui intègre à la fois des transformations Leet Speak et l'ajout de modèles courants, démontrant comment plusieurs types de règles peuvent être utilisés ensemble.

Créons un fichier de règles complet nommé complex_rules.rule dans votre répertoire ~/project. Ce fichier inclura des substitutions Leet Speak, puis ajoutera des nombres ou des symboles courants.

nano ~/project/complex_rules.rule

Ajoutez le contenu suivant au fichier complex_rules.rule :

: s/a/4 s/e/3 s/i/1 s/o/0 s/s/5 A123
: s/a/4 s/e/3 s/i/1 s/o/0 s/s/5 A!

• La première règle applique le Leet Speak, puis ajoute "123".
• La deuxième règle applique le Leet Speak, puis ajoute "!".

Enregistrez le fichier en appuyant sur Ctrl+X, puis Y, puis Entrée.

Maintenant, testons ces règles complexes avec notre wordlist.txt.

john --wordlist=~/project/wordlist.txt --rules=~/project/complex_rules.rule --stdout

Vous devriez voir une sortie similaire à celle-ci :

p4ssw0rd123
s3cr3t123
p4ssw0rd!
s3cr3t!

Ceci démontre la puissance de la combinaison de différents types de règles pour générer un large éventail de candidats de mots de passe potentiels, ce qui est essentiel pour un cassage de mots de passe efficace.

Optimiser les performances des règles

Dans cette étape, vous apprendrez à optimiser les performances des règles. Bien que les règles complexes soient puissantes, elles peuvent également être gourmandes en ressources informatiques. John the Ripper fournit des mécanismes pour optimiser l'application des règles, principalement en comprenant l'ordre des opérations et en évitant les règles redondantes.

Une façon d'optimiser est de s'assurer que vos règles sont aussi spécifiques que possible et d'éviter de générer des candidats inutiles. Par exemple, si vous savez qu'un mot de passe commencera toujours par une majuscule, appliquer une règle qui met toutes les lettres en majuscule est inefficace.

Considérez le fichier complex_rules.rule de l'étape précédente. Chaque règle applique toutes les substitutions Leet Speak avant d'ajouter quelque chose. Si vous aviez de nombreuses règles similaires, répéter les substitutions pourrait être moins efficace que de les appliquer une seule fois, puis de bifurquer. Cependant, pour des cas simples, le chaînage au sein d'une seule règle est souvent suffisamment efficace.

Pour des ensembles de règles très volumineux ou des scénarios spécifiques, John the Ripper autorise une syntaxe de règles plus avancée et des fichiers de règles externes. Pour ce laboratoire, nous nous concentrerons sur une compréhension conceptuelle de l'optimisation.

Une technique d'optimisation courante consiste à filtrer votre liste de mots ou à cibler des modèles spécifiques avec des ensembles de règles plus petits et séparés, plutôt qu'un seul ensemble de règles massif et englobant tout.

Démontrons un concept d'optimisation simple en créant une règle qui ne s'applique que si le mot est plus court qu'une certaine longueur, en utilisant la règle l (longueur). Cela peut éviter d'appliquer des règles complexes à des mots qui sont déjà trop longs pour être des mots de passe courants.

Créez un nouveau fichier de règles nommé optimized_rules.rule dans votre répertoire ~/project.

nano ~/project/optimized_rules.rule

Ajoutez le contenu suivant au fichier optimized_rules.rule :

: l<10 s/e/3 A!

• l<10 signifie "appliquer cette règle uniquement si la longueur du mot est inférieure à 10 caractères".
• s/e/3 substitue 'e' par '3'.
• A! ajoute un point d'exclamation.

Enregistrez le fichier en appuyant sur Ctrl+X, puis Y, puis Entrée.

Maintenant, testons cette règle avec notre wordlist.txt.

john --wordlist=~/project/wordlist.txt --rules=~/project/optimized_rules.rule --stdout

Vous devriez voir une sortie similaire à celle-ci :

s3cr3t!
p4ssw0rd!

"password" (8 caractères) et "secret" (6 caractères) sont tous deux inférieurs à 10 caractères, donc la règle s'applique. Si vous aviez un mot comme "superlongpassword" (17 caractères), cette règle ne s'appliquerait pas à celui-ci, économisant ainsi des calculs.

Comprendre comment appliquer sélectivement des règles en fonction de conditions telles que la longueur peut améliorer considérablement les performances de vos tentatives de cassage en réduisant le nombre de candidats inutiles générés.

Résumé

Dans ce laboratoire, vous avez acquis une compréhension approfondie de la création de règles avancées pour John the Ripper. Vous avez commencé par explorer le chaînage de règles, qui permet des transformations séquentielles. Vous avez ensuite appris à créer des règles spécifiques pour les transformations Leet Speak courantes et développé des règles pour cibler les modèles de mots de passe prévalents. De plus, vous vous êtes exercé à tester des ensembles de règles complexes en combinant différents types de règles. Enfin, vous avez été initié aux concepts d'optimisation des performances des règles, tels que l'utilisation de règles conditionnelles pour réduire les calculs inutiles. Ces compétences sont fondamentales pour exploiter efficacement John the Ripper dans des scénarios réels d'audit et de cassage de mots de passe.