Challenge : retrouvez un mot de passe à partir d’un hash

maginez que vous tombiez sur une base de données contenant une série de mots de passe… mais sous forme de chaînes incompréhensibles, comme :

5f4dcc3b5aa765d61d8327deb882cf99

À première vue, cela ne ressemble à rien de lisible. Pourtant, ce hash correspond à quelque chose de très familier : le mot de passe “password”.

Dans ce tutoriel, vous allez découvrir comment comprendre, générer, et tenter de retrouver un mot de passe à partir d’un hash, comme le ferait un pirate éthique ou un expert en cybersécurité.

Ce type d’exercice est appelé un “challenge de cracking de hash”, et il est régulièrement proposé dans les formations en sécurité informatique ou dans les compétitions appelées CTF (Capture The Flag).

Mais avant de plonger dans la partie pratique, il est essentiel de comprendre ce qu’est un hash, à quoi il sert, et pourquoi il est conçu pour être… irréversible.

Comprendre les fonctions de hachage

Une fonction de hachage est un algorithme mathématique qui transforme une donnée (comme un mot de passe, un fichier ou un texte) en une chaîne de caractères unique, de longueur fixe.

Ce processus s’appelle le hachage, et le résultat est appelé empreinte ou digest.

Prenons un exemple simple avec la fonction MD5. En PHP, vous pouvez générer un hash MD5 comme ceci :

<?php
$mot_de_passe = "bonjour";
$hash = md5($mot_de_passe);
echo $hash;

Le résultat affiché sera :

a6d5c8c7a8a5d2dcdac7f4f5e5f1bfb2

Si vous essayez avec un autre mot, même très proche (par exemple “bonjour1”), le hash sera complètement différent. Ce comportement s’appelle l’effet avalanche : une toute petite modification du texte d’origine provoque une transformation totale du résultat.

Les fonctions de hachage les plus connues sont :

• MD5 (ancienne, très rapide mais aujourd’hui considérée comme vulnérable)
• SHA-1 (également dépréciée)
• SHA-256, SHA-512 (plus sûres)
• bcrypt, argon2, scrypt (spécialement conçues pour le hachage des mots de passe)

Le but d’un hash est d’assurer la sécurité : lorsqu’un utilisateur se connecte, le site ne stocke pas son mot de passe en clair, mais seulement son hash. Lorsqu’il saisit son mot de passe, le site le re-hache et compare le résultat avec celui en base de données.

Pour allez plus loin : Hashé un mot de passe

Pourquoi un mot de passe haché n’est-il pas censé être retrouvé ?

Le hachage n’est pas un chiffrement. Le chiffrement (comme AES ou RSA) permet de décrypter un message à condition d’avoir la clé. Le hachage, lui, est à sens unique : il n’existe pas de “clé de déchiffrement”.

Autrement dit, il n’y a pas de bouton “inverser le hash”. Mais… alors pourquoi cet tutoriel parle-t-il de “retrouver un mot de passe à partir d’un hash” ?

Parce qu’en pratique, les humains ne choisissent pas toujours des mots de passe robustes. Et comme le hachage est déterministe (le même mot produit toujours le même hash), il est possible d’utiliser des bases de données de hash connus pour deviner l’original.

Par exemple :

md5("password") = 5f4dcc3b5aa765d61d8327deb882cf99

Ce hash a été calculé des millions de fois, et figure dans toutes les bases publiques de hash. Si vous le rencontrez, vous n’avez pas besoin de “le casser” : il suffit de le chercher.

C’est ce qu’on appelle une attaque par dictionnaire ou une recherche dans une base pré-calculée.

Comment font les pirates pour retrouver un mot de passe ?

Les pirates (ou chercheurs en sécurité) utilisent trois principales méthodes pour tenter de retrouver un mot de passe à partir d’un hash :

1. La recherche dans une base de hash connue
   Des sites comme CrackStation.net ou Hashes.com contiennent des millions de hash pré-calculés. Il suffit d’entrer votre hash et d’attendre une correspondance.
2. L’attaque par dictionnaire
   On teste un grand nombre de mots issus d’un dictionnaire (par exemple les 10 000 mots de passe les plus utilisés). Chaque mot est haché et comparé avec le hash à retrouver.
3. L’attaque par force brute (brute force)
   On teste toutes les combinaisons possibles de caractères jusqu’à trouver le bon.
   Cette méthode garantit un résultat, mais peut être extrêmement lente selon la longueur du mot de passe et l’algorithme de hachage utilisé.

