Hur hashar man lösenord och använder crypto-modulen?

Question

Accepted Answer

Nodes inbyggda **`crypto`**-modul tillhandahåller kryptografiska funktioner: hashing, kryptering, slumpmässiga värden och HMAC. Den viktigaste praktiska användningen — **lösenordshashing** — har en kritisk regel: använd aldrig snabba, allmänna hash-algoritmer (MD5/SHA-256) för lösenord.

## Lösenordshashing: använd en LÅNGSAM, saltad algoritm

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

Viktiga punkter: **`scrypt`** (eller bcrypt/argon2) är *avsiktligt långsam* för att motstå brute-force-attacker; ett **unikt salt per lösenord** förhindrar rainbow tables; och **`timingSafeEqual`** jämför hash-värden på konstant tid för att förhindra timing-attacker.

## Varför INTE MD5/SHA-256 för lösenord

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

Snabba hash-funktioner är lämpliga för filkontrollsummor men katastrofala för lösenord — deras hastighet är exakt det som gör dem brutalt forcerbara. (I praktiken föredras ofta bibliotek som **bcrypt** eller **argon2** framför raw scrypt för ergonomins skull.)

## Andra kryptobaserade användningar

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

## Varför det är viktigt

Att lösa lösenordslagring på rätt sätt är ett kritiskt säkerhetsbeslut, och det är ett vanligt, farligt misstag att använda snabba hash-funktioner eller hoppa över salting.

`crypto`-modulen (eller högre nivå bcrypt/argon2) tillhandahåller de korrekta primitiverna: långsam saltad hashing för lösenord, jämförelse på konstant tid, säker slumpmässig generering för tokens och HMAC för att verifiera integritet (som webhook-signaturer).

Att förstå *varför* lösenord behöver långsam, saltad, konstant-tid-hantering — och att snabba hash-funktioner endast är för icke-hemliga kontrollsummor — är väsentligt för att bygga autentisering som inte exponerar användare för lösenordsstöld.