Kif tixnin passwords u tuża l-modul crypto?

Question

Accepted Answer

Il-modul **`crypto`** integrat ta' Node jipprovdi funzjonalità kriptografika: hashing, encryption, valuri random, u HMAC. L-iktar importanti użu pratiku — **password hashing** — għandu regola kritika: qatt m'għandekx tuża hashes veloċi, użu ġenerali (MD5/SHA-256) għal passwords.

## Password hashing: uża algoritmu MBAXX, saltat

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

Punti ċentrali: **`scrypt`** (jew bcrypt/argon2) hija *intenzjonalment mbaxx* biex tirrezisti brute-force; **sabta unika għal kull password** tħallib rainbow tables; u **`timingSafeEqual`** tqabbel hashes f'ħin kostanti biex tipprevjeni timing attacks.

## Għaliex LE MD5/SHA-256 għal passwords

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

Hashes veloċi huma tajbin għal checksums tal-files imma katastrofiċi għal passwords — il-veloċità tagħhom hija preċiżament dak li jagħmluhom brute-forceable. (Fil-prattika, libreriji bħal **bcrypt** jew **argon2** ġeneralment jippreferixxu fuq scrypt pur għal ergonomics.)

## Użi crypto oħra

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

## Għaliex hu importanti

Obtenjenza tal-password storage korretta hija responsabilità kritiċa ta' sigurtà, u hu żball komuni u perikolus li tuża hashes veloċi jew teskludu s-saltjar.

Il-modul `crypto` (jew bcrypt/argon2 ta' livell ogħla) jipprovdi l-primitivi korretti: hashing mbaxx saltat għal passwords, qabbil ta' ħin kostanti, ġenerazzjoni random sigura għal tokens, u HMAC biex tivverifika l-integrità (bħal webhook signatures).

L-għarfien *għaliex* passwords jeħtieġu tħaddim mbaxx, saltat, ħin kostanti — u li hashes veloċi huma biss għal checksums mhux-sigri — hu essenzjali biex tibni autentifikazzjoni li ma tesponix l-utenti għat-theft tal-credentials.