Hvordan hasher du adgangskoder og bruger crypto-modulet?

Question

Accepted Answer

Nodes indbyggede **`crypto`**-modul leverer kryptografiske funktioner: hashing, kryptering, tilfældige værdier og HMAC. Den vigtigste praktiske brug — **adgangskodhashing** — har en kritisk regel: brug aldrig hurtige, generelle hashes (MD5/SHA-256) til adgangskoder.

## Adgangskodhashing: brug en LANGSOM, saltet 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)
}
```

Nøglepunkter: **`scrypt`** (eller bcrypt/argon2) er *bevidst langsom* for at modstå brute-force; et **unikt salt pr. adgangskode** besejrer rainbow tables; og **`timingSafeEqual`** sammenligner hashes på konstant tid for at forhindre timing-angreb.

## Hvorfor IKKE MD5/SHA-256 til adgangskoder

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

Hurtige hashes er fine til filkontrolsummer, men katastrofale for adgangskoder — deres hastighed er præcis det, der gør dem brute-forceable. (I praksis foretrækkes biblioteker som **bcrypt** eller **argon2** ofte frem for raw scrypt for brugervenlighed.)

## Anden crypto-brug

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

## Hvorfor det er vigtig

At få adgangskodelager rigtigt er et kritisk sikkerhedsansvar, og det er en almindelig, farlig fejl at bruge hurtige hashes eller springe saltering over.

`crypto`-modulet (eller højere-niveau bcrypt/argon2) leverer de rigtige primitiver: langsom saltet hashing til adgangskoder, konstant-tid sammenligning, sikker tilfældig generering til tokens, og HMAC til at verificere integritet (som webhook-signaturer).

At forstå *hvorfor* adgangskoder har brug for langsom, saltet, konstant-tid håndtering — og at hurtige hashes kun er til ikke-hemmelige kontrolsummer — er væsentligt for at bygge godkendelse, der ikke udsætter brugere for legitimationstyv.