Jak haszujesz hasła i używasz modułu crypto?

Question

Accepted Answer

Wbudowany moduł **`crypto`** Node'a dostarcza funkcji kryptograficznych: haszowanie, szyfrowanie, wartości losowe i HMAC. Najważniejsze praktyczne zastosowanie — **haszowanie haseł** — ma krytyczną regułę: nigdy nie używaj szybkich, ogólnego przeznaczenia haszów (MD5/SHA-256) do haseł.

## Haszowanie haseł: używaj WOLNEGO, słonego algorytmu

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

Klucze: **`scrypt`** (lub bcrypt/argon2) jest *celowo powolny*, aby opierać się atakowi brute-force; **unikatowy sól dla każdego hasła** pokonuje rainbow tables; a **`timingSafeEqual`** porównuje hasze w stałym czasie, aby zapobiec atakom czasowym.

## Dlaczego NIE MD5/SHA-256 do haseł

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

Szybkie hasze są w porządku dla sum kontrolnych plików, ale katastrofalne dla haseł — ich szybkość to dokładnie to, co czyni je podatnymi na brute-force. (W praktyce biblioteki takie jak **bcrypt** lub **argon2** są powszechnie preferowane zamiast surowego scrypt dla ergonomii.)

## Inne zastosowania crypto

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

## Dlaczego to ważne

Prawidłowe przechowywanie haseł to krytyczna odpowiedzialność za bezpieczeństwo i to powszechny, niebezpieczny błąd — używanie szybkich haszów lub pomijanie solenia.

Moduł `crypto` (lub wyższy poziom bcrypt/argon2) dostarcza prawidłowych prymitywów: wolne, słone haszowanie dla haseł, porównanie w stałym czasie, bezpieczne generowanie losowych danych dla tokenów i HMAC do weryfikacji integralności (jak podpisy webhooków).

Zrozumienie *dlaczego* hasła potrzebują wolnego, słonego, stałoczasowego przetwarzania — i że szybkie hasze są tylko dla nietajnych sum kontrolnych — jest niezbędne do budowania uwierzytelniania, które nie narażają użytkowników na kradzież poświadczeń.