Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
NestJS

Hacher les mots de passe avec bcrypt

Cette leçon explique comment stocker un mot de passe sans jamais pouvoir le relire. Elle compare le stockage en clair, un hachage rapide (SHA-256) qui donne toujours la même empreinte, et bcrypt, conç...

0 chapitres 0 QCM Accès gratuit
Hacher les mots de passe avec bcrypt

À propos de ce cours

Cette leçon explique comment stocker un mot de passe sans jamais pouvoir le relire. Elle compare le stockage en clair, un hachage rapide (SHA-256) qui donne toujours la même empreinte, et bcrypt, conçu pour les mots de passe. L'exécution montre deux hachages bcrypt différents du même mot de passe grâce au sel, la vérification avec compare, la structure du hachage, les durées réelles selon le coût comparées à SHA-256, et une limite peu connue : bcrypt n'utilise que les 72 premiers octets. Elle évoque Argon2 et les règles de robustesse. Activités corrigées.

Objectifs de la leçon

  • Expliquer pourquoi un mot de passe ne doit jamais être stocké en clair ni chiffré.
  • Comprendre le rôle du sel et du coût.
  • Hacher et vérifier un mot de passe avec bcrypt.
  • Connaître la limite des 72 octets.
Le principe

Si la base de données fuit (sauvegarde perdue, injection SQL, ancien employé), les mots de passe ne doivent pas être récupérables : beaucoup de personnes réutilisent le même mot de passe sur plusieurs sites. On ne stocke donc ni le mot de passe, ni une version chiffrée (qu'on pourrait déchiffrer avec la clé), mais une empreinte obtenue par une fonction de hachage à sens unique. À la connexion, on hache le mot de passe saisi et on compare les empreintes.

Stocker un mot de passe avec bcrypt

Un hachage bcrypt contient l'algorithme, le coût, le sel et l'empreinte.

L'exécution
npm install bcrypt
npm install -D @types/bcrypt

📄 src/essai-bcrypt.ts

import * as bcrypt from 'bcrypt';
import { createHash } from 'node:crypto';

async function main() {
  const motDePasse = 'Formation2026!';

  // 1. Pourquoi pas un simple hachage (SHA-256) ?
  const sha = (t: string) => createHash('sha256').update(t).digest('hex');
  console.log('SHA-256 (1) :', sha(motDePasse));
  console.log('SHA-256 (2) :', sha(motDePasse), '← identique : même mot de passe = même empreinte');

  // 2. bcrypt : un sel aléatoire différent à chaque fois
  const h1 = await bcrypt.hash(motDePasse, 10);
  const h2 = await bcrypt.hash(motDePasse, 10);
  console.log('\nbcrypt (1) :', h1);
  console.log('bcrypt (2) :', h2, '← différent');
  console.log('Format : $2b$ = algorithme | 10$ = coût | 22 caractères de sel | 31 caractères de hachage');

  // 3. Vérifier : compare() relit le sel et le coût dans le hachage
  console.log('\ncompare(bon, h1)      :', await bcrypt.compare(motDePasse, h1));
  console.log('compare(bon, h2)      :', await bcrypt.compare(motDePasse, h2));
  console.log('compare(mauvais, h1)  :', await bcrypt.compare('formation2026!', h1));

  // 4. Le coût : chaque +1 double le temps de calcul (c'est voulu)
  for (const cout of [8, 10, 12, 13]) {
    const debut = performance.now();
    await bcrypt.hash(motDePasse, cout);
    console.log(`coût ${cout} : ${Math.round(performance.now() - debut)} ms`);
  }
  const debut = performance.now();
  for (let i = 0; i < 100000; i++) sha(motDePasse + i);
  console.log(`comparaison : 100 000 SHA-256 en ${Math.round(performance.now() - debut)} ms`);

  // 5. Limite : bcrypt n'utilise que les 72 premiers octets
  const long = 'a'.repeat(72);
  const hLong = await bcrypt.hash(long + 'FIN-1', 10);
  console.log('\n72 octets + "FIN-1" haché, comparé à 72 octets + "FIN-2" :', await bcrypt.compare(long + 'FIN-2', hLong));
}
main();

Résultat réellement obtenu :

SHA-256 (1) : 271c46651486747ca49408327fdae3591e950ede917acd4fca5e02f3a608a9c9
SHA-256 (2) : 271c46651486747ca49408327fdae3591e950ede917acd4fca5e02f3a608a9c9 ← identique : même mot de passe = même empreinte

bcrypt (1) : $2b$10$oLf1l.738x7TPR55.ipU1.2jeTnO2VEW/bnYxYGmZZI9D4GFtt8NC
bcrypt (2) : $2b$10$VaQ1sOaxh1QSzhhhJSVueu8qV68iLLfAqRFEcWE0i70wyq8HDzhJ6 ← différent
Format : $2b$ = algorithme | 10$ = coût | 22 caractères de sel | 31 caractères de hachage

compare(bon, h1)      : true
compare(bon, h2)      : true
compare(mauvais, h1)  : false
coût 8 : 18 ms
coût 10 : 70 ms
coût 12 : 294 ms
coût 13 : 600 ms
comparaison : 100 000 SHA-256 en 94 ms

72 octets + "FIN-1" haché, comparé à 72 octets + "FIN-2" : true
Lecture
  1. SHA-256 donne toujours la même empreinte pour le même mot de passe : deux utilisateurs qui ont « Formation2026! » ont la même empreinte, et un attaquant peut utiliser des tables précalculées (rainbow tables). De plus, il est très rapide: 100 000 calculs en moins de 100 ms. Un attaquant qui possède la base peut essayer des milliards de mots de passe.
  2. bcrypt ajoute un sel aléatoire différent à chaque hachage : deux empreintes différentes pour le même mot de passe. Le sel est stocké dans le hachage, ce qui permet à compare() de refaire le calcul.
  3. compare() renvoie true pour le bon mot de passe avec chacun des deux hachages, et false pour un mauvais mot de passe.
  4. Le coût: chaque +1 double le temps (18 ms au coût 8, 70 ms au coût 10, 294 ms au coût 12, 600 ms au coût 13 sur la machine de test). Une connexion qui prend 75 ms est imperceptible pour un utilisateur, mais ralentit énormément une attaque par force brute. Le coût 10 est la valeur courante ; 12 si le serveur le permet.
  5. Limite des 72 octets: au-delà, bcrypt ignore la fin : la dernière ligne montre que deux chaînes qui ne diffèrent qu'après le 72e octet sont considérées comme identiques. Pour un mot de passe humain, ce n'est pas un problème réel ; mais il ne faut pas utiliser bcrypt pour des chaînes longues comme les jetons (démonstration à la leçon 13.8).

Toujours utiliser les versions asynchrones (hash, compare) dans une API : hashSync bloque le serveur Node.js pendant tout le calcul, et donc toutes les autres requêtes. Et ne comparez jamais deux hachages avec ===: utilisez compare(), qui relit le sel et le coût.

Et Argon2 ?

Argon2 (paquet argon2), vainqueur du concours Password Hashing Competition, est aujourd'hui recommandé par l'OWASP en premier choix : il consomme aussi de la mémoire, ce qui rend les attaques par cartes graphiques plus coûteuses, et n'a pas la limite des 72 octets. bcrypt reste très répandu et sûr avec un coût suffisant. L'utilisation est presque identique : argon2.hash(mdp), argon2.verify(hachage, mdp).

Des mots de passe robustes
  • Imposer une longueur minimale (8 caractères au moins, 12 c'est mieux) plutôt que des règles compliquées.
  • Refuser les mots de passe les plus courants (« 12345678 », « azertyui »).
  • Limiter le nombre de tentatives de connexion (chapitre 19, @nestjs/throttler).
  • Ne jamais renvoyer le hachage dans une réponse, ni l'écrire dans les journaux.
Activités

Activité 1 Choisir le coût

Sur votre machine, mesurez la durée de bcrypt.hash pour les coûts 10 à 14. Quel coût choisiriez-vous si la connexion doit rester sous 250 ms ? Que se passera-t-il pour les comptes existants si vous augmentez le coût plus tard ?

Voir le corrigé

Choisissez le coût le plus élevé qui reste sous la limite (souvent 11 ou 12). Les anciens hachages restent valides : le coût est inscrit dans chaque hachage, compare() l'utilise. On peut les « remonter » progressivement : à la connexion réussie, si le coût du hachage stocké (lisible avec bcrypt.getRounds(hachage)) est inférieur au coût actuel, on re-hache le mot de passe saisi et on met à jour la base.

Activité 2 Pourquoi pas chiffrer ?

Un collègue propose de chiffrer les mots de passe avec AES et une clé stockée dans .env, « pour pouvoir les renvoyer aux utilisateurs qui les oublient ». Donnez deux raisons de refuser.

Voir le corrigé

(1) Si la base et le .env fuient ensemble (même serveur), tous les mots de passe sont lisibles. (2) Envoyer un mot de passe par e-mail l'expose ; et un administrateur ne doit jamais pouvoir lire les mots de passe des utilisateurs. La bonne pratique pour un oubli : un lien de réinitialisation à usage unique et à durée limitée (chapitre 15, e-mails).

Activité 3 Une fonction utilitaire

Écrivez un service MotsDePasseService avec hacher(mdp) et verifier(mdp, hachage), le coût venant de la configuration (BCRYPT_COUT, 10 par défaut). Pourquoi un service plutôt que des appels directs à bcrypt partout ?

Voir le corrigé
@Injectable()
export class MotsDePasseService {
  private readonly cout: number;
  constructor(config: ConfigService) {
    this.cout = Number(config.get('BCRYPT_COUT', 10));
  }
  hacher(motDePasse: string) {
    return bcrypt.hash(motDePasse, this.cout);
  }
  verifier(motDePasse: string, hachage: string) {
    return bcrypt.compare(motDePasse, hachage);
  }
}

Un seul endroit à modifier pour changer de coût ou passer à Argon2, et des tests plus rapides : on fournit un faux service avec useValue (leçon 7.4) au lieu d'attendre 75 ms par hachage.

Activité 4 Lire un hachage

Décomposez $2b$12$R9h/cIPz0gi.URNNX3kh2OPST9/PgBkqquzi.Ss7KIUgO2t0jWMUW: algorithme, coût, sel, empreinte. Combien de tours de calcul représente ce coût ?

Voir le corrigé

Algorithme 2b (bcrypt), coût 12, sel R9h/cIPz0gi.URNNX3kh2O (22 caractères), empreinte PST9/PgBkqquzi.Ss7KIUgO2t0jWMUW (31 caractères). Coût 12 = 212 = 4 096 itérations de l'algorithme interne, quatre fois plus que le coût 10.

À retenir

  • Jamais de mot de passe en clair ni chiffré : une empreinte avec une fonction lente et salée.
  • bcrypt.hash(mdp, coût) → 60 caractères à stocker ; bcrypt.compare(saisi, hachage) pour vérifier.
  • Sel aléatoire : deux hachages différents pour le même mot de passe ; le coût double le temps à chaque +1.
  • SHA-256 est trop rapide et sans sel pour des mots de passe.
  • bcrypt ignore tout ce qui dépasse 72 octets ; Argon2 est l'alternative moderne.

Cet article vous a-t-il aidé ?