Voyons maintenant comment vous pouvez simuler ces techniques vous-même, en toute légalité, à des fins éducatives.

Pour allez plus loin, découvrez comment Tester / Craquer un mot de passe

Challenge pratique : retrouver un mot de passe à partir d’un hash

Pour cet exercice, imaginons que vous avez récupéré ce hash :

5f4dcc3b5aa765d61d8327deb882cf99

Votre mission : retrouver le mot de passe d’origine à l’aide d’un petit script PHP.

Étape 1 : Créez votre fichier crack.php

<?php
$hash_a_trouver = "5f4dcc3b5aa765d61d8327deb882cf99";
$dictionnaire = ["123456", "admin", "password", "bonjour", "azerty", "motdepasse"];

foreach ($dictionnaire as $mot) {
    if (md5($mot) === $hash_a_trouver) {
        echo "Mot de passe trouvé : $mot";
        exit;
    }
}
echo "Aucun mot de passe trouvé.";

Quand vous exécutez ce code, le script teste chaque mot du dictionnaire, le hache avec MD5, et le compare au hash que vous cherchez à casser.

Le résultat :

Mot de passe trouvé : password

Félicitations, vous venez de “cracker” un hash !

Étape 2 : Et si le mot de passe n’était pas dans le dictionnaire ?

Dans ce cas, il faut passer à une autre approche : la force brute.

Voici un exemple simple en PHP qui génère toutes les combinaisons de lettres minuscules sur 4 caractères :

<?php
$hash_a_trouver = "81dc9bdb52d04dc20036dbd8313ed055"; // 1234

$lettres = range('a', 'z');
$chiffres = range('0', '9');
$caracteres = array_merge($lettres, $chiffres);

function bruteForce($hash, $caracteres, $mot = '') {
    if (md5($mot) === $hash) {
        echo "Mot de passe trouvé : $mot";
        exit;
    }
    if (strlen($mot) < 4) {
        foreach ($caracteres as $c) {
            bruteForce($hash, $caracteres, $mot . $c);
        }
    }
}

bruteForce($hash_a_trouver, $caracteres);

Ce script teste toutes les combinaisons de 1 à 4 caractères composées de lettres et de chiffres. Même pour une longueur si courte, le nombre de possibilités est déjà très élevé (36⁴ = 1 679 616).

C’est pour cette raison que les mots de passe longs et complexes sont très difficiles à casser.

Étape 3 : Même concept en Python

Python est souvent utilisé pour ce genre de tests car il est plus rapide à exécuter que PHP. Voici un exemple équivalent :

import hashlib
from itertools import product
import string

hash_a_trouver = "5f4dcc3b5aa765d61d8327deb882cf99"

for longueur in range(1, 6):
    for mot in product(string.ascii_lowercase, repeat=longueur):
        mot = ''.join(mot)
        if hashlib.md5(mot.encode()).hexdigest() == hash_a_trouver:
            print("Mot de passe trouvé :", mot)
            exit()

Ici, on utilise itertools.product pour générer toutes les combinaisons possibles.
Le code peut prendre plusieurs minutes à s’exécuter, mais il illustre parfaitement la logique.

Techniques avancées, outils professionnels et défenses

Nous allons maintenant aborder des notions plus avancées et concrètes. Vous apprendrez ce que sont les rainbow tables, comment fonctionnent des outils professionnels comme Hashcat et John the Ripper, et surtout quelles sont les bonnes pratiques pour protéger vos utilisateurs et éviter que leurs mots de passe soient retrouvés à partir d’un hash.

Rainbow tables : principe et limites

Une rainbow table est une énorme table pré-calculée qui associe des mots en clair à leurs hash. Au lieu de recalculer un hash à la volée, on recherche le hash dans la table et on lit immédiatement le mot en clair correspondant. Cette approche repose sur un compromis temps/espace : vous dépensez beaucoup d’espace disque pour gagner énormément de temps au moment de la recherche.

Toutefois, les rainbow tables ont deux limites majeures. Premièrement, elles sont efficaces uniquement pour des fonctions de hachage rapides et sans salt, comme MD5 ou SHA-1. Deuxièmement, l’utilisation d’un salt (valeur aléatoire stockée avec le hash) rend les rainbow tables pratiquement inutiles, car il faut alors recalculer la table pour chaque salt possible, ce qui devient prohibitif. C’est pour cette raison que les salts sont aujourd’hui indispensables pour le stockage sécurisé des mots de passe.

