Generador de Hash SHA-512

¿Qué es el hashing SHA-512?

SHA-512 es una función hash criptográfica definida en NIST FIPS 180-4 como el miembro más grande de la familia SHA-2. Acepta una entrada de longitud arbitraria y produce un resumen de mensaje fijo de 512 bits (64 bytes), representado como una cadena hexadecimal de 128 caracteres. SHA-512 se utiliza en firmas digitales (Ed25519 usa SHA-512 internamente), construcciones HMAC, verificación de integridad de archivos y protocolos criptográficos que se benefician de un amplio margen de seguridad.

SHA-512 opera sobre bloques de 1024 bits (128 bytes) usando aritmética de palabras de 64 bits y 80 rondas de compresión. Sus ocho valores de hash iniciales se derivan de las partes fraccionarias de las raíces cuadradas de los primeros ocho números primos, y sus 80 constantes de ronda provienen de las raíces cúbicas de los primeros 80 primos. Dado que usa operaciones nativas de 64 bits, SHA-512 suele ser más rápido que SHA-256 en procesadores modernos de 64 bits, a pesar de producir un resumen más largo.

SHA-384, SHA-512/224 y SHA-512/256 son variantes truncadas de SHA-512 que comparten la misma estructura interna pero usan distintos valores de hash iniciales y producen menos bits de salida. Cuando necesitas la longitud máxima de resumen que ofrece la familia SHA-2, o cuando un protocolo requiere específicamente SHA-512 (como Ed25519 o ciertos esquemas de derivación de claves basados en HMAC), SHA-512 es la elección correcta. Proporciona 256 bits de resistencia a colisiones, equivalente a SHA-3-512 y muy por encima del límite de 128 bits de SHA-256.

¿Por qué usar un generador SHA-512 online?

Calcular un hash SHA-512 normalmente requiere un comando en la terminal o unas pocas líneas de código. Esta herramienta en el navegador te permite generar resúmenes SHA-512 de forma instantánea sin instalar software, abrir una terminal ni escribir scripts desechables.

Casos de uso del generador SHA-512

Comparación de variantes de la familia SHA-2

SHA-512 pertenece a la familia SHA-2 definida en FIPS 180-4. La tabla compara las variantes SHA-2 que comparten la arquitectura interna de 64 bits de SHA-512, junto con SHA-256 como referencia.

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

El algoritmo hash correcto depende de tus requisitos de seguridad, las limitaciones de rendimiento y las especificaciones del protocolo. SHA-512 ofrece el resumen más amplio de la familia SHA-2 y suele ser más rápido que SHA-256 en hardware de 64 bits. Esta comparación cubre las propiedades más relevantes al elegir entre ellos.

Cómo funciona SHA-512 internamente

SHA-512 procesa la entrada mediante una construcción Merkle–Damgård usando bloques de 1024 bits. Inicializa ocho palabras de estado de 64 bits (H0–H7) a partir de las partes fraccionarias de las raíces cuadradas de los primeros ocho números primos. Cada bloque pasa por 80 rondas de mezcla que aplican operaciones bit a bit (AND, XOR, NOT, rotación derecha, desplazamiento derecho) sobre palabras de 64 bits, combinadas con 80 constantes de ronda derivadas de las raíces cúbicas de los primeros 80 primos.

El tamaño de palabra más amplio de 64 bits es el diferenciador clave respecto a SHA-256. En CPUs de 64 bits, cada operación procesa el doble de bits por ciclo, lo que explica por qué SHA-512 suele superar a SHA-256 en benchmarks a pesar de ejecutar 80 rondas en lugar de 64. El efecto avalancha garantiza que al invertir un solo bit de entrada cambie aproximadamente el 50% de los 512 bits de salida.

Ejemplos de código SHA-512

SHA-512 está disponible de forma nativa en todos los principales lenguajes y entornos de ejecución. La Web Crypto API lo proporciona en los navegadores sin necesidad de ninguna biblioteca. Los ejemplos siguientes cubren patrones comunes, incluido el manejo de Unicode y el hashing de archivos.

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

await sha512('hello world')
// → "309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f"

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

import hashlib

# Basic SHA-512 hash
result = hashlib.sha512(b'hello world').hexdigest()
print(result)
# → "309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee..."

# Hash a string with Unicode (encode to bytes first)
text = 'café ☕'
hashlib.sha512(text.encode('utf-8')).hexdigest()
# → 128-character hex string

# Hash a large file in chunks (memory-efficient)
with open('release.tar.gz', 'rb') as f:
    sha = hashlib.sha512()
    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")
    hash := sha512.Sum512(data)
    fmt.Printf("%x\n", hash)
    // → 309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f...
}

# Using sha512sum (Linux) or shasum (macOS)
echo -n "hello world" | sha512sum
# → 309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee...  -

# macOS
echo -n "hello world" | shasum -a 512
# → 309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee...  -

# Verify a file checksum
echo "309ecc48...  myfile.bin" | sha512sum -c
# → myfile.bin: OK

# Using openssl (cross-platform)
echo -n "hello world" | openssl dgst -sha512
# → SHA2-512(stdin)= 309ecc489c12d6eb4cc40f50c902f2b4...

Preguntas frecuentes