Table of Contents
As aplicações web modernas lidam com vastas quantidades de dados sensíveis – identificadores pessoais, transações financeiras, registros de saúde e informações de negócios proprietárias. Sem criptografia adequada, esses dados são vulneráveis à interceptação, modificação e roubo durante a transmissão.O JavaScript, há muito tempo confinado a interações baseadas em navegadores, agora oferece ferramentas maduras e prontas para a produção para implementar criptografia forte e proteger canais de comunicação.Este guia fornece uma ampla e prática abordagem do uso do JavaScript para criptografia de dados e comunicação segura, abrangendo algoritmos, bibliotecas, padrões de implementação e melhores práticas de segurança.
Compreender os Fundamentos de Encriptação de Dados
A criptografia é o processo de transformar o texto simples legível em um texto cifrado ilegível usando um algoritmo e uma chave secreta. Somente as partes autorizadas que possuem a chave de descriptografia correta podem reverter a transformação e recuperar os dados originais. A força de um sistema de criptografia depende das propriedades matemáticas do algoritmo, do comprimento e da aleatoriedade da chave e da segurança das práticas de gerenciamento de chaves.
A criptografia distingue entre duas categorias amplas de criptografia:
- Centragem simétrica — usa uma única chave compartilhada para criptografia e descriptografia. É rápida e eficiente para dados em massa, mas a chave deve ser trocada com segurança entre as partes. Exemplos: AES, ChaCha20.
- Cryptografia assimétrica — usa um par de chaves público-privadas. A chave pública criptografa dados; apenas a chave privada correspondente pode descriptografá-lo. Isto elimina a necessidade de um segredo compartilhado, mas é computacionalmente mais lento. Exemplos: RSA, ECC (Cryptography de Curva Elíptica).
Além disso, tem[] (por exemplo, SHA-256) é uma função unidirecional que produz um digest de tamanho fixo a partir de dados de entrada. Não é criptografia (não pode invertê-lo), mas é essencial para verificações de integridade, armazenamento de senhas e assinaturas digitais. HMAC[ (Código de Autenticação de Mensagem baseado em Hash) combina uma chave secreta com uma hash para verificar a integridade e autenticidade dos dados.
Criptografia no Navegador vs. Node.js
O JavaScript é executado em dois ambientes primários: o navegador e o Node.js (lado servidor). Cada ambiente fornece diferentes interfaces nativas:
- ]Browser — O Web Crypto API é a interface padrão, criptograficamente sonora. Ele suporta AES-CBC, AES-GCM, RSA-OAEP, ECDH, e muitas outras operações. A API foi projetada para ser segura por padrão, usando o provedor criptográfico nativo do sistema em vez de algoritmos implementados com JavaScript.
- Node.js — O módulo de criptografia incorporado oferece um amplo conjunto de funções criptográficas, incluindo primitivos de baixo nível e classes de alto nível como , , , e . Ele suporta cifras de fluxos, HKDF e PBKDF2 para derivação de chaves.
Bibliotecas de terceiros como CryptoJS, libsodium.js[, e Forge[ podem complementar APIs nativas, mas os desenvolvedores devem preferir implementações nativas sempre que possível para evitar algoritmos mal implementados ou desactualizados.
Algoritmos de criptografia comuns no JavaScript
AES (Padrão de Criptografia Avançada)
AES é a cifra simétrica de facto utilizada em todo o mundo. Opera em blocos de 128 bits e suporta tamanhos-chave de 128, 192, ou 256 bits. Os modos mais comuns para JavaScript são:
- AES-GCM (Modo Galois/Counter) — fornece criptografia autenticada; criptografa e produz uma etiqueta de autenticação que detecta adulteração. Recomendado para a maioria dos casos de uso.
- AES-CBC (Cipher Block Chaining) — requer um vetor de inicialização (IV) e enchimento. Não fornece integridade por si só, portanto deve ser combinado com HMAC ou usado em um protocolo que adiciona autenticação.
Exemplo usando a API Web Crypto (browser) para criptografar com AES-GCM:
async function encryptAESGCM(data, key) {
const iv = crypto.getRandomValues(new Uint8Array(12));
const encoded = new TextEncoder().encode(data);
const encrypted = await crypto.subtle.encrypt(
{ name: 'AES-GCM', iv },
key,
encoded
);
return { iv, ciphertext: new Uint8Array(encrypted) };
}
// Generate a 256‑bit AES key
const key = await crypto.subtle.generateKey(
{ name: 'AES-GCM', length: 256 },
true,
['encrypt', 'decrypt']
);RSA (Rivest–Shamir–Adleman)
RSA é um algoritmo assimétrico comumente usado para troca de chaves e assinaturas digitais. No JavaScript, ele está disponível através da API Web Crypto (browser) e do módulo Node.js . RSA-OAEP (Optimal Assimétrico Encriptação Padding) é o esquema de criptografia recomendado, uma vez que inclui padding aleatório para proteger contra ataques de texto escolhido.
RSA é muito mais lento do que criptografia simétrica e é limitado no tamanho dos dados que pode criptografar (proporcional ao tamanho da chave). Na prática, RSA é usado para criptografar uma chave AES (criptografia híbrida), e então AES criptografa a carga útil real.
SHA-256/Sha-3 (Algoritmos de Hash Seguros)
Os algoritmos de hashing não são encriptação, mas são indispensáveis para uma comunicação segura. O SHA-256 é o hash mais utilizado na segurança da web moderna (por exemplo, para certificados TLS, HMAC e senhas com sal). A API Web Crypto fornece para SHA-1, SHA-256, SHA-384 e SHA-512. Note que o SHA-1 está desprecado devido a ataques de colisão.
Criptografia da curva elíptica (ECC)
O ECC oferece segurança equivalente ao RSA com chaves muito mais curtas, tornando-o ideal para aplicações móveis e de alto desempenho. A Web Crypto API suporta ECDH (Eliptic Curve Diffie-Hellman) para acordo chave e ECDSA (Eliptic Curve Digital Signature Algorithm) para assinatura. O módulo Node.js também suporta estas curvas (p. ex., P-256, P-384).
Implementação de criptografia em JavaScript: Um Guia Prático
Abaixo estão exemplos completos, de copy-and-paste para o navegador e Node.js. Sempre prefira o módulo Web Crypto API ou Node.js sobre bibliotecas de terceiros quando possível, uma vez que são auditados e realizam operações criptográficas na memória segura do sistema.
Navegador: Criptografia Simétrica com AES-GCM (Web Crypto API)
// Encrypt a message with a given password
async function encryptWithPassword(password, plaintext) {
// Derive a key from the password using PBKDF2
const encoder = new TextEncoder();
const salt = crypto.getRandomValues(new Uint8Array(16));
const keyMaterial = await crypto.subtle.importKey(
'raw',
encoder.encode(password),
'PBKDF2',
false,
['deriveKey']
);
const key = await crypto.subtle.deriveKey(
{
name: 'PBKDF2',
salt,
iterations: 600000, // OWASP recommended min
hash: 'SHA-256'
},
keyMaterial,
{ name: 'AES-GCM', length: 256 },
false,
['encrypt']
);
// Encrypt
const iv = crypto.getRandomValues(new Uint8Array(12));
const encrypted = await crypto.subtle.encrypt(
{ name: 'AES-GCM', iv },
key,
encoder.encode(plaintext)
);
// Return salt, iv, ciphertext as base64 for transport
return {
salt: btoa(String.fromCharCode(...salt)),
iv: btoa(String.fromCharCode(...iv)),
ciphertext: btoa(String.fromCharCode(...new Uint8Array(encrypted)))
};
}
// Decrypt
async function decryptWithPassword(password, { salt, iv, ciphertext }) {
const encoder = new TextEncoder();
const decoder = new TextDecoder();
const saltBytes = Uint8Array.from(atob(salt), c => c.charCodeAt(0));
const ivBytes = Uint8Array.from(atob(iv), c => c.charCodeAt(0));
const data = Uint8Array.from(atob(ciphertext), c => c.charCodeAt(0));
const keyMaterial = await crypto.subtle.importKey(
'raw',
encoder.encode(password),
'PBKDF2',
false,
['deriveKey']
);
const key = await crypto.subtle.deriveKey(
{
name: 'PBKDF2',
salt: saltBytes,
iterations: 600000,
hash: 'SHA-256'
},
keyMaterial,
{ name: 'AES-GCM', length: 256 },
false,
['decrypt']
);
const decrypted = await crypto.subtle.decrypt(
{ name: 'AES-GCM', iv: ivBytes },
key,
data
);
return decoder.decode(decrypted);
}Node.js: AES-256-GCM com o Módulo de Cripto
const crypto = require('crypto');
function encrypt(text, key) {
const iv = crypto.randomBytes(12);
const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
let encrypted = cipher.update(text, 'utf8', 'hex');
encrypted += cipher.final('hex');
const authTag = cipher.getAuthTag().toString('hex');
return { iv: iv.toString('hex'), encrypted, authTag };
}
function decrypt(encryptedData, key) {
const decipher = crypto.createDecipheriv(
'aes-256-gcm',
key,
Buffer.from(encryptedData.iv, 'hex')
);
decipher.setAuthTag(Buffer.from(encryptedData.authTag, 'hex'));
let decrypted = decipher.update(encryptedData.encrypted, 'hex', 'utf8');
decrypted += decipher.final('utf8');
return decrypted;
}
// Usage: generate a 256‑bit key
const key = crypto.randomBytes(32);
const message = 'This is secret.';
const ciphertext = encrypt(message, key);
console.log(ciphertext);
console.log('Decrypted:', decrypt(ciphertext, key));Melhores práticas de comunicação seguras
A criptografia por si só não garante uma comunicação segura. As seguintes práticas devem ser integradas em todo o fluxo de dados:
1. Sempre use HTTPS com TLS 1.2 ou Superior
HTTPS não é opcional. Ele criptografa toda a conversa HTTP, evitando escutas e ataques de man- in- the- middle. Configure seu servidor para usar TLS 1.2[ ou TLS 1.3 e desativar suítes de cifra fracas. Serviços como Cloudflare[] fornecem terminação gratuita de TLS e gerenciamento de certificados. Para servidores auto- hospedados, use ferramentas como Vamos criptografar[[] para obter certificados automatizados.
2. Implementar o gerenciamento adequado da chave
- Nunca chaves de código rígido no código do cliente. Use variáveis de ambiente ou cofres seguros (por exemplo, HashiCorp Vault, AWS Secrets Manager) no servidor.
- Rodar as teclas regularmente e imediatamente revogar chaves comprometidas.
- Use funções de derivação de chaves (PBKDF2, script, Argon2) para criptografia baseada em senha. A API Web Crypto e Node.js suportam PBKDF2.
- Ao trocar chaves, use um protocolo de acordo chave seguro, como ECDH ou RSA-OAEP, e combinar com uma etapa chave de confirmação.
3. Autenticação e Autorização
A criptografia protege os dados em trânsito, mas o sistema também deve verificar a identidade. Use autenticação baseada em tokens (JWT, OAuth 2.0) e garanta que os tokens sejam transmitidos apenas através do HTTPS. Para APIs, necessita de um token de acesso válido para cada solicitação e implemente vidas de tokens curtas com tokens de atualização. A WASP Authentication Cheat Sheet fornece orientações abrangentes.
4. Proteja contra ataques comuns na Web
- Cross-Site Scripting (XSS) – Os atacantes podem injetar scripts que roubam dados ou chaves criptografadas. Use cabeçalhos de Política de Segurança de Conteúdo (CSP), escape de entrada do usuário e nunca confie em .
- Cross-Site Solicite falsificação (CSRF) – Use tokens anti-CSRF ou cookies SameSite para evitar pedidos falsificados.
- Sequestro de cliques – Defina o cabeçalho como ou .
- Man-in-the-Middle – Enforce o HSTS (HTTP Strict Transport Security) e considere o certificado que serve para aplicações de alta segurança.
5. Validar todas as entradas e usar comparações de tempo constante
Ao comparar HMACs, etiquetas de autenticação ou senhas, use sempre uma função de comparação constante para evitar ataques de tempo. Node.js fornece ; para o navegador, você pode implementar uma comparação constante de tempo ou usar uma biblioteca como .
Tópicos Avançados: Assinaturas Digitais, Criptografia Híbrida e Arraste o Certificado
Assinaturas digitais
As assinaturas digitais fornecem não-repudiação e comprovam a autenticidade de uma mensagem. Use as operações ECDSA (com curva P-256) ou RSA-PSS. No navegador, a API Web Crypto suporta e . Exemplo de trecho (browser):
// Generate signing key pair
const keyPair = await crypto.subtle.generateKey(
{ name: 'ECDSA', namedCurve: 'P-256' },
true,
['sign', 'verify']
);
// Sign a message
const data = new TextEncoder().encode('Important contract');
const signature = await crypto.subtle.sign(
{ name: 'ECDSA', hash: 'SHA-256' },
keyPair.privateKey,
data
);Criptografia híbrida para grandes cargas
A criptografia assimétrica não pode lidar com dados grandes de forma eficiente. A abordagem padrão é a criptografia híbrida:
- Gerar uma chave simétrica aleatória (por exemplo, 256-bit AES).
- Criptografar a chave simétrica com a chave RSA pública do destinatário (RSA-OAEP).
- Criptografe a mensagem real com AES-GCM usando a chave simétrica.
- Transmita tanto a chave simétrica criptografada quanto o texto cifrado (com etiqueta IV e autenticação).
O destinatário descodifica a chave simétrica com a sua chave privada, depois descodifica a mensagem com AES-GCM.
Marcação do certificado
Para proteger ainda mais contra as autoridades comprometidas do certificado, você pode fixar o certificado do servidor esperado ou seu hash de chave pública. Isto pode ser feito usando o cabeçalho (preparado, mas ainda usado em alguns contextos) ou através do cabeçalho (Transparência de Certificado). A prática moderna favorece a transparência do certificado e certificados de curta duração sobre o suporte rígido.
Pistas comuns e como evitá - las
- Usando um IV ou nonce fraco – O IV deve ser aleatório e único para cada operação de criptografia com a mesma chave.Reusar um IV com AES-GCM ou AES-CTR quebra completamente a segurança.
- Implementar criptografia personalizada – Nunca escreva seu próprio algoritmo de criptografia. Use implementações padrão e bem vetadas da plataforma ou bibliotecas confiáveis.
- Teclas de armazenamento em cookies ou armazenamento local – O armazenamento de navegador é acessível ao JavaScript e, portanto, aos ataques XSS. Para criptografia do lado do cliente, considere usar a API Web Crypto para gerar chaves que nunca estão expostas à memória JavaScript.
- Omitir autenticação – Criptografar sem uma etiqueta de autenticação (por exemplo, usando AES-CBC sem HMAC) permite que os atacantes modifiquem o texto cifrado sem serem detectados.
- Ignorar ataques de canais laterais – Em ambientes de alta segurança, esteja ciente dos ataques de timing, cache e análise de energia. Operações constantes e ramificações mínimas ajudam a atenuar esses riscos.
Conclusão
O JavaScript é totalmente capaz de implementar criptografia robusta e garantir a comunicação quando usado corretamente. A API Web Crypto e o módulo Node.js fornecem funções criptográficas de nível de produção e plataforma nativas que seguem os padrões da indústria. Ao combinar criptografia simétrica e assimétrica com as melhores práticas, como HTTPS, gerenciamento adequado de chaves, comparações constantes e validação de entradas, você pode construir aplicativos web que protegem dados do usuário de múltiplos vetores de ameaça. O cenário de segurança web evolui continuamente – permaneça atual com atualizações da Fundação OWASP] e Vamos criptografar[ comunidade e sempre audite suas implementações de criptografia contra vulnerabilidades conhecidas.