Generador HMAC

¿Qué es HMAC?

HMAC (Hash-based Message Authentication Code, código de autenticación de mensajes basado en hash) es una construcción criptográfica definida en la RFC 2104 que combina una función hash con una clave secreta para producir una etiqueta de autenticación de tamaño fijo. A diferencia de un hash simple, que cualquiera puede calcular, un HMAC solo puede generarse y verificarse por las partes que comparten la clave secreta. HMAC es el mecanismo estándar para verificar tanto la integridad como la autenticidad de un mensaje: confirma que los datos no han sido alterados y que fueron producidos por un emisor de confianza.

El algoritmo HMAC funciona con cualquier función hash iterativa: SHA-256, SHA-384, SHA-512, e incluso funciones heredadas como SHA-1 o MD5. La construcción resultante se denomina por su hash subyacente: HMAC-SHA256, HMAC-SHA384 o HMAC-SHA512. Como la prueba de seguridad de HMAC depende de que la función hash sea resistente a colisiones y tenga ciertas propiedades pseudoaleatorias, los algoritmos de la familia SHA-2 son la opción recomendada para sistemas nuevos. HMAC-SHA256 es la variante más ampliamente desplegada, usada en AWS Signature V4, webhooks de Stripe, secretos de webhook de GitHub, firma de solicitudes de Slack y JSON Web Tokens (HS256).

El diseño de HMAC proporciona una propiedad crítica que el hashing simple no tiene: resistencia a los ataques de extensión de longitud. Con SHA-256 solo, un atacante que conoce H(mensaje) puede calcular H(mensaje || datos_atacante) sin conocer el mensaje original. La estructura de doble hashing de HMAC (hash interno y hash externo con claves rellenadas diferentes) previene este ataque por completo. Por eso los esquemas de firma de API usan HMAC en lugar de simplemente concatenar una clave secreta al mensaje y hacer hash del resultado.

¿Por qué usar un generador HMAC online?

Calcular firmas HMAC normalmente requiere escribir código o usar herramientas de línea de comandos. Este generador HMAC en el navegador te permite crear firmas HMAC-SHA256, HMAC-SHA384 y HMAC-SHA512 al instante sin instalar software ni cambiar a una terminal.

Casos de uso del generador HMAC

HMAC vs hash simple vs cifrado

HMAC, el hashing simple y el cifrado sirven para propósitos diferentes. HMAC proporciona autenticación de mensajes: prueba de que el mensaje fue creado por alguien con la clave secreta y no ha sido modificado. Un hash simple proporciona integridad pero no autenticación. El cifrado proporciona confidencialidad. La tabla a continuación aclara las diferencias.

Comparación de algoritmos HMAC

HMAC puede usar cualquier función hash, pero la elección del algoritmo subyacente determina el tamaño de la salida, el nivel de seguridad y la compatibilidad con el navegador. HMAC-SHA256 es la opción más común para sistemas nuevos. La tabla compara las variantes que probablemente encuentres.

Cómo funciona HMAC internamente

HMAC aplica la función hash subyacente dos veces con dos rellenos derivados de la clave. La construcción está definida en la RFC 2104 y demostrada como PRF (función pseudoaleatoria) bajo suposiciones criptográficas estándar. La clave se rellena primero o se hace hash para coincidir con el tamaño de bloque de la función hash (64 bytes para SHA-256, 128 bytes para SHA-512).

El algoritmo aplica XOR a la clave rellenada con una constante de relleno interno (ipad, 0x36 repetido), la concatena con el mensaje y hace hash del resultado. Luego aplica XOR a la clave rellenada con una constante de relleno externo (opad, 0x5C repetido), la concatena con la salida del hash interno y hace hash de nuevo. Esta estructura de doble hashing es la que previene los ataques de extensión de longitud y garantiza que la salida HMAC no pueda calcularse sin conocer la clave secreta.

Ejemplos de código HMAC

HMAC está soportado de forma nativa en todos los principales lenguajes y entornos de ejecución. La Web Crypto API proporciona HMAC-SHA256, HMAC-SHA384 y HMAC-SHA512 en los navegadores sin ninguna biblioteca. Los ejemplos a continuación muestran patrones de uso reales, incluida la verificación de webhooks y la comparación en tiempo constante.

async function hmacSHA256(message, secret) {
  const enc = new TextEncoder()
  const key = await crypto.subtle.importKey(
    'raw', enc.encode(secret),
    { name: 'HMAC', hash: 'SHA-256' },
    false, ['sign']
  )
  const sig = await crypto.subtle.sign('HMAC', key, enc.encode(message))
  return Array.from(new Uint8Array(sig))
    .map(b => b.toString(16).padStart(2, '0')).join('')
}

await hmacSHA256('hello world', 'my-secret-key')
// → "90eb182d8396f16d4341d582047f45c0a97d73388c5377d9ced478a2212295ad"

// Node.js (built-in crypto module)
const crypto = require('crypto')
crypto.createHmac('sha256', 'my-secret-key')
  .update('hello world').digest('hex')
// → "90eb182d8396f16d4341d582047f45c0a97d73388c5377d9ced478a2212295ad"

import hmac
import hashlib

# HMAC-SHA256
sig = hmac.new(
    b'my-secret-key',
    b'hello world',
    hashlib.sha256
).hexdigest()
print(sig)
# → "90eb182d8396f16d4341d582047f45c0a97d73388c5377d9ced478a2212295ad"

# Verify a webhook signature (constant-time comparison)
expected = "90eb182d8396f16d4341d582047f45c0a97d73388c5377d9ced478a2212295ad"
received = hmac.new(b'my-secret-key', b'hello world', hashlib.sha256).hexdigest()
if hmac.compare_digest(expected, received):
    print("Signature valid")

# HMAC-SHA512
hmac.new(b'key', b'data', hashlib.sha512).hexdigest()

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "fmt"
)

func main() {
    mac := hmac.New(sha256.New, []byte("my-secret-key"))
    mac.Write([]byte("hello world"))
    sig := mac.Sum(nil)
    fmt.Printf("%x\n", sig)
    // → 90eb182d8396f16d4341d582047f45c0a97d73388c5377d9ced478a2212295ad

    // Verify: use hmac.Equal for constant-time comparison
    expected := mac.Sum(nil)
    fmt.Println(hmac.Equal(sig, expected)) // true
}

# HMAC-SHA256
echo -n "hello world" | openssl dgst -sha256 -hmac "my-secret-key"
# → SHA2-256(stdin)= 90eb182d8396f16d4341d582047f45c0a97d73388c5377d9ced478a2212295ad

# HMAC-SHA512
echo -n "hello world" | openssl dgst -sha512 -hmac "my-secret-key"

# Verify a file signature
openssl dgst -sha256 -hmac "my-secret-key" release.tar.gz

# HMAC with hex key (e.g. from a webhook secret)
echo -n "payload" | openssl dgst -sha256 -hmac "$(echo -n '736563726574' | xxd -r -p)"

Preguntas frecuentes