Hashcat et John the Ripper : aperçu pratique

Hashcat et John the Ripper sont des outils de cracking largement utilisés par les professionnels de la sécurité et les chercheurs en cybersécurité. Ils exploitent la puissance des GPU ou des clusters pour accélérer les attaques par dictionnaire, par règles et par force brute.

Voici un exemple de commande Hashcat pour tenter de casser un hash MD5 contenu dans le fichier hashes.txt à l’aide d’un dictionnaire rockyou.txt :

hashcat -m 0 -a 0 hashes.txt /chemin/vers/rockyou.txt

Dans cette commande, -m 0 indique le mode MD5, et -a 0 indique une attaque par dictionnaire. Hashcat possède aussi des modes pour bcrypt, bcrypt $2y$, sha256crypt, et bien d’autres. Il propose des règles puissantes qui modifient chaque mot du dictionnaire en appliquant des transformations (ajout de chiffres, substitutions, permutations), ce qui augmente très fortement les chances de succès sans sacrifier trop de temps.

John the Ripper s’utilise de manière similaire et inclut des fonctionnalités intégrées pour détecter automatiquement le type de hash. Un usage courant en mode “single crack” combine des informations sur les noms d’utilisateurs et d’autres champs pour générer des mots probables.

Je n’expliquerai pas ici la mise en place détaillée de ces logiciels — leur documentation est complète et chaque environnement (GPU, CPU, OS) impose des réglages — mais gardez en tête qu’ils montrent à quel point des mots de passe simples peuvent être compromis rapidement lorsqu’ils ne sont pas protégés par des mécanismes adaptés.

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

Salage (salting) et poivrage (pepper) : pourquoi et comment

Le salt est une valeur aléatoire différente pour chaque mot de passe, stockée en clair (ou avec le hash) en base de données. Lorsqu’un mot de passe est haché, on concatène le salt au mot en clair avant d’appliquer la fonction de hachage. Le résultat est que deux utilisateurs ayant le même mot de passe n’auront pas le même hash, et qu’il devient inutile d’utiliser rainbow tables centralisées.

Le pepper est une valeur secrète, généralement unique à l’application, qui n’est pas stockée en base de données mais conservée dans un endroit séparé (par exemple une variable d’environnement ou un coffre-fort de secrets). Le pepper est concaténé au mot de passe avant le hachage, comme le salt, mais il ajoute une couche de sécurité supplémentaire si un attaquant obtient la base de données : sans la valeur du pepper, il ne pourra pas calculer les hashes corrects.

Les bonnes pratiques actuelles recommandent d’utiliser un salt unique par mot de passe et d’appliquer une fonction de dérivation lente et résistante au GPU, comme bcrypt, Argon2 (préférence moderne) ou PBKDF2 configuré avec suffisamment d’itérations. Le pepper peut être ajouté si vous êtes en mesure de le stocker de façon sécurisée en dehors de la base de données.

Fonctions adaptées aux mots de passe : bcrypt, Argon2, PBKDF2

Les fonctions de hachage génériques comme MD5 ou SHA-256 sont trop rapides pour protéger efficacement des mots de passe. Elles permettent à un attaquant de tester des millions, voire des milliards, de candidats par seconde sur du matériel GPU. Pour pallier cela, on utilise des fonctions conçues pour être lentes et coûteuses en ressources, ce qui ralentit considérablement une attaque par force brute.

bcrypt est une fonction éprouvée qui intègre un paramètre de coût (work factor) ajustable. Argon2, lauréat du concours Password Hashing Competition, offre une résistance supérieure au GPU et permet de régler à la fois le temps, la mémoire et le parallélisme. PBKDF2 reste utilisable mais n’est pas aussi adaptée que Argon2 à la menace GPU moderne.

Voici un exemple en PHP pour hacher correctement un mot de passe avec bcrypt :

<?php
$mot = 'MonMotDePasseSecurise!';
$hash = password_hash($mot, PASSWORD_BCRYPT);
echo $hash;

Et pour vérifier un mot de passe :

<?php
if (password_verify($motSaisi, $hashEnBase)) {
    // Authentification réussie
} else {
    // Échec
}

Pour Argon2 en PHP (disponible si votre version de PHP le supporte) :

<?php
$hash = password_hash($mot, PASSWORD_ARGON2ID);

En Python, vous pouvez utiliser la bibliothèque argon2-cffi :

from argon2 import PasswordHasher

