Comment utiliser John the Ripper : tutoriel complet (2026)

Ce que fait John the Ripper

John the Ripper est un casseur de mots de passe open-source qui récupère des mots de passe en clair à partir de hashes cryptographiques en testant des candidats issus de wordlists, de motifs de masque ou de séquences de caractères générées. Il fonctionne sur Linux, macOS, Windows et la plupart des BSD, prend en charge plus de 470 formats de hash et de chiffrement dans le build jumbo, et est ce que la communauté sécurité a de plus proche d'un casseur universel.

L'histoire a son importance. John est maintenu par Openwall depuis 1996, ce qui le rend plus ancien que la plupart des hashes qu'il casse. Cette longévité se traduit en couverture de formats. Là où Hashcat se concentre sur les types de hash qui comptent aujourd'hui, John casse encore les fichiers ID Lotus Notes, les trousseaux Mac OS X 10.5 et des blobs d'authentification de bases de données obscurs que personne d'autre ne supporte. Pour les tests d'intrusion où vous trouvez un fichier bizarre dans une sauvegarde, cette amplitude fait la différence entre une découverte exploitable et une note de bas de page.

Deux choses différencient John de Hashcat. Premièrement, la détection automatique de format : vous pointez John sur un fichier de hashes et il identifie l'algorithme. Pas de numéros de mode à chercher, pas de table de correspondance. Deuxièmement, l'écosystème *2john : une famille de scripts qui extraient des hashes depuis des fichiers chiffrés, des archives et du matériel de clés. Hashcat exige que vous extrayiez le hash vous-même ; John regroupe l'extraction et le cassage dans un seul flux. Pour une comparaison plus large des cas où chaque outil l'emporte, notre guide des outils de tests d'intrusion couvre le rôle de chaque outil dans une vraie mission.

Une note tranchée : ignorez tous les articles « John vs Hashcat : qui gagne » qui désignent un vainqueur. Les vrais pentesters installent les deux et utilisent celui qui correspond au travail. Le cadrage est faux. La bonne question est « quel hash ai-je en face de moi, et quel outil le gère le mieux ».

Installer John the Ripper

L'installation dépend de la plateforme, mais le résultat doit toujours être le build jumbo. Vérifiez avec john --list=build-info après l'installation. Si la sortie mentionne « jumbo », tout est bon.

Linux (Kali, Debian, Ubuntu, Parrot)

Kali et Parrot livrent le build jumbo sous john par défaut :

sudo apt install john
john --list=build-info | head -3

Sur Debian ou Ubuntu standard, le paquet s'appelle aussi john, mais vérifiez la version. Si --list=build-info ne dit pas jumbo, compilez depuis les sources :

git clone https://github.com/openwall/john.git
cd john/src
./configure && make -j$(nproc)
ln -s ~/john/run/john /usr/local/bin/john

macOS

Homebrew installe directement la version jumbo : brew install john-jumbo. Après l'installation, lancez john --test pour benchmarker le build sur votre CPU et vérifier que tout est correctement lié.

Windows

Téléchargez le binaire pré-compilé depuis openwall.com/john et extrayez-le n'importe où. Lancez depuis le répertoire run/ extrait. WSL fonctionne aussi et tend à être plus naturel si vous venez de Linux.

Une fois installé, lancez un auto-test pour confirmer que le build fonctionne sur votre matériel :

john --test=10
Will run 8 OpenMP threads
Benchmarking: descrypt, traditional crypt(3) [DES 256/256 AVX2-16]... DONE
Speed for cost 1 (iteration count) of 25
Raw:    8521K c/s real, 1066K c/s virtual

Les chiffres varient selon le CPU. Le but de --test n'est pas de comparer avec autrui ; c'est de confirmer que le build a bien démarré et de vous donner une base pour repérer un futur run anormalement lent.

Identifier les types de hash avant de casser

John détecte automatiquement la plupart des formats, mais ce n'est pas magique. Quand le format est ambigu (un hex brut de 32 caractères peut être MD5, NTLM, LM ou plusieurs autres), John en choisit un et lance. Si vous vous trompez, vous perdez des heures. Identifier le hash en amont sauve le run.

