Hoe hash je wachtwoorden en gebruik je de crypto module?

Question

Accepted Answer

Node's ingebouwde **`crypto`** module biedt cryptografische functies: hashing, encryptie, willekeurige waarden en HMAC. Het belangrijkste praktische gebruik — **wachtwoordhashing** — heeft een kritieke regel: gebruik nooit snelle, algemene hash-functies (MD5/SHA-256) voor wachtwoorden.

## Wachtwoordhashing: gebruik een TRAGE, gezoute algoritme

```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)
}
```

Belangrijke punten: **`scrypt`** (of bcrypt/argon2) is *opzettelijk traag* om brute-force aan te weerstaan; een **unieke zout per wachtwoord** verslaat regenboogtabellen; en **`timingSafeEqual`** vergelijkt hashes in constante tijd om timing attacks te voorkomen.

## Waarom NIET MD5/SHA-256 voor wachtwoorden

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

Snelle hashes zijn prima voor bestandscontrolesommen maar rampzalig voor wachtwoorden — hun snelheid is precies wat ze brute-forceable maakt. (In de praktijk hebben bibliotheken zoals **bcrypt** of **argon2** meestal de voorkeur boven zuivere scrypt voor gebruiksgemak.)

## Ander crypto-gebruik

```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");
```

## Waarom het belangrijk is

Het correct opslaan van wachtwoorden is een kritieke beveiligingsverantwoordelijkheid, en het is een veel voorkomende, gevaarlijke fout om snelle hashes te gebruiken of het zouten over te slaan.

De `crypto` module (of hoger-niveau bcrypt/argon2) biedt de juiste primitieven: trage gezoute hashing voor wachtwoorden, vergelijking in constante tijd, veilige willekeurige generatie voor tokens en HMAC voor integriteitsverificatie (zoals webhook-handtekeningen).

Begrijpen *waarom* wachtwoorden trage, gezoute, constante-tijd verwerking nodig hebben — en dat snelle hashes alleen voor niet-geheime controlesommen zijn — is essentieel om authenticatie te bouwen die gebruikers niet blootstelt aan gestolen inloggegevens.