crypto

O módulo node:crypto fornece APIs de hashing, HMAC, bytes aleatórios e cifras para tokens, verificação de webhook e criptografia - use as APIs integradas antes de adicionar wrappers de criptografia npm.

Receita

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');

Quando usar:

• Assinar webhooks do Stripe/Twilio
• Gerar tokens de sessão e segredos CSRF
• Hashing de senhas (prefira scrypt/argon2 via crypto ou biblioteca dedicada)
• Operações de certificado TLS fora do escopo - use plataforma/KMS para chaves

Exemplo de Trabalho

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'],
);

O que isso demonstra:

• Padrão HMAC-SHA256 para webhooks - compare com timingSafeEqual nos digests
• scrypt via promisify para armazenamento de senhas com salt por usuário
• Web Crypto subtle para AES-GCM ao interoperar com criptografia do navegador
• Nunca registre segredos ou assinaturas completas em erros

Mergulho Profundo

Como Funciona

• Hash (sha256) - impressão digital unidirecional - não apenas para senhas.
• HMAC - hash com chave para integridade + autenticidade da mensagem.
• CSPRNG - randomBytes, randomUUID para tokens.
• scrypt/pbkdf2 - alongamento de senha - ajuste os parâmetros de custo com base de hardware.

Escolha do Algoritmo

Notas de TypeScript

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

Armadilhas

• SHA256 sozinho para senhas - muito rápido - força bruta. Correção: scrypt/argon2 com salt.
• Comparação de tempo com === - vazamento. Correção: compare digests HMAC com timingSafeEqual.
• IV/nonce reutilizado em AES-GCM - falha criptográfica catastrófica. Correção: nonce aleatório de 12 bytes por mensagem.
• Segredos codificados na origem - vazamento via repositório. Correção: env/KMS + rotação.
• Math.random para tokens - previsível. Correção: apenas randomBytes.

Alternativas

FAQs

Relacionados

• Segurança de Buffer - manuseio de segredos
• Verificação de Webhook - webhooks HMAC
• Noções Básicas de Segurança - postura mais ampla
• Poluição de Protótipo - não é criptografia, mas vizinho de segurança

Versões do Stack: Esta página foi escrita para Node.js 24.18.0 (Active LTS), npm 10+, TypeScript 5.6+, Express 5, Fastify 5 e NestJS 11.