Si i dhashin passwords-et dhe si përdorni modulin crypto?

Question

Accepted Answer

Moduli **`crypto`** i ndërtuar në Node ofron funksione kriptografike: hashing, enkriptim, vlera të rastësishme dhe HMAC. Përdorimi më i rëndësishëm praktik — **password hashing** — ka një rregull kritik: asnjëherë mos përdorni hash të shpejta, për qëllime të përgjithshme (MD5/SHA-256) për passwords.

## Dhasja e passwords: përdorni një algoritëm të NGADALË, me 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)
}
```

Pika kyçe: **`scrypt`** (ose bcrypt/argon2) është *qëllimisht i ngadalë* për të rezistuar ndaj brute-force; një **salt unik për secilin password** dëshmohet ndaj tabelave të ylberit; dhe **`timingSafeEqual`** krahason hashet në kohë konstante për të parandaluar sulme të kohës.

## Pse JO MD5/SHA-256 për passwords

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

Hash të shpejta janë të mira për checksums e skedarëve por katastrofale për passwords — shpejtësia e tyre është pikërisht ajo që i bën ata të prekshmë ndaj brute-force. (Në praktikë, biblioteka si **bcrypt** ose **argon2** përforcohen zakonisht mbi scrypt të pastër për ergonomikë.)

## Përdorime të tjera të 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");
```

## Pse ka rëndësi

Që të arrihet ruajtja e duhur e passwords është një përgjegjësi kritike e sigurisë, dhe është një gabim i zakonshëm dhe i rrezikshëm të përdorni hash të shpejta ose të kaloni përmes saltimit.

Moduli `crypto` (ose bcrypt/argon2 më i lartë) ofron primitivat e duhur: dhasje të ngadalë, të salluar, me krahasim të kohës konstante për passwords, gjenerimin e sigurt të rastësisë për tokens, dhe HMAC për verifikimin e integritetit (si firmat e webhook).

Përkuptimi *pse* passwords kanë nevojë për trajtim të ngadalë, të salluar, me kohë konstante — dhe që hash të shpejta janë vetëm për checksums jo-sekret — është thelbësor për ndërtimin e autentifikimit që nuk e expozoj përdoruesit ndaj vjedhjes së kredencialit.