Comment hacher les mots de passe et utiliser le module crypto ?

Question

Accepted Answer

Le module **`crypto`** intégré de Node fournit des fonctions cryptographiques : hachage, chiffrement, valeurs aléatoires et HMAC. L'utilisation pratique la plus importante — **hachage des mots de passe** — a une règle critique : n'utilisez jamais des hashes rapides et polyvalents (MD5/SHA-256) pour les mots de passe.

## Hachage des mots de passe : utilisez un algorithme LENT et salé

```js
import { scrypt, randomBytes, timingSafeEqual } from "crypto";
import { promisify } from "util";
const scryptAsync = promisify(scrypt);

// HASH a password (on signup)
async function hashPassword(password) {
  const salt = randomBytes(16).toString("hex");          // unique random salt per user
  const derived = await scryptAsync(password, salt, 64); // slow, salted derivation
  return `${salt}:${derived.toString("hex")}`;            // store salt + hash together
}

// VERIFY a password (on login)
async function verify(password, stored) {
  const [salt, hash] = stored.split(":");
  const derived = await scryptAsync(password, salt, 64);
  const hashBuf = Buffer.from(hash, "hex");
  return timingSafeEqual(hashBuf, derived); // constant-time compare (avoid timing attacks)
}
```

Points clés : **`scrypt`** (ou bcrypt/argon2) est *intentionnellement lent* pour résister aux attaques par force brute ; un **sel unique par mot de passe** neutralise les tables arc-en-ciel ; et **`timingSafeEqual`** compare les hashes en temps constant pour prévenir les attaques temporelles.

## Pourquoi PAS MD5/SHA-256 pour les mots de passe

```js
// ❌ NEVER do this — SHA/MD5 are FAST, so attackers can guess billions/sec
crypto.createHash("sha256").update(password).digest("hex");
```

Les hashes rapides conviennent aux sommes de contrôle de fichiers mais sont catastrophiques pour les mots de passe — leur vitesse est exactement ce qui les rend vulnérables aux attaques par force brute. (En pratique, les bibliothèques comme **bcrypt** ou **argon2** sont généralement préférées au scrypt brut pour l'ergonomie.)

## Autres utilisations crypto

```js
import crypto from "crypto";

crypto.randomBytes(32).toString("hex");        // secure random tokens (session ids, CSRF)
crypto.randomUUID();                            // a secure UUID v4

// HMAC — verify integrity/authenticity (e.g. webhook signatures)
crypto.createHmac("sha256", secret).update(payload).digest("hex");

// hashing for NON-secret integrity (file checksums) — SHA is fine here
crypto.createHash("sha256").update(fileBuffer).digest("hex");
```

## Pourquoi c'est important

Bien faire le stockage des mots de passe est une responsabilité critique en matière de sécurité, et c'est une erreur courante et dangereuse d'utiliser des hashes rapides ou de sauter le salage.

Le module `crypto` (ou bcrypt/argon2 de niveau supérieur) fournit les primitives correctes : hachage lent et salé pour les mots de passe, comparaison en temps constant, génération aléatoire sécurisée pour les jetons et HMAC pour vérifier l'intégrité (comme les signatures webhook).

Comprendre *pourquoi* les mots de passe nécessitent un traitement lent, salé et en temps constant — et que les hashes rapides ne sont que pour les sommes de contrôle non secrètes — est essentiel pour construire une authentification qui n'expose pas les utilisateurs au vol d'identifiants.