Cómo utilizar Javascript para cifrado de datos y comunicación segura

Bibliotecas de terceros como CryptoJS], libsodium.js], y La forja puede complementar las API nativas, pero los desarrolladores deben preferir las implementaciones nativas siempre que sea posible para evitar algoritmos mal implementados o deprecatados.

Algoritmos de cifrado comunes en JavaScript

AES (Norma de cifrado avanzado)

AES es el cifrado simétrico de facto utilizado en todo el mundo. Funciona en bloques de 128 bits y soporta tamaños clave de 128, 192, o 256 bits. Los modos más comunes para JavaScript son:

• AES‐GCM (Modo Galois/Counter) — proporciona encriptación autenticada; encripta y produce una etiqueta de autenticación que detecta manipulación. Recomendado para la mayoría de los casos de uso.
• AES‐CBC (Cipher Block Chaining) requiere un vector de inicialización (IV) y un relleno. No proporciona integridad por sí mismo, por lo que debe combinarse con HMAC o utilizarse en un protocolo que agrega autenticación.

Ejemplo utilizando la API de Crypto Web (browser) para cifrar con 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 es un algoritmo asimétrico utilizado comúnmente para el intercambio clave y las firmas digitales. En JavaScript, está disponible a través de la API de Crypto Web (browser) y el módulo Node.js . RSA‐OAEP (Optimal Asymmetric Encryption Padding) es el esquema de cifrado recomendado, ya que incluye el relleno aleatorio para proteger contra ataques de texto escogidos.

RSA es mucho más lento que el cifrado simétrico y está limitado en el tamaño de los datos que puede cifrar (proporcional al tamaño de la clave). En la práctica, RSA se utiliza para cifrar una clave AES (encriptación de hisopo), y luego AES cifra la carga útil real.

SHA‐256 / SHA‐3 (Secure Hash Algorithms)

Los algoritmos de esquizo no son cifrados, pero son indispensables para una comunicación segura. SHA‐256 es el hash más utilizado en la seguridad web moderna (por ejemplo, para certificados TLS, HMAC y contraseña de escotilla con sal). La API de Crypto Web proporciona para ataques SHA‐1, SHA‐256, SHA‐384, y SHA‐512.

Criptografía de curvas elípticas (ECC)

ECC ofrece seguridad equivalente a RSA con claves mucho más cortas, lo que lo hace ideal para aplicaciones móviles y de alto rendimiento. La API de Crypto Web admite ECDH (Elliptic Curve Diffie‐Hellman) para un acuerdo clave y ECDSA (Elliptic Curve Digital Signature Algorithm) para la firma. El módulo Node.js también admite estas curvas (25.g.

Implementación de Encriptación en JavaScript: Una Guía Práctica

A continuación se muestran ejemplos completos, copy‐and‐paste para el navegador y Node.js. Siempre prefiere el módulo Web Crypto API o Node.js sobre bibliotecas de terceros cuando sea posible, ya que son auditados y realizan operaciones criptográficas en la memoria segura del sistema.

Navegador: Cifrado simétrico con 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 con el módulo 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));

Prácticas óptimas de comunicación seguras

La cifrado no garantiza la comunicación segura. Las siguientes prácticas deben integrarse en todo el flujo de datos:

1. Use siempre HTTPS con TLS 1.2 o Superior

HTTPS no es opcional. Encripta toda la conversación HTTP, evitando los ataques de escucha y man-in-the-middle. Configure su servidor para usar TLS 1.2 o TLS 1.3 y deshabilitar las suites de cifrado débiles.

2. Implementar una gestión adecuada de las claves

• Nunca claves de código duro en el código del lado cliente. Utilice variables de entorno o bóvedas seguras (por ejemplo, HashiCorp Vault, AWS Secrets Manager) en el servidor.
• Rotar las teclas regularmente e inmediatamente revocar las claves comprometidas.
• Utilizar funciones clave de derivación (PBKDF2, scrypt, Argon2) para el cifrado basado en contraseña. La API de Crypto Web y Node.js ambos soportan PBKDF2.
• Al intercambiar llaves, utilice un protocolo de acuerdo clave seguro como ECDH o RSA‐OAEP, y combine con un paso clave de confirmación.

3. Autenticación y Autorización

4. Proteger contra los ataques web comunes

• Cross‐Site Scripting (XSS)] – Los atacantes pueden inyectar scripts que roban datos o claves cifrados. Use encabezados de la Política de Seguridad de Contenidos, escape de entrada de usuario, y nunca confíe .
• Protección de la Solicitud de Cross‐Site (CSRF)] – Use tokens anti-CSRF o cookies de SameSite para evitar solicitudes falsificadas.
• Señalización] – Poner el encabezado a o .
• Man‐in‐the‐Middle – Forzar HSTS (HTTP Strict Transport Security) y considerar la fijación de certificados para aplicaciones de alta seguridad.

5. Validar todas las entradas y utilizar comparaciones de tiempo constante

Al comparar HMACs, etiquetas de autenticación o contraseñas, siempre utilice una función de comparación de tiempo constante para prevenir ataques de tiempo. Node.js proporciona ; para el navegador, puede implementar una comparación de tiempo constante o utilizar una biblioteca como .

Temas avanzados: Firmas digitales, cifrado híbrido y fijación de certificados

Firmas digitales

Las firmas digitales proporcionan no-repudiación y prueban la autenticidad de un mensaje. Usa ECDSA (con curva P‐256) o RSA‐PSS. En el navegador, el Web Crypto API soporta y ] operaciones. Ejemplo snippet (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
);

Encriptación híbrida para grandes cargas

El cifrado asimétrico no puede manejar datos grandes de manera eficiente. El enfoque estándar es el cifrado híbrido:

1. Generar una tecla simétrica aleatoria (por ejemplo, 256 bits AES).
2. Cifrar la tecla simétrica con la clave RSA pública del receptor (RSA‐OAEP).
3. Cifrar el mensaje real con AES‐GCM utilizando la tecla simétrica.
4. Transmite tanto la clave simétrica cifrada como el criptotexto (con la etiqueta IV y auth).

El receptor descifra la clave simétrica con su clave privada, y luego descifra el mensaje con AES‐GCM.

Certificado de Pinning

Para protegerse aún más contra las autoridades certificadoras comprometidas, puede fijar el certificado de servidor esperado o su hash de clave pública. Esto se puede hacer utilizando el encabezado (dependido pero todavía utilizado en algunos contextos) o a través del encabezado (Transparencia Certificado). La práctica moderna favorece la transparencia de certificados y certificados de corta duración sobre el pinning duro.

Pitfalls comunes y cómo evitarlos

• Usando una IV débil o nonce – La IV debe ser aleatoria y única para cada operación de cifrado con la misma clave. Reutilizar una IV con AES‐GCM o AES‐CTR rompe completamente la seguridad.
• Implementar la criptografía personalizada – Nunca escriba su propio algoritmo de cifrado. Utilice implementaciones estándar, bien captadas desde la plataforma o bibliotecas de confianza.
• Calificación de claves en cookies o almacenamiento local] – Almacenamiento de navegadores es accesible a JavaScript y por lo tanto a ataques XSS. Para cifrado de lado cliente, considere el uso de la API de Crypto para generar claves que nunca se exponen a memoria JavaScript.
• Omitiendo autenticación] – Cifrar sin una etiqueta de autenticación (por ejemplo, usando AES‐CBC sin HMAC) permite a los atacantes modificar el cifertexto sin ser detectado.
• Ignorar los ataques de canal lateral – En entornos de alta seguridad, tenga conciencia de los ataques de tiempo, caché y análisis de potencia. Las operaciones de tiempo constante y la filiación mínima ayudan a mitigar estos riesgos.

Conclusión

JavaScript es totalmente capaz de implementar una encriptación robusta y asegurar la comunicación cuando se utiliza correctamente. El módulo Web Crypto API y Node.js proporciona funciones criptográficas de grado de producción, plataforma que siguen los estándares de la industria. Combinando la encriptación simétrica y asimétrica con mejores prácticas como HTTPS, la gestión correcta de claves, comparaciones de tiempo constante y validación de entradas