ph = PasswordHasher(time_cost=2, memory_cost=102400, parallelism=8)
hash = ph.hash("MonMotDePasseSecurise!")
# Vérification
try:
    ph.verify(hash, "MonMotDePasseSecurise!")
    print("OK")
except:
    print("Non")

Les paramètres (time_cost, memory_cost, parallelism) déterminent la lenteur et l’usage mémoire et doivent être choisis selon vos ressources et le niveau de sécurité souhaité. L’objectif est d’atteindre un compromis où l’authentification reste acceptable pour l’utilisateur mais où une attaque par force brute devient coûteuse pour l’adversaire.

Migration d’une base de mots de passe existante vers Argon2 / bcrypt

Il est fréquent de devoir migrer une base qui stocke des hashes MD5 ou SHA-1 vers une fonction sûre. Une stratégie non intrusive consiste à re-hasher lors de la prochaine connexion d’un utilisateur. Concrètement, lorsque l’utilisateur s’authentifie avec succès (en comparant son mot de passe haché selon l’ancien algorithme), vous calculez le nouvel hash sécurisé et remplacez l’ancien en base. Ainsi la migration se fait progressivement, sans forcer tous les utilisateurs à changer de mot de passe en même temps.

Voici un pseudo-flot :

1. Récupérer le hash existant et le type (ex : md5).
2. Vérifier le mot de passe saisi en appliquant l’ancien algorithme.
3. Si succès, calculer un nouveau hash avec bcrypt/Argon2 et le stocker.
4. Mettre à jour le champ indiquant la méthode de hachage, si nécessaire.

Si vous stockez un pepper, vérifiez aussi que le code qui effectue la vérification a accès à la valeur secrète.

Exemples concrets de attaques et lenteurs

Pour bien comprendre l’effet d’une fonction lente : imaginez qu’un attaquant puisse tester 1 000 000 de MD5 par seconde sur un GPU. Avec un mot de passe de 8 caractères alphanumériques, le nombre de combinaisons possibles est astronomique, mais un grand nombre d’attaques se concentrent sur des mots plus courts ou issus de listes de mots courants. Si vous passez à bcrypt avec un facteur de travail qui réduit la vitesse à 100 vérifications par seconde, le temps requis par l’attaquant explose, rendant l’attaque impraticable.

Argon2, configuré pour utiliser une grande quantité de mémoire et plusieurs passes, inflige une pénalité encore plus lourde au GPU, car les attaques parallèles deviennent limitées par l’accès mémoire.

Tests pratiques en laboratoire (éthique)

Si vous souhaitez pratiquer ces techniques, créez toujours un environnement contrôlé et légal : une machine virtuelle sur votre poste, des comptes factices et des hashes que vous possédez. N’utilisez jamais ces techniques sur des systèmes tiers sans autorisation écrite. Les CTF et environnements comme TryHackMe ou HackTheBox proposent des laboratoires légitimes pour apprendre.

Pour tester Hashcat localement, préparez un fichier hashes.txt avec quelques exemples MD5 et lancez une attaque par dictionnaire. Sur GPU, rappelez-vous de surveiller la température et la consommation électrique, et de respecter les limites matérielles.

Défenses complémentaires : politiques, UX et authentification

La sécurité des mots de passe n’est pas seulement technique ; elle englobe également l’expérience utilisateur et les politiques internes. Instaurer l’obligation d’un mot de passe de longueur minimale et encourager l’usage d’un gestionnaire de mots de passe génèrent une forte amélioration de sécurité. Exiger une longueur trop courte ou des règles uniquement basées sur la complexité (majuscule, caractère spécial) tend à produire des mots de passe difficiles à mémoriser mais peu différents (les utilisateurs ajoutent souvent “1!” à la fin), ce qui n’aide pas.

La mise en place de la double authentification (2FA) — via OTP (applications comme Google Authenticator), SMS (moins recommandé) ou clés matériel WebAuthn — réduit dramatiquement l’impact d’un mot de passe compromis. Enfin, la limitation du taux de tentatives (rate-limiting), le blocage temporaire après plusieurs tentatives échouées, et la surveillance des anomalies (connexion depuis pays inhabituels, IP suspectes) sont des couches de défense indispensables.

Monitoring, alertes et rotation

Mettre en place un système d’alertes en cas de fuite de données (par exemple si un dump contenant des emails et hashes est publié) permet d’agir rapidement : forcer la réinitialisation des mots de passe, informer les utilisateurs, et révoquer les sessions actives. La rotation régulière des secrets (pepper) et la mise à jour des paramètres de coût des fonctions de hachage (augmentez le work factor quand votre infrastructure le permet) renforcent la résilience.

