Kako zgostite gesla in uporabljate modul crypto?

Question

Accepted Answer

Vgrajeni modul **`crypto`** v Node.js omogoča kriptografske funkcije: zgostitev, šifriranje, naključne vrednosti in HMAC. Najpomembnejša praktična uporaba — **zgostitev gesel** — ima kritično pravilo: nikoli ne uporabljajte hitvih, splošnih zgostil (MD5/SHA-256) za gesla.

## Zgostitev gesel: uporabite POČASNEGA, s soljo obdelanega 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`** (ali bcrypt/argon2) je *namenoma počasen* za odpornost na nasilno iskanje; **edinstven sol za vsako geslo** preprečuje napad z mavričnimi tabelami; in **`timingSafeEqual`** primerjava zgostil v konstantnem času, da preprečuje napade s časovanjem.

## Zakaj NE MD5/SHA-256 za gesla

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

Hitri zgostili so v redu za preverjanje integritete datotek, vendar katastrofalni za gesla — njihova hitrost je ravno to, kar jih naredi napadljivih za nasilno iskanje. (V praksi so knjižnice, kot sta **bcrypt** ali **argon2**, običajno bolj priljubljene od surovega scrypta za ergonomijo.)

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

## Zakaj je to važno

Pravilen odgovor pri shranjevanju gesel je kritična odgovornost varnosti in je pogosta, nevarna napaka uporaba hitrih zgostil ali preskakovanje solitve.

Modul `crypto` (ali kriptografske knjižnice na višji ravni, kot sta bcrypt/argon2) zagotavlja pravilne osnovne gradnike: počasna soljeno zgostitev za gesla, primerjavo v konstantnem času, varno naključno generiranje za žetone in HMAC za preverjanje integritete (na primer podpis webhookov).

Razumevanje *zakaj* gesla potrebujejo počasno, soljeno, primerjavo v konstantnem času — in da so hitri zgostili namenjeni samo ne-skritim preverjem integritete — je bistveno za razvoj avtentifikacije, ki ne izpostavlja uporabnikov kraji poverilnic.