Hogyan hash jelszavakat és hogyan használja a crypto modult?

Question

Accepted Answer

A Node beépített **`crypto`** modulja kriptográfiai funkciókat biztosít: hashing, titkosítás, véletlen értékek és HMAC. A legfontosabb gyakorlati felhasználás — **jelszó hashing** — kritikus szabályot tartalmaz: soha ne használjon gyors, általános célú hash-eket (MD5/SHA-256) jelszavakhoz.

## Jelszó hashing: használjon LASSÚ, sós algoritmust

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

Fontosabb pontok: a **`scrypt`** (vagy bcrypt/argon2) *szándékosan lassú* a brute-force elleni ellenálláshoz; az **egyedi só jelszónként** legyőzi a szivárvány táblákat; és a **`timingSafeEqual`** konstans időben hasonlítja össze a hash-eket az időzítési támadások megelőzéséhez.

## Miért NE MD5/SHA-256 jelszavakhoz

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

A gyors hash-ek rendben vannak a fájl-ellenőrzéshez, de katasztrofálisak a jelszavakhoz — a sebességük az, ami brute-force-ozható. (A gyakorlatban az olyan könyvtárak, mint a **bcrypt** vagy az **argon2**, általában az ergonómia miatt előnyösebbek, mint a nyers scrypt.)

## Egyéb kriptográfiai felhasználások

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

## Miért fontos ez

A jelszó helyes tárolása kritikus biztonsági felelősség, és gyakori, veszélyes hiba a gyors hash-ek használata vagy a sózás kihagyása.

A `crypto` modul (vagy magasabb szintű bcrypt/argon2) biztosítja a helyes primitíveket: lassú sós hashing jelszavakhoz, konstans idejű összehasonlítás, biztonságos véletlen generáció tokeneknél és HMAC az integritás ellenőrzéséhez (például webhook aláírások).

A megértése, hogy *miért* szükséges a jelszavaknak lassú, sós, konstans idejű kezelés — és hogy a gyors hash-ek csak nem titkos ellenőrzésekhez szükségesek — elengedhetetlen az olyan autentifikáció felépítéséhez, amely nem teszi ki a felhasználókat a hitelesítő adatok ellopásának.