Aspects légaux et éthiques

La pratique du cracking de hash se situe sur une ligne sensible. En tant que chercheur ou administrateur, tester la sécurité de vos systèmes est légitime et souhaitable, à condition d’avoir l’autorisation explicite des propriétaires des systèmes. Tenter de cracker des mots de passe sans consentement est illégal et puni par la loi. La recherche en sécurité doit toujours respecter des règles d’éthique : informer, obtenir l’accord, divulguer les failles de façon responsable, et aider à corriger les vulnérabilités.

Exemples pratiques supplémentaires : script de vérification et migration en PHP

Pour clore la partie technique, voici un script PHP simple qui illustre la vérification d’un mot de passe et la migration progressive vers Argon2ID. Il illustre le concept sans être un composant complet de production (pensez à gérer les erreurs, logs et la sécurité des entrées).

<?php
// $userFromDb contient : id, hash, alg (ex: 'md5' ou 'argon2id')

function verify_and_migrate($userFromDb, $passwordSaisi) {
    $alg = $userFromDb['alg'];
    $hashEnBase = $userFromDb['hash'];

    if ($alg === 'md5') {
        // Vérifier l'ancien hash
        if (md5($passwordSaisi) === $hashEnBase) {
            // Auth ok : migrer vers Argon2
            $nouveauHash = password_hash($passwordSaisi, PASSWORD_ARGON2ID);
            // Mettre à jour en base : nouveau hash + alg = 'argon2id'
            // UPDATE users SET hash = $nouveauHash, alg = 'argon2id' WHERE id = ...
            return true;
        } else {
            return false;
        }
    } else {
        // Alg commun : utiliser password_verify qui gère bcrypt/argon2 automatiquement
        if (password_verify($passwordSaisi, $hashEnBase)) {
            // Optionnel : vérifier si le hash doit être rehashé (augmentation du coût)
            if (password_needs_rehash($hashEnBase, PASSWORD_ARGON2ID)) {
                $nouveauHash = password_hash($passwordSaisi, PASSWORD_ARGON2ID);
                // Mettre à jour en base
            }
            return true;
        } else {
            return false;
        }
    }
}

Cette méthode est pratique : elle évite de forcer l’ensemble des utilisateurs à changer de mot de passe simultanément et diminue graduellement la part des algorithmes faibles.

Penser proactivement la sécurité des mots de passe

Retrouver un mot de passe à partir d’un hash peut sembler être un tour de magie inversée, mais il s’agit surtout d’un jeu d’équilibre entre la force du mot de passe choisi, la qualité du stockage et les techniques dont dispose l’attaquant. Si un mot de passe simple peut être retrouvé en quelques secondes grâce à un dictionnaire ou des outils comme Hashcat, la combinaison d’un salt unique, d’une fonction de dérivation lente (Argon2 ou bcrypt), d’un pepper correctement stocké, d’une politique d’authentification robuste et de la 2FA rend toute tentative de compromission beaucoup moins rentable pour un attaquant.

Apprendre ces techniques du point de vue du défenseur vous permettra d’anticiper ce que peut chercher un adversaire et d’implémenter des mesures concrètes pour protéger vos utilisateurs. Pratiquez toujours dans un cadre légal et contrôlé, testez vos choix de paramètres en laboratoire, et considérez la sécurité des mots de passe comme un processus évolutif, pas comme une solution ponctuelle.

Challenge : Mettez-vous à l’épreuve

Pour mettre en pratique ce que vous venez d’apprendre, voici un petit exercice que vous pouvez réaliser chez vous, dans un environnement contrôlé. Les réponses peuvent m’être envoyées sur Twitter : @creatroyes.

Cet exercice propose trois niveaux de difficulté et des indices pour vous guider. Rappelez-vous que ces exercices sont uniquement à des fins d’apprentissage : ne tentez jamais de casser des mots de passe sur des systèmes ou des comptes qui ne vous appartiennent pas.

Exercice 1 — niveau facile (MD5)
Voici un hash MD5 à retrouver. Il s’agit d’un cas simple et volontairement trivial pour débuter :

482c811da5d5b4bc6d497ffa98491e38

Indice : ce mot de passe est très courant et se compose d’un mot suivi de trois chiffres. Vous pouvez essayer un petit dictionnaire ou le script PHP/Python présenté plus bas.

Exercice 2 — niveau intermédiaire (SHA-1)
Voici un hash SHA-1 à retrouver :

60d38442aec41c7ba05d681f53825ba549a68bb0

Indice : le mot de passe est court et contient des lettres et des chiffres, il a été choisi pour tester une recherche par dictionnaire étendue ou une attaque par force contrôlée.

Exercice 3 — niveau avancé (SHA-256 avec salt fourni)
Pour ce troisième défi, on ajoute un salt. Le salt est : SALT2025
Le hash SHA-256 (calculé sur la concaténation salt + mot de passe) est :

d0ed96bfe53d347c0f611577a694a2efe5ee2634fb357243f8668f87b035aa23

Indice : le mot de passe est un mot anglais simple en minuscules. Comme le salt est fourni, vous pouvez l’utiliser directement dans vos scripts pour reconstituer et tester les candidats.

Exemples de scripts pour commencer (à exécuter localement)

Exemple en PHP : attaque par dictionnaire (utilisez un fichier dico.txt contenant des candidats, un mot par ligne)

<?php
$hash_md5 = "482c811da5d5b4bc6d497ffa98491e38";
$hash_sha1 = "60d38442aec41c7ba05d681f53825ba549a68bb0";
$salt = "SALT2025";
$hash_salted_sha256 = "d0ed96bfe53d347c0f611577a694a2efe5ee2634fb357243f8668f87b035aa23";

$dico = fopen("dico.txt", "r");
if (!$dico) { die("Impossible d'ouvrir dico.txt\n"); }

while (($ligne = fgets($dico)) !== false) {
    $mot = trim($ligne);
    if (md5($mot) === $hash_md5) {
        echo "Exo1 trouvé (MD5) : $mot\n";
    }
    if (sha1($mot) === $hash_sha1) {
        echo "Exo2 trouvé (SHA1) : $mot\n";
    }
    if (hash('sha256', $salt . $mot) === $hash_salted_sha256) {
        echo "Exo3 trouvé (salted SHA256) : $mot\n";
    }
}
fclose($dico);

Exemple en Python : génération par force brute (petite démonstration pour mots très courts — attention au temps de calcul)

import hashlib
from itertools import product
import string

hash_md5 = "482c811da5d5b4bc6d497ffa98491e38"
hash_sha1 = "60d38442aec41c7ba05d681f53825ba549a68bb0"
salt = "SALT2025"
hash_salted_sha256 = "d0ed96bfe53d347c0f611577a694a2efe5ee2634fb357243f8668f87b035aa23"

# Exemple : brute force sur des mots de longueur 1 à 6 composés de lettres minuscules
alphabet = string.ascii_lowercase + string.digits

for length in range(1, 7):
    for tup in product(alphabet, repeat=length):
        candidate = ''.join(tup)
        if hashlib.md5(candidate.encode()).hexdigest() == hash_md5:
            print("Exo1 trouvé (MD5) :", candidate)
        if hashlib.sha1(candidate.encode()).hexdigest() == hash_sha1:
            print("Exo2 trouvé (SHA1) :", candidate)
        if hashlib.sha256((salt + candidate).encode()).hexdigest() == hash_salted_sha256:
            print("Exo3 trouvé (salted SHA256) :", candidate)

Conseils pratiques pour aborder l’exercice :
Commencez par une attaque par dictionnaire avec des listes de mots courants (rockyou.txt ou dicos plus petits pour débuter). Si aucun résultat, adaptez des règles simples (ajout de chiffres, substitutions classiques) ou réduisez le champ de recherche pour la force brute en ciblant d’abord des longueurs courtes. Pour l’exercice 3, n’oubliez pas d’ajouter le salt exactement dans le bon ordre (ici salt + mot de passe). Surveillez le temps d’exécution et testez sur des mots courts avant d’élargir.

Envoyez vos réponses sur Twitter
Quand vous avez trouvé les mots correspondants, envoyez-les sur Twitter en message public ou en DM vers le compte @creatroyes. Si vous préférez un retour privé pour vérifier vos résultats avant publication, précisez-le dans votre message.

Rappel éthique et légal.
Ces exercices visent l’apprentissage et la sensibilisation à la sécurité. N’utilisez jamais ces techniques sur des systèmes dont vous n’avez pas la permission explicite. Entraînez-vous uniquement sur vos propres fichiers ou dans des environnements dédiés.

Amusez-vous bien avec ce petit challenge !

Alban

Fondateur de l’agence Créa-troyes.
Intervenant en Freelance.
Contactez-moi

crea-troyes.fr