Pour les hashes avec marqueurs de format, l'identification est triviale :

• $1$ - MD5crypt (ancien shadow Linux)
• $5$ - SHA-256crypt
• $6$ - SHA-512crypt (par défaut sur la plupart des distributions Linux modernes)
• $2y$ ou $2b$ - bcrypt
• $y$ - yescrypt (par défaut sur Debian 12, Ubuntu 24.04+)
• $argon2id$ - Argon2 (la meilleure classe, volontairement lent à casser)

Pour les hashes hex bruts sans marqueur, le contexte décide. Les hashes NTLM proviennent de fichiers SAM Windows, de dumps NTDS.dit ou de la sortie de secretsdump.py. Les MD5 bruts proviennent généralement de dumps de bases de données d'applications web. Si vous ne pouvez vraiment pas trancher, lancez hashid pour une estimation classée, puis utilisez le drapeau --format de John pour verrouiller le bon :

john --format=NT hash.txt
john --format=Raw-MD5 hash.txt
john --format=sha512crypt shadow.txt

Récupérez la liste complète des formats supportés avec john --list=formats. La sortie compte près de 500 entrées ; passez-la dans grep pour ce que vous cherchez :

john --list=formats | tr ',' '\n' | grep -i ssh

Pour le contexte sur les différences entre algorithmes de hash et leurs cas d'apparition, notre tutoriel sur le cassage de hash couvre la théorie des algorithmes. Ce guide reste centré sur les commandes spécifiques à John.

Mode wordlist : le flux par défaut

Le mode wordlist est le cas à 80 %. Vous avez un fichier de hashes et une liste de mots de passe candidats. John essaie chaque candidat, le hache avec l'algorithme cible et compare aux hashes fournis. L'invocation de base :

john --wordlist=/usr/share/wordlists/rockyou.txt hash.txt

Cette commande passe en revue 14 millions de mots de passe dans rockyou. Sur un CPU desktop moderne contre du NTLM sans sel, le passage complet prend moins d'une minute. Contre du bcrypt avec un facteur de coût 12, le même passage prend des semaines. L'algorithme du hash décide de tout.

Pendant que John tourne, appuyez sur n'importe quelle touche pour voir l'état : candidats par seconde, ETA, candidat courant. Appuyez sur q pour quitter proprement. John écrit les cassages réussis dans ~/.john/john.pot automatiquement. Consultez ce que vous avez cassé à tout moment :

$ john --show hash.txt
admin:Summer2024!:::::::
backup:hunter2:::::::
2 password hashes cracked, 0 left

La sortie de --show est compatible shell : passez-la dans cut -d: -f1,2 pour extraire les paires utilisateur:mot de passe pour votre rapport. Si une session est interrompue (vous avez fermé le terminal, le portable s'est endormi, le chat a débranché l'alim), reprenez depuis le fichier .rec dans ~/.john/ :

john --restore

Deux drapeaux à mémoriser pour le mode wordlist. --fork=N répartit le travail sur N cœurs CPU ; sur une machine 8 cœurs, --fork=8 multiplie environ par 8 le débit contre des hashes rapides. --session=nom étiquette le run, ce qui permet de lancer plusieurs sessions en parallèle et de les restaurer par nom. En pratique, tout run sérieux utilise les deux : john --wordlist=rockyou.txt --rules --fork=8 --session=mission-q2 hash.txt.

Au-delà des wordlists : modes incrémental et masque

Quand la wordlist est épuisée et que le hash résiste, vous avez deux options. Le mode incrémental génère des candidats à partir d'une distribution de probabilité apprise. Le mode masque génère des candidats qui correspondent à un motif connu.

L'incrémental, c'est la force brute que les gens imaginent quand ils entendent « cassage de mots de passe ». John génère les mots de passe statistiquement, en commençant par les combinaisons de caractères les plus probables et en s'élargissant. L'invocation de base :

john --incremental=ASCII hash.txt
john --incremental=Digits hash.txt
john --incremental=Alnum hash.txt

Les classes de caractères par défaut sont définies dans john.conf sous les sections [Incremental:*]. Vous pouvez les éditer, mais pour presque tout run réel, les classes stock ASCII, Digits et Alnum couvrent vos besoins. L'incrémental contre des hashes rapides fonctionne pour des mots de passe courts (5-7 caractères). Au-delà, ça devient un problème mathématique pour lequel vous n'avez pas le temps.

Le mode masque, c'est ce que vous sortez quand vous avez de l'intelligence sur la politique de mots de passe. Imaginons que l'organisation cible impose « 8 caractères, première lettre en majuscule, finit par chiffre-chiffre-spécial ». Cela se traduit directement en masque :

john --mask=?u?l?l?l?l?l?d?d?s hash.txt

Les marqueurs reprennent ceux de Hashcat : ?l minuscule, ?u majuscule, ?d chiffre, ?s spécial, ?a tout imprimable. Un masque de 9 caractères comme celui ci-dessus génère environ 30 milliards de candidats. Contre du NTLM sans sel, ça finit en quelques secondes ; contre du bcrypt, il faut un autre plan.

En pratique, le mode masque est la technique la plus sous-utilisée chez les nouveaux pentesters. L'instinct est de continuer à mouliner des wordlists. Le gain est de passer dix minutes à interroger le client sur sa politique de mots de passe, puis d'encoder cette politique en masque. Des cassages que les wordlists ratent pendant des heures tombent en quelques minutes avec un masque bien ciblé.

Les règles : multiplier votre wordlist

Les règles sont la fonctionnalité qui transforme une liste de 14 millions de mots en une attaque de 14 milliards de candidats. Chaque règle mute chaque entrée de la wordlist : ajouter des chiffres, mettre en majuscule, substituer en leet-speak, inverser la chaîne. Une wordlist devient des centaines de variantes par mot.

Les jeux de règles intégrés les plus utiles :

• --rules=Single - les règles stock de John, calibrées pour la vitesse. Rapides, couverture correcte, votre choix par défaut.
• --rules=Wordlist - similaire à Single mais avec des mutations de casse plus agressives.
• --rules=Jumbo - le tout-en-un. Tous les motifs de mutation que John connaît. Lent contre des hashes coûteux.
• --rules=KoreLogic - règles issues des concours crackme DEF CON de l'équipe KoreLogic. Calibrées sur les motifs de mots de passe d'entreprises réelles.

La commande de combat standard pour un environnement d'entreprise inconnu :

john --wordlist=rockyou.txt --rules=Jumbo --fork=8 hash.txt

Cela lance toutes les règles que John possède contre tous les mots de rockyou, parallélisé sur 8 cœurs. Sur du NTLM sans sel, le balayage complet termine en 30-60 minutes sur du matériel banalisé. Comptez 60-75 % de taux de cassage sur un dump d'entreprise typique.

Les règles personnalisées vont dans ~/.john/john.conf sous une section [List.Rules:Custom]. La syntaxe est documentée dans la référence officielle des règles John the Ripper ; attendez-vous à une courbe d'apprentissage. Pour 95 % des missions, les règles intégrées font mieux que tout ce que vous pourriez écrire vous-même dans le temps disponible. Évitez les règles personnalisées tant que vous n'avez pas une raison spécifique de les écrire, comme une boîte qui impose des mots de passe « $Saison$Année# » et que les règles stock ratent le dièse final.

Un exemple de chaîne de mutation. Avec --rules=KoreLogic appliqué, l'entrée password de la wordlist génère des candidats incluant Password1, P@ssw0rd, password!, password123, P@ssw0rd! et Password2024. Aucun n'est dans rockyou directement. Tous apparaissent dans les vrais dumps de mots de passe. C'est ce que les règles vous achètent.

Casser les types de hash réels

Les fichiers de hashes bruts sont du territoire débutant. Les vraies missions vous donnent des fichiers chiffrés, du matériel de clés et des dumps de bases que John ne peut pas attaquer sans prétraitement. Les scripts utilitaires *2john gèrent ce prétraitement.

Fichiers shadow Linux

Les fichiers /etc/passwd et /etc/shadow doivent être combinés en un seul fichier d'entrée :

unshadow /etc/passwd /etc/shadow > shadow-combined.txt
john --wordlist=rockyou.txt --rules=Single shadow-combined.txt

La plupart des distributions Linux modernes utilisent SHA-512crypt ($6$) ou yescrypt ($y$). Les deux sont volontairement lents. Comptez environ 10 000 candidats par seconde sur un CPU desktop. Wordlist plus règles est la stratégie réaliste ; l'incrémental complet ne l'est pas.

Pratiquez le pipeline complet dans le lab Shadow Cracker : extrayez /etc/shadow d'une cible, lancez unshadow et cassez le résultat avec John.

Fichiers ZIP, PDF, Office et clés SSH

Chaque type de fichier a son extracteur :

zip2john secret.zip > zip.hash
pdf2john confidential.pdf > pdf.hash
office2john document.docx > office.hash
ssh2john id_rsa > ssh.hash
keepass2john credentials.kdbx > kp.hash

Cassez ensuite chaque sortie avec la commande John standard. Le catalogue de labs inclut Crack SHA1 Hash pour la pratique sur hashes bruts et des labs dédiés au cassage ZIP et PDF dans la catégorie password-cracking.

Hashes NTLM et Active Directory

Les dumps NTDS.dit issus de secretsdump.py sortent dans un format que John lit directement. Filtrez d'abord les hashes pertinents :

cut -d: -f4 ntds.dit.dump > ntlm-hashes.txt
john --format=NT --wordlist=rockyou.txt --rules=KoreLogic ntlm-hashes.txt

NTLM est sans sel et rapide. Même sur CPU, comptez des millions de candidats par seconde. Contre un dump AD typique, prévoyez 60-80 % de taux de cassage dans la première heure avec rockyou plus règles KoreLogic. Les 20-40 % restants sont généralement des mots de passe longs aléatoires ou de type passphrase ; passez à une wordlist plus longue ou à un masque ciblé si nécessaire.

Dernière vérification : avril 2026 contre John the Ripper 1.9.0-jumbo-1 sur Kali 2026.1.

John the Ripper vs Hashcat : quand utiliser lequel

Choisissez John quand la flexibilité de format ou l'extraction de hashes compte. Choisissez Hashcat quand la vitesse brute compte. La réponse honnête, c'est que la plupart des pentesters utilisent les deux ; le tableau ci-dessous couvre les cas où l'un l'emporte clairement.

Le flux réaliste en mission : utiliser les *2john de John pour extraire les hashes des fichiers, identifier le format, puis envoyer les hashes rapides à Hashcat sur GPU et les hashes lents ou inhabituels à John sur CPU. Les deux outils partagent les wordlists et (avec quelques ajustements) les fichiers de règles. Les garder dans le même répertoire et basculer entre eux est la norme.

Considérations légales et éthiques

Les missions de tests d'intrusion autorisées, les compétitions CTF et vos propres labs dédiés sont les seuls contextes sûrs pour John the Ripper. Votre contrat de mission doit explicitement inclure le cassage de mots de passe comme activité approuvée. S'il ne le fait pas, obtenez une confirmation écrite avant d'extraire le premier hash.

Pour la pratique, restez sur des environnements contrôlés. Les labs HackerDNA, les VM VulnHub et les setups Docker locaux d'applications volontairement vulnérables existent spécifiquement pour l'apprentissage offensif et ne portent aucune exposition légale. Les vrais dumps de mots de passe issus de fuites (au-delà des jeux d'entraînement bien connus comme rockyou.txt) ne devraient pas être téléchargés ni stockés, même pour la « recherche ». L'exposition légale ne vaut pas la commodité.

Quand vous cassez des mots de passe lors d'une mission autorisée, traitez la sortie comme certaines des données les plus sensibles que le client possède. Stockez les identifiants cassés sous forme chiffrée, partagez-les uniquement par les canaux convenus et supprimez-les à la clôture de la mission. Le projet OWASP publie des recommandations sur le stockage des mots de passe et l'authentification qui aident quand les clients demandent comment se défendre contre les techniques que vous venez de démontrer.