¿Cómo se hashean contraseñas y se usa el módulo crypto?

Question

Accepted Answer

El módulo **`crypto`** integrado de Node proporciona funciones criptográficas: hashing, cifrado, valores aleatorios y HMAC. El uso práctico más importante — el **hashing de contraseñas** — tiene una regla crítica: nunca uses hashes rápidos de propósito general (MD5/SHA-256) para contraseñas.

## Hashing de contraseñas: usa un algoritmo LENTO y con sal

```js
import { scrypt, randomBytes, timingSafeEqual } from "crypto";
import { promisify } from "util";
const scryptAsync = promisify(scrypt);

// HASHEAR una contraseña (al registrarse)
async function hashPassword(password) {
  const salt = randomBytes(16).toString("hex");          // sal aleatoria única por usuario
  const derived = await scryptAsync(password, salt, 64); // derivación lenta, con sal
  return `${salt}:${derived.toString("hex")}`;            // almacena la sal + el hash juntos
}

// VERIFICAR una contraseña (al iniciar sesión)
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); // comparación de tiempo constante (evita ataques de temporización)
}
```

Puntos clave: **`scrypt`** (o bcrypt/argon2) es *deliberadamente lento* para resistir la fuerza bruta; una **sal única por contraseña** vence a las rainbow tables; y **`timingSafeEqual`** compara los hashes en tiempo constante para prevenir ataques de temporización.

## Por qué NO usar MD5/SHA-256 para contraseñas

```js
// ❌ NUNCA hagas esto — SHA/MD5 son RÁPIDOS, así que los atacantes pueden adivinar miles de millones/seg
crypto.createHash("sha256").update(password).digest("hex");
```

Los hashes rápidos están bien para checksums de archivos, pero son catastróficos para las contraseñas — su velocidad es exactamente lo que las hace vulnerables a la fuerza bruta. (En la práctica, bibliotecas como **bcrypt** o **argon2** suelen preferirse sobre scrypt en crudo por ergonomía.)

## Otros usos de crypto

```js
import crypto from "crypto";

crypto.randomBytes(32).toString("hex");        // tokens aleatorios seguros (ids de sesión, CSRF)
crypto.randomUUID();                            // un UUID v4 seguro

// HMAC — verifica la integridad/autenticidad (p. ej. firmas de webhooks)
crypto.createHmac("sha256", secret).update(payload).digest("hex");

// hashing para integridad NO secreta (checksums de archivos) — SHA está bien aquí
crypto.createHash("sha256").update(fileBuffer).digest("hex");
```

## Por qué es importante

Hacer bien el almacenamiento de contraseñas es una responsabilidad de seguridad crítica, y es un error común y peligroso usar hashes rápidos u omitir la sal.

El módulo `crypto` (o bcrypt/argon2 de más alto nivel) proporciona las primitivas correctas: hashing lento y con sal para contraseñas, comparación de tiempo constante, generación aleatoria segura para tokens y HMAC para verificar la integridad (como las firmas de webhooks).

Entender *por qué* las contraseñas necesitan un manejo lento, con sal y de tiempo constante — y que los hashes rápidos son solo para checksums no secretos — es esencial para construir una autenticación que no exponga a los usuarios al robo de credenciales.