Kako hashirate lozinke i koristite crypto modul?

Question

Accepted Answer

Node-ov ugrađeni **`crypto`** modul pruža kriptografske funkcije: heširanje, enkripcija, nasumične vrijednosti i HMAC. Najvažnije praktično korištenje — **heširanja lozinke** — ima kritično pravilo: nikada ne koristite brze, opće heševe (MD5/SHA-256) za lozinke.

## Heširanja lozinke: koristite SPORA, slana algoritma

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

Ključne točke: **`scrypt`** (ili bcrypt/argon2) je *namjerno spor* kako bi se odupro brute-force; **jedinstvena sol po lozinci** pobijeđuje duginih tablica; i **`timingSafeEqual`** uspoređuje heširane u stalnom vremenu kako bi se spriječili napadi na vrijeme.

## Zašto NE MD5/SHA-256 za lozinke

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

Brzi heševi su u redu za kontrolne sume datoteka, ali katastrofalni za lozinke — njihova brzina je upravo ono što ih čini brute-forsceablima. (U praksi, biblioteke poput **bcrypt** ili **argon2** obično se više vole od sirova scrypt zbog ergonomije.)

## Ostala korištenja 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");
```

## Zašto je to važno

Ispravo pohranjivanje lozinke je kritična odgovornost sigurnosti, a to je česta i opasna greška koristiti brze heške ili preskakati soljenje.

`crypto` modul (ili viši bcrypt/argon2) daje ispravne primitivke: spora slana heširanja za lozinke, usporedbe u stalnom vremenu, sigurnu nasumičnu generaciju za tokene i HMAC za provjeru cjelovitosti (kao što su webhook potpisi).

Razumijevanje *zašto* lozinke trebaju spora, slana, stalna vrijeme rukovanja — i da su brzi heševi samo za ne-tajne kontrolne sume — neophodno je za gradnju autentifikacije koja ne izlaže korisnike krađi kredencijala.