Generador de Hash SHA-384

¿Qué es el hashing SHA-384?

SHA-384 es una función de hash criptográfico definida en NIST FIPS 180-4 como parte de la familia SHA-2. Acepta una entrada de longitud arbitraria y produce un resumen de mensaje fijo de 384 bits (48 bytes), habitualmente representado como una cadena hexadecimal de 96 caracteres. SHA-384 se usa ampliamente en suites de cifrado TLS, firmas de certificados digitales y sistemas gubernamentales que requieren un margen de resistencia a colisiones mayor que el que ofrece SHA-256.

Internamente, SHA-384 es una variante truncada de SHA-512. Utiliza el mismo tamaño de bloque de 1024 bits, 80 rondas de compresión y aritmética de palabras de 64 bits que SHA-512, pero parte de un conjunto diferente de valores de hash iniciales (derivados del 9.º al 16.º número primo) y produce solo los primeros 384 bits del estado final. Esta truncación hace que SHA-384 genere un resumen distinto al de SHA-512 para entradas idénticas, a pesar de compartir el mismo algoritmo central.

Dado que SHA-384 opera con palabras de 64 bits, es más rápido que SHA-256 en procesadores de 64 bits modernos y produce un resumen más largo. Esto lo convierte en un punto medio práctico: más robusto que SHA-256 (192 bits de resistencia a colisiones frente a 128 bits) sin el coste de almacenamiento de la salida hex de 128 caracteres de SHA-512. SHA-384 es el hash predeterminado para las firmas de verificación de certificados en TLS 1.3 y es requerido por NSA Suite B (ahora CNSA) para datos SECRETOS.

¿Por qué usar un generador de SHA-384 online?

Generar hashes SHA-384 normalmente requiere un comando de terminal o escribir código. Esta herramienta basada en navegador te permite calcular resúmenes SHA-384 al instante sin instalar nada ni enviar datos a un servidor. Ya sea que necesites generar un hash SRI para un recurso en CDN, verificar un checksum de archivo, o comparar la salida SHA-384 con SHA-256 para la misma entrada, esta herramienta te da una forma inmediata y sin dependencias de trabajar con resúmenes SHA-384 en cualquier navegador moderno.

Casos de uso del Generador de Hash SHA-384

Comparación de variantes de la familia SHA-2

SHA-384 pertenece a la familia SHA-2 junto con otras variantes. La tabla muestra sus diferencias en tamaño de resumen, longitud de salida y aplicaciones típicas.

SHA-384 vs SHA-256 vs SHA-512 vs SHA-3-384

La elección entre SHA-384 y otros algoritmos de hash depende de tus requisitos de seguridad, las limitaciones de la plataforma y las necesidades de rendimiento. Esta comparación cubre las propiedades más relevantes.

Cómo funciona SHA-384 internamente

SHA-384 procesa la entrada mediante la misma construcción Merkle–Damgård que SHA-512. La entrada se rellena hasta ser múltiplo de 1024 bits, se divide en bloques y cada bloque se procesa a través de 80 rondas de mezcla usando las funciones Ch, Maj y dos funciones Sigma con aritmética de palabras de 64 bits. La diferencia clave respecto a SHA-512 son los valores de hash iniciales: SHA-384 usa valores derivados de las partes fraccionarias de las raíces cuadradas del 9.º al 16.º número primo, mientras que SHA-512 usa los 8 primeros. Tras procesar todos los bloques, SHA-384 trunca el estado interno de 512 bits a sus primeros 384 bits.

La truncación y la inicialización diferente hacen que SHA-384 y SHA-512 siempre produzcan resúmenes distintos para la misma entrada. Esto también hace que SHA-384 sea intrínsecamente resistente a los ataques de extensión de longitud, a diferencia de SHA-256 y SHA-512, donde un atacante puede añadir datos y calcular un hash válido sin conocer el mensaje original.

Ejemplos de código SHA-384

SHA-384 está soportado de forma nativa en todos los principales lenguajes y entornos de ejecución. A continuación encontrarás ejemplos funcionales que puedes copiar directamente en tus proyectos.

// Works in all modern browsers and Node.js 18+
async function sha384(text) {
  const data = new TextEncoder().encode(text)
  const hashBuffer = await crypto.subtle.digest('SHA-384', data)
  const hashArray = Array.from(new Uint8Array(hashBuffer))
  return hashArray.map(b => b.toString(16).padStart(2, '0')).join('')
}

await sha384('hello world')
// → "fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd"

// Node.js (built-in crypto module)
const crypto = require('crypto')
crypto.createHash('sha384').update('hello world').digest('hex')
// → "fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd"

import hashlib

# Basic SHA-384 hash
result = hashlib.sha384(b'hello world').hexdigest()
print(result)
# → "fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd"

# Hash a string with Unicode characters
text = 'café ☕'
hashlib.sha384(text.encode('utf-8')).hexdigest()
# → 96-character hex string

# Hash a file in chunks (memory-efficient)
with open('release.tar.gz', 'rb') as f:
    sha = hashlib.sha384()
    for chunk in iter(lambda: f.read(8192), b''):
        sha.update(chunk)
    print(sha.hexdigest())

package main

import (
    "crypto/sha512"
    "fmt"
)

func main() {
    data := []byte("hello world")
    // SHA-384 lives in the crypto/sha512 package
    hash := sha512.Sum384(data)
    fmt.Printf("%x\n", hash)
    // → fdbd8e75a67f29f701a4e040385e2e23986303ea10239211af907fcbb83578b3e417cb71ce646efd0819dd8c088de1bd
}

# Using sha384sum (Linux)
echo -n "hello world" | sha384sum
# → fdbd8e75a67f29f701a4e040385e2e23...  -

# macOS
echo -n "hello world" | shasum -a 384
# → fdbd8e75a67f29f701a4e040385e2e23...  -

# Using openssl (cross-platform)
echo -n "hello world" | openssl dgst -sha384
# → SHA2-384(stdin)= fdbd8e75a67f29f701a4e040385e2e23986303ea...

# Verify a file checksum
sha384sum myfile.bin > checksum.txt
sha384sum -c checksum.txt
# → myfile.bin: OK

Preguntas frecuentes