Come si esegue l'hash delle password e si usa il modulo crypto?

Question

Accepted Answer

Il modulo **`crypto`** integrato di Node fornisce funzioni crittografiche: hashing, crittografia, valori casuali e HMAC. L'uso pratico più importante — **password hashing** — ha una regola critica: non usare mai hash veloci e generici (MD5/SHA-256) per le password.

## Password hashing: usare un algoritmo LENTO e salato

```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 chiave: **`scrypt`** (o bcrypt/argon2) è *deliberatamente lento* per resistere al brute-force; un **salt unico per password** sconfigge le tabelle arcobaleno; e **`timingSafeEqual`** confronta gli hash in tempo costante per prevenire attacchi di timing.

## Perché NON MD5/SHA-256 per le password

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

Gli hash veloci vanno bene per i checksum dei file ma sono catastrofici per le password — la loro velocità è esattamente quello che le rende attaccabili con forza bruta. (In pratica, librerie come **bcrypt** o **argon2** sono comunemente preferite a scrypt puro per questioni ergonomiche.)

## Altri usi di 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");
```

## Perché è importante

Archiviare correttamente le password è una responsabilità di sicurezza critica, ed è un errore comune e pericoloso usare hash veloci o saltare l'aggiunta di salt.

Il modulo `crypto` (o bcrypt/argon2 di livello superiore) fornisce le primitive corrette: hashing lento e salato per le password, confronto in tempo costante, generazione casuale sicura per i token e HMAC per verificare l'integrità (come le firme dei webhook).

Capire *perché* le password richiedono una gestione lenta, salata e a tempo costante — e che gli hash veloci sono solo per checksum non segreti — è essenziale per costruire un'autenticazione che non espone gli utenti al furto di credenziali.