Generador de Hash SHA-384 (Hash Suite B para TLS)

¿Qué es SHA-384?

// Hash text using Web Crypto API (SHA-384)
async function sha384(text) {
  const data = new TextEncoder().encode(text);
  const hash = await crypto.subtle.digest('SHA-384', data);
  return Array.from(new Uint8Array(hash))
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');
}

await sha384('Hello, World!');
// → '5485cc9b3365b4305dfb4e8337e0a598a574f8242bf17289e0dd6c20a3cd44a089de16ab4ab308f63e44b1170eb5f515'

Ejemplos de SHA-384

ECDHE-ECDSA-AES256-GCM-SHA384

master secret || client random || server random

CLASSIFIED//TS//SI//NF — Document ID: TSC-2026-0001

POST /api/v2/transfer
Content-Type: application/json
{"amount":10000,"to":"account-XYZ"}

Cómo generar hashes SHA-384

1. 1

   Pega texto o suelta un archivo

   Selecciona la pestaña Texto y pega cualquier cadena — un ID de documento, cuerpo de solicitud o entrada arbitraria — en el área de entrada. El hash SHA-384 se actualiza mientras escribes. Para archivos, cambia a la pestaña Archivo y arrastra cualquier archivo a la zona de soltar; el navegador lo hashea localmente usando la Web Crypto API sin ninguna subida. Un indicador de progreso aparece para archivos grandes (>10 MB).

2. 2

   Copia el hash de 96 caracteres

   Haz clic en el botón Copiar junto a la salida del hash. La cadena hexadecimal completa de 96 caracteres en minúsculas va a tu portapapeles — lista para pegar en una configuración TLS, informe de conformidad o implementación HMAC. Usa la opción Mayúsculas si tu sistema de destino requiere hexadecimal en mayúsculas.

3. 3

   Compara contra un hash conocido

   Cambia a la pestaña Comparar y pega dos hashes SHA-384 lado a lado. La herramienta informa coincidencia o discrepancia usando comparación en tiempo constante, que no filtra información de temporización. Útil para verificar hashes de conformidad Suite B, comparar claves derivadas HKDF-SHA-384 entre implementaciones o comprobar huellas de documentos en auditorías de archivos clasificados.

Detalles técnicos

Algoritmo: SHA-512 con IV diferente, salida truncada a 384 bits

SHA-384 es estructuralmente idéntico a SHA-512 (FIPS 180-4, sección 6.5). Ambos usan 80 rondas de operaciones de 64 bits (funciones Ch, Maj, Σ0, Σ1) con constantes derivadas de las raíces cúbicas y cuadradas de los primeros 80 primos. El vector de inicialización (ocho palabras de 64 bits) difiere del IV de SHA-512 — el IV de SHA-384 se deriva de las partes fraccionarias de las raíces cuadradas de los primos del 9.º al 16.º. Tras el procesamiento, se emiten las primeras seis palabras de 64 bits de las ocho palabras del estado (384 bits); las dos palabras finales se descartan.

Salida: 384 bits, 96 caracteres hexadecimales

Siempre exactamente 96 caracteres hexadecimales en minúsculas (384 bits = 48 bytes, cada byte codificado como 2 caracteres hex). Longitud fija independientemente del tamaño de la entrada. Los 96 caracteres de longitud son la huella inmediata que distingue SHA-384 de SHA-256 (64 caracteres) y SHA-512 (128 caracteres). Los 128 bits descartados — las dos últimas palabras de 64 bits del estado — son los que hacen a SHA-384 resistente a extensión de longitud.

Rendimiento: idéntico a SHA-512 en hardware de 64 bits

SHA-384 y SHA-512 ejecutan la misma secuencia de instrucciones en CPUs de 64 bits. Ambos usan bloques de entrada de 1024 bits (128 bytes), procesados con rotaciones y sumas de 64 bits. El rendimiento es típicamente 500-900 MB/s en un navegador usando la Web Crypto API (que llama a código C/Rust nativo fuera de la VM de JS), y 1-3 GB/s en herramientas nativas con extensiones SHA de hardware. En hardware de 32 bits o sin aceleración hardware, SHA-384/512 son más lentos que SHA-256 debido a la emulación de enteros de 64 bits.

Estándares: FIPS 180-4, NSA Suite B heredado, CNSA actual

Estandarizado en FIPS 180-2 (2001), versión actual FIPS 180-4 (2015). Requerido por NSA Suite B (CNSSP-15, 2005) para TOP SECRET, todavía presente en CNSA Suite (2015). Especificado para TLS en RFC 5246 (PRF de TLS 1.2 con suites de cifrado SHA-384), RFC 8446 (algoritmo de firma TLS 1.3 ecdsa_secp384r1_sha384) y RFC 5869 (HKDF). Aprobado por el NIST para todos los niveles de seguridad hasta 2030 y más allá según NIST SP 800-131A Rev 2.

Buenas prácticas

Usa SHA-384 cuando la inmunidad a extensión de longitud importa sin HMAC

Si tu protocolo expone la salida hash pura y un atacante podría intentar extender el mensaje (por ejemplo, en ciertos esquemas de URL firmadas o desafío-respuesta), SHA-384 proporciona inmunidad inherente a extensión de longitud que SHA-256 no tiene. Para todos los demás usos con clave, aplica HMAC independientemente del hash subyacente — HMAC-SHA-256 y HMAC-SHA-384 son ambos seguros, y HMAC elimina los ataques de extensión de longitud para cualquier variante SHA-2.

Combina con AES-256-GCM para conformidad Suite B / CNSA

Si estás construyendo un sistema que debe cumplir con los requisitos NSA Suite B o CNSA, el emparejamiento canónico es AES-256-GCM para cifrado masivo y SHA-384 para integridad y derivación de claves. TLS 1.2 con ECDHE-ECDSA-AES256-GCM-SHA384 es la suite de cifrado de referencia. Para TLS 1.3, el equivalente es TLS_AES_256_GCM_SHA384 con ecdsa_secp384r1_sha384 como algoritmo de firma. Confirma que tu biblioteca TLS realmente negocia estas suites de cifrado — algunos valores predeterminados prefieren variantes AES-128 incluso en sistemas configurados para Suite B.

Usa HMAC-SHA-384 para MAC con clave en contextos PRF de TLS 1.2

El PRF de TLS 1.2 usa HMAC-SHA-384 para suites de cifrado donde se negoció SHA-384 (RFC 5246, sección 5). Si estás implementando o probando un PRF de TLS 1.2: PRF(secreto, etiqueta, semilla) = P_SHA384(secreto, etiqueta + semilla). No sustituyas HMAC-SHA-256 en un contexto de suite de cifrado SHA-384 — la negociación de la suite de cifrado determina el hash del PRF, y una discrepancia causa un fallo en el handshake. Verifica con vectores de prueba de RFC 5705 (exportadores de material de clave) o RFC 6070 (PBKDF2).

Usa comparación en tiempo constante al verificar hashes SHA-384 en código

Si comparas dos hashes SHA-384 en código — verificando una huella de documento, comprobando un MAC — usa una verificación de igualdad en tiempo constante: Node.js crypto.timingSafeEqual(), Python hmac.compare_digest(), Go subtle.ConstantTimeCompare(). La igualdad de cadenas simple (=== o ==) filtra información de temporización que puede permitir a un atacante reconstruir el hash esperado byte a byte en ~768 comparaciones (96 chars × 8 bits). Esta es una medida de defensa en profundidad crítica para cualquier sistema de autenticación.

Preguntas frecuentes sobre SHA-384