Presque tout le monde sait qu'il "ne faut pas stocker les mots de passe en clair" et qu'il faut "hasher avec bcrypt". Le problème n'est presque jamais là. Il est dans les détails d'implémentation autour du hash : le choix du coût, la gestion des migrations d'algorithme, la troncature silencieuse d'entrée, ou la confusion entre hash de mot de passe et hash cryptographique générique. Un bon algorithme mal implémenté protège à peine mieux qu'un mauvais algorithme.

Le problème concret

Une fuite de base de données est un "quand", pas un "si", sur un horizon suffisamment long. La question qui compte vraiment n'est pas "ai-je hashé le mot de passe" mais "si cette table fuit demain, combien de temps et de budget faudrait-il à un attaquant pour retrouver les mots de passe en clair à partir des hashes ?". Avec SHA-256(password), la réponse est : quelques heures sur un GPU grand public, parce que SHA-256 est conçu pour être calculé vite, exactement l'inverse de ce qu'on veut pour un mot de passe.

Pourquoi un hash rapide est le vrai problème

Un hash cryptographique générique (SHA-256, SHA-512) est optimisé pour vérifier l'intégrité de données à grande vitesse. Cette vitesse, qui est une qualité pour une somme de contrôle de fichier, devient une faiblesse pour un mot de passe : un attaquant qui récupère la table de hashes peut tester des milliards de mots de passe candidats par seconde sur du matériel GPU, bien au-delà de ce qu'un humain pourrait deviner manuellement.

bcrypt et argon2 résolvent ce problème en étant délibérément lents et, pour argon2, gourmands en mémoire :

  • bcrypt repose sur l'algorithme Blowfish avec un nombre de rounds configurable (le "cost factor"), ce qui rend le calcul lent de façon ajustable dans le temps à mesure que le matériel progresse.
  • argon2 (vainqueur de la Password Hashing Competition en 2015, recommandé par l'OWASP) ajoute une contrainte mémoire en plus de la contrainte CPU, ce qui rend les attaques par GPU et ASIC spécialisés nettement moins efficaces qu'elles ne le sont contre bcrypt.

Les deux intègrent aussi un sel (salt) aléatoire généré automatiquement par implémentation, ce qui empêche les attaques par table précalculée (rainbow tables) et garantit que deux utilisateurs avec le même mot de passe n'ont jamais le même hash stocké.

Diagnostiquer un système existant

Avant de corriger quoi que ce soit, il faut auditer ce qui est réellement stocké en base :

-- Repérer les hashes suspects : trop courts pour être du bcrypt/argon2,
-- ou sans préfixe d'algorithme reconnaissable
SELECT id, email, LEFT(password_hash, 10), LENGTH(password_hash)
FROM users
WHERE password_hash NOT LIKE '$2y$%'   -- bcrypt
  AND password_hash NOT LIKE '$2b$%'
  AND password_hash NOT LIKE '$argon2%'
LIMIT 50;

Un hash bcrypt commence toujours par $2y$ ou $2b$ suivi du cost factor (ex. $2y$12$...) ; un hash argon2 par $argon2id$v=19$.... Si la table contient des chaînes de 32 ou 64 caractères hexadécimaux sans préfixe, c'est très probablement du MD5 ou du SHA nu : à traiter en priorité absolue.

Le correctif, avec les pièges d'implémentation

Choisir un cost factor réaliste, pas un défaut copié-collé

// Node.js, avec bcrypt
const bcrypt = require('bcrypt');

// Le cost factor doit être calibré sur le matériel de PRODUCTION,
// pas laissé au défaut de la lib. Cible usuelle : ~250ms par hash.
const SALT_ROUNDS = 12;

async function hashPassword(plain) {
  return bcrypt.hash(plain, SALT_ROUNDS);
}

async function verifyPassword(plain, stored) {
  return bcrypt.compare(plain, stored);
}

Un cost factor trop bas (souvent laissé à 10 par habitude) réduit la protection ; trop haut, il dégrade l'expérience de connexion ou sature le CPU sous charge. Le bon réglage se mesure sur l'infrastructure réelle, pas sur machine de développement.

Argon2 : attention aux trois paramètres, pas seulement le temps

const argon2 = require('argon2');

async function hashPassword(plain) {
  return argon2.hash(plain, {
    type: argon2.argon2id, // toujours argon2id, pas argon2i ou argon2d seul
    memoryCost: 19456, // ~19 MiB, recommandation OWASP actuelle
    timeCost: 2,
    parallelism: 1,
  });
}

argon2id est le mode hybride recommandé par l'OWASP pour la plupart des cas (résistant aux attaques par canal auxiliaire ET aux attaques GPU), contrairement à argon2i seul ou argon2d seul qui ne couvrent chacun qu'une partie de la menace. Oublier memoryCost et laisser un défaut trop bas annule une bonne partie de l'avantage d'argon2 sur bcrypt.

La troncature silencieuse de bcrypt

Piège moins connu mais réel : bcrypt tronque silencieusement l'entrée à 72 octets. Un mot de passe de 100 caractères sera hashé comme s'il n'en avait que 72, sans erreur ni avertissement selon l'implémentation. Si l'application accepte des passphrases longues (ce qui est une bonne pratique UX), il faut soit documenter cette limite, soit pré-hasher avec SHA-256 avant bcrypt (uniquement pour contourner la limite de longueur, pas comme substitut à bcrypt), soit migrer vers argon2 qui n'a pas cette contrainte.

Migrer un algorithme legacy sans forcer une réinitialisation de masse

// Laravel : vérifier avec l'algorithme legacy, re-hasher à la volée
public function attempt(string $email, string $plain): bool
{
    $user = User::where('email', $email)->first();
    if (!$user) {
        return false;
    }

    if (str_starts_with($user->password_hash, 'md5:')) {
        // Legacy : vérifie avec l'ancien algo, migre si ça matche
        if (md5($plain) === substr($user->password_hash, 4)) {
            $user->password_hash = Hash::make($plain); // bcrypt par défaut
            $user->save();
            return true;
        }
        return false;
    }

    return Hash::check($plain, $user->password_hash);
}

Cette approche "migrate on login" évite de forcer tous les utilisateurs à réinitialiser leur mot de passe simultanément, ce qui serait à la fois un mauvais signal (panique côté utilisateurs) et un pic de charge support. Elle demande en contrepartie de garder le code de vérification legacy actif pendant la période de transition, avec un suivi du pourcentage de comptes encore non migrés.

Les compromis

  • bcrypt vs argon2 pour un projet neuf : argon2id est le choix recommandé aujourd'hui par l'OWASP, mais bcrypt reste parfaitement acceptable et bénéficie d'un écosystème plus mature dans certains langages/frameworks plus anciens. Le vrai risque n'est pas le choix entre les deux, c'est un cost factor ou des paramètres mémoire mal calibrés, quel que soit l'algorithme.
  • Cost factor élevé vs temps de réponse : un cost factor trop agressif protège mieux contre le brute-force offline mais peut créer un vecteur de déni de service si un attaquant spamme l'endpoint de connexion avec des mots de passe volontairement invalides, faisant tourner le hash coûteux pour rien. Un rate-limiting sur l'endpoint d'authentification reste nécessaire en complément, pas en remplacement.

Quand bcrypt/argon2 seuls ne suffisent plus

Le hashing protège contre la fuite de la base, pas contre un mot de passe faible ou réutilisé ailleurs. Pour une application exposée (comptes utilisateurs avec accès à des données sensibles ou financières), il faut compléter par une vérification contre les bases de mots de passe compromis connus (API type "Have I Been Pwned - Pwned Passwords", interrogée en k-anonymat pour ne jamais envoyer le mot de passe en clair) et, idéalement, par de la MFA. Le hash robuste est une condition nécessaire, pas suffisante, pour la sécurité des comptes.

À retenir

Le choix de l'algorithme (bcrypt ou argon2id) compte moins que sa mise en œuvre : cost factor calibré sur le matériel réel, paramètres mémoire explicites pour argon2, gestion consciente de la limite de 72 octets de bcrypt, et migration progressive plutôt que brutale pour tout legacy MD5/SHA encore présent.