crypto

node:crypto proporciona hashing, HMAC, bytes aleatorios y cifrados para tokens, verificación de webhooks y cifrado. Usa las APIs integradas antes de añadir wrappers de criptografía de npm.

Receta

import { createHmac, randomBytes, timingSafeEqual, randomUUID } from 'node:crypto';
 
const token = randomBytes(32).toString('base64url');
const id = randomUUID();
 
const sig = createHmac('sha256', secret).update(body).digest('hex');

Cuándo usarlo:

• Firmar webhooks de Stripe/Twilio
• Generar tokens de sesión y secretos CSRF
• Hashing de contraseñas (prefiere scrypt/argon2 a través de crypto o una librería dedicada)
• Operaciones de certificados TLS fuera del alcance - usa la plataforma/KMS para las claves

Ejemplo funcional

import { createHmac, randomBytes, scrypt, timingSafeEqual } from 'node:crypto';
import { promisify } from 'node:util';
 
const scryptAsync = promisify(scrypt);
 
export function signPayload(body: Buffer, secret: string): string {
  return createHmac('sha256', secret).update(body).digest('hex');
}
 
export function verifySignature(body: Buffer, secret: string, providedHex: string): boolean {
  const expected = Buffer.from(signPayload(body, secret), 'hex');
  const provided = Buffer.from(providedHex, 'hex');
  if (expected.length !== provided.length) return false;
  return timingSafeEqual(expected, provided);
}
 
export async function hashPassword(password: string, salt?: Buffer): Promise<{ salt: Buffer; hash: Buffer }> {
  const s = salt ?? randomBytes(16);
  const hash = (await scryptAsync(password, s, 64)) as Buffer;
  return { salt: s, hash };
}

import { webcrypto } from 'node:crypto';
 
const key = await webcrypto.subtle.generateKey(
  { name: 'AES-GCM', length: 256 },
  true,
  ['encrypt', 'decrypt'],
);

Lo que esto demuestra:

• Patrón HMAC-SHA256 para webhooks - compara con timingSafeEqual en los digests
• scrypt a través de promisify para el almacenamiento de contraseñas con sal por usuario
• Web Crypto subtle para AES-GCM al interoperar con la criptografía del navegador
• Nunca registres secretos o firmas completas en los errores

Inmersión profunda

Cómo funciona

• Hash (sha256) - huella digital unidireccional - no solo para contraseñas.
• HMAC - hash con clave para la integridad + autenticidad del mensaje.
• CSPRNG - randomBytes, randomUUID para tokens.
• scrypt/pbkdf2 - estiramiento de contraseñas - ajusta los parámetros de costo con la línea base del hardware.

Elección del algoritmo

Notas de TypeScript

import { createHash } from 'node:crypto';
 
export function sha256Hex(input: string): string {
  return createHash('sha256').update(input, 'utf8').digest('hex');
}

Errores comunes

• SHA256 solo para contraseñas - demasiado rápido - fuerza bruta. Solución: scrypt/argon2 con sal.
• Comparación de tiempo en cadenas con === - fuga. Solución: compara los digests HMAC con timingSafeEqual.
• IV/nonce reutilizado en AES-GCM - fallo criptográfico catastrófico. Solución: nonce aleatorio de 12 bytes por mensaje.
• Secretos codificados en el código fuente - fuga a través del repositorio. Solución: env/KMS + rotación.
• Math.random para tokens - predecible. Solución: solo randomBytes.

Alternativas

Preguntas frecuentes

Relacionado

• Seguridad de los búferes - manejo de secretos
• Verificación de Webhook - webhooks HMAC
• Conceptos básicos de seguridad - postura más amplia
• Contaminación de prototipos - no es criptografía, pero es un vecino de seguridad

Versiones de la pila: Esta página fue escrita para Node.js 24.18.0 (LTS activa), npm 10+, TypeScript 5.6+, Express 5, Fastify 5 y NestJS 11.