Hvordan hasher du passord og bruker crypto-modulen?

Question

Accepted Answer

Node's innebygde **`crypto`**-modul tilbyr kryptografiske funksjoner: hashing, kryptering, tilfeldige verdier og HMAC. Den viktigste praktiske bruken — **passord-hashing** — har en kritisk regel: aldri bruk raske, generelle hashes (MD5/SHA-256) for passord.

## Passord-hashing: bruk en SLØ, saltilgoritmе

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

Hovedpunkter: **`scrypt`** (eller bcrypt/argon2) er *bevisst treg* for å motstå brute-force-angrep; en **unik salt per passord** besegrer rainbow tables; og **`timingSafeEqual`** sammenligner hashes på konstant tid for å forhindre timing-angrep.

## Hvorfor IKKE MD5/SHA-256 for passord

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

Raske hashes er fine for filsjekksum, men katastrofale for passord — deres hastighet er nøyaktig det som gjør dem sårbare for brute-force. (I praksis foretrekkes biblioteker som **bcrypt** eller **argon2** ofte fremfor rå scrypt for brukervennlighet.)

## Andre crypto-bruksområder

```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 viktig

Å få passord-lagring riktig er et kritisk sikkerhetskjøp, og det er en vanlig, farlig feil å bruke raske hashes eller hoppe over salting.

`crypto`-modulen (eller høyere-nivå bcrypt/argon2) tilbyr de rette primitivene: treg saltildet hashing for passord, konstant-tid-sammenligning, sikker tilfeldig generering for tokens, og HMAC for verifisering av integritet (som webhook-signaturer).

Å forstå *hvorfor* passord trenger treg, saltet, konstant-tid-håndtering — og at raske hashes bare er for ikke-hemmelighetsfulle sjekksum — er essensielt for å bygge autentisering som ikke eksponerer brukere for tyveri av legitimasjon.