Como você faz hash de senhas e usa o módulo crypto?

Question

Accepted Answer

O módulo **`crypto`** integrado do Node fornece funções criptográficas: hashing, encriptação, valores aleatórios e HMAC. O uso prático mais importante — **hash de senhas** — tem uma regra crítica: nunca use hashes rápidos e de propósito geral (MD5/SHA-256) para senhas.

## Use um algoritmo LENTO e com 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)
}
```

Pontos-chave: **`scrypt`** (ou bcrypt/argon2) é *deliberadamente lento* para resistir à força bruta; um **salt único por senha** derrota tabelas arco-íris; e **`timingSafeEqual`** compara hashes em tempo constante para prevenir ataques de timing.

## Por que NÃO usar MD5/SHA-256 para senhas

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

Hashes rápidos são adequados para checksums de arquivo mas catastróficos para senhas — sua velocidade é exatamente o que as torna vulneráveis à força bruta. (Na prática, bibliotecas como **bcrypt** ou **argon2** são comumente preferidas ao scrypt bruto por ergonomia.)

## Outros usos do 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");
```

## Por que isso importa

Obter o armazenamento de senhas correto é uma responsabilidade crítica de segurança, e é um erro comum e perigoso usar hashes rápidos ou pular o salt.

O módulo `crypto` (ou bcrypt/argon2 de nível superior) fornece as primitivas corretas: hashing lento com salt para senhas, comparação em tempo constante, geração aleatória segura para tokens e HMAC para verificar integridade (como assinaturas de webhook).

Compreender *por que* senhas precisam de manipulação lenta, com salt e em tempo constante — e que hashes rápidos são apenas para checksums não-secretos — é essencial para construir autenticação que não exponha usuários ao roubo de credenciais.