Cum faci hashing la parole și cum folosești modulul crypto?

Question

Accepted Answer

Modulul **`crypto`** încorporat al Node.js oferă funcții criptografice: hashing, criptare, valori aleatoare și HMAC. Cea mai importantă utilizare practică — **hashing-ul parolelor** — are o regulă critică: nu folosi niciodată hash-uri rapide și generice (MD5/SHA-256) pentru parole.

## Hashing-ul parolelor: folosește un algoritm LENT, cu salt

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

Puncte cheie: **`scrypt`** (sau bcrypt/argon2) este *deliberat lent* pentru a rezista la atacuri brute-force; un **salt unic pentru fiecare parolă** anulează tabelele rainbow; și **`timingSafeEqual`** compară hash-urile în timp constant pentru a preveni atacurile de timing.

## De ce NU MD5/SHA-256 pentru parole

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

Hash-urile rapide sunt în regulă pentru checksumuri de fișiere, dar catastrofale pentru parole — viteza lor este exact ceea ce le face ușor de forțat. (În practică, biblioteci precum **bcrypt** sau **argon2** sunt frecvent preferate în locul scrypt-ului brut pentru ergonomie.)

## Alte utilizări ale 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");
```

## De ce contează

Stocarea corectă a parolelor este o responsabilitate critică de securitate și este o greșeală comună și periculoasă să folosești hash-uri rapide sau să omiti salt-ul.

Modulul `crypto` (sau bcrypt/argon2 de nivel superior) oferă primitivele corecte: hashing lent și cu salt pentru parole, comparare în timp constant, generare sigură de numere aleatoare pentru tokenuri și HMAC pentru verificarea integrității (cum ar fi semnăturile webhook-urilor).

Înțelegerea *motivului pentru care* parolele au nevoie de manipulare lentă, cu salt și în timp constant — și că hash-urile rapide sunt doar pentru checksumuri non-secrete — este esențială pentru construirea unei autentificări care nu expune utilizatorii la furtul de acreditări.