Generador y Verificador HMAC

Calcula y verifica firmas RFC 2104 HMAC-SHA256, SHA-384, SHA-512, SHA-1 y MD5 en Hex, Base64 o Base64URL localmente en tu navegador mediante Web Crypto.

Sin subidasSin registroResultados instantáneos
HMAC-SHA256 · SHA512 · MD5Hex · Base64 · Base64URL100% Local • Cero Subidas
Calcular HMAC
Motor local listoEspacio de trabajo 100% privado en el navegador • Sin subidas a la nube
100 % Privado • Sin cargas de archivos a servidores

¿Por qué usar Generador y Verificador HMAC gratis en Utiliome?

Diseñado para máxima privacidad, ejecución instantánea y sin fricción. Sin suscripciones ni registros.

Construcción Compatible con RFC 2104 y FIPS 198-1

Implementa el relleno de clave XOR interno (0x36) y externo (0x5c) de tamaño de bloque estándar para HMAC-SHA256, HMAC-SHA384, HMAC-SHA512, HMAC-SHA1 y HMAC-MD5, verificado con vectores de prueba IETF RFC 2202 y RFC 4231.

Decodificación de Clave Secreta en UTF-8, Hex y Base64

Analiza secretos de firma como texto UTF-8, octetos hexadecimales puros o búferes de bytes Base64 RFC 4648 para decodificar claves de API binarias a sus bytes exactos antes de la derivación del HMAC.

Modo de Verificación de Firma en Tiempo Constante

Valida cabeceras MAC entrantes de webhooks o APIs frente a las firmas calculadas usando crypto.subtle.verify de Web Crypto y comparación XOR bit a bit de longitud fija sin filtrar tiempos por prefijo.

Salidas de Webhook en Hex, Base64 y Base64URL

Genera resúmenes en Hex en minúsculas/mayúsculas (GitHub, Stripe, Slack), Base64 estándar con relleno (Shopify, AWS) y Base64URL sin relleno (segmentos JWS/JWT) completamente sin conexión en la memoria local del navegador.

Utiliome vs Alternativas en la nube tradicionales

Compara nuestro motor local en WebAssembly frente a herramientas en la nube.

Característica Utiliome (Navegador local) Convertidores en la nube tradicionales
Construcción Compatible con RFC 2104 y FIPS 198-1 Implementa el relleno de clave XOR interno (0x36) y externo (0x5c) de tamaño de bloque estándar para HMAC-SHA256, HMAC-SHA384, HMAC-SHA512, HMAC-SHA1 y HMAC-MD5, verificado con vectores de prueba IETF RFC 2202 y RFC 4231. Opciones limitadas sin personalización avanzada
Decodificación de Clave Secreta en UTF-8, Hex y Base64 Analiza secretos de firma como texto UTF-8, octetos hexadecimales puros o búferes de bytes Base64 RFC 4648 para decodificar claves de API binarias a sus bytes exactos antes de la derivación del HMAC. Requiere herramientas externas o ajustes manuales
Privacidad y Procesamiento 100% local en tu navegador (cero subidas al servidor) Sube los datos a servidores externos en la nube
Precio y Registro 100% gratis para siempre y sin crear cuenta Requiere registro de cuenta o suscripción de pago
Cómo funciona

Cómo usar Generador y Verificador HMAC en 3 sencillos pasos

Sin instalación de software. Todo funciona directamente dentro de tu navegador web.

1

Proporciona el Payload Exacto del Mensaje

Pega el cuerpo crudo sin formatear de la petición HTTP o la cadena canónica de firma —conservando los espacios en blanco exactos y el orden de las claves— o suelta un archivo de payload capturado.

2

Configura la Codificación de Clave Secreta y el Hash

Introduce tu secreto compartido, selecciona su representación de bytes (texto plano UTF-8, Hex o Base64) y elige HMAC-SHA256, HMAC-SHA384, HMAC-SHA512, HMAC-SHA1 o HMAC-MD5.

3

Copia el MAC o Verifica la Firma Entrante

Copia el resumen resultante en Hex, Base64 o Base64URL, o pega una firma esperada (eliminando prefijos de transporte como sha256= o v0=) para ejecutar una verificación en tiempo constante.

Cálculo y Verificación de Firmas HMAC en Webhooks y APIs: Guía Práctica

Respuesta rápida: Firmar el mensaje what do ya want for nothing? con el secreto de 4 bytes Jefe (Caso de Prueba 2 de IETF RFC 4231) bajo HMAC-SHA256 produce 5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843 en Hex y W9zBRr9gdU5qBCQmCJV1x1oAPwidJzmDnexYuWTsOEM= en Base64 en los modos de clave UTF-8, Hex (4a656665) y Base64 (SmVmZQ==).

Un Código de Autenticación de Mensajes Basado en Hash con Clave (HMAC) demuestra tanto la integridad de los datos (el payload no fue alterado en tránsito) como la autenticidad (el remitente posee la clave secreta compartida). Reproducir la firma de un proveedor requiere hacer coincidir tres parámetros exactos: la primitiva hash subyacente, la decodificación en bytes puros de la clave secreta y la secuencia exacta de bytes del payload firmado.

Ejemplo 1: Caso de Prueba 2 de IETF RFC 2104 / RFC 2202 / RFC 4231

Ya sea que introduzcas la clave secreta de 4 bytes como texto UTF-8 Jefe, hexadecimal puro 4a656665 o Base64 SmVmZQ==, se decodifica al mismo búfer de clave [0x4a, 0x65, 0x66, 0x65]. Firmar el mensaje UTF-8 de 28 bytes what do ya want for nothing? produce:

{
  "keyUtf8": "Jefe",
  "keyHex": "4a656665",
  "keyBase64": "SmVmZQ==",
  "message": "what do ya want for nothing?",
  "signatures": {
    "hmac_md5_hex": "750c783e6ab0b503eaa86e310a5db738",
    "hmac_sha1_hex": "effcdf6ae5eb2fa2d27416d5f184df9c259a7c79",
    "hmac_sha256_hex": "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843",
    "hmac_sha256_base64": "W9zBRr9gdU5qBCQmCJV1x1oAPwidJzmDnexYuWTsOEM=",
    "hmac_sha256_base64url": "W9zBRr9gdU5qBCQmCJV1x1oAPwidJzmDnexYuWTsOEM",
    "hmac_sha384_hex": "af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec3736322445e8e2240ca5e69e2c78b3239ecfab21649",
    "hmac_sha512_hex": "164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737"
  }
}

Ejemplo 2: Base64 vs Base64URL y Payloads Canónicos de Webhooks

El formato Base64 estándar (RFC 4648 Sección 4) emite +, / y relleno final =, mientras que Base64URL seguro para URL (RFC 4648 Sección 5, utilizado en firmas JWS/JWT y URLs firmadas) sustituye + por -, / por _ y elimina el relleno =. Firmar The quick brown fox jumps over the lazy dog con la clave UTF-8 key bajo HMAC-SHA256 ilustra directamente la diferencia de codificación:

Key (UTF-8):     key
Message (UTF-8): The quick brown fox jumps over the lazy dog

HMAC-SHA256 Hex:       f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8
HMAC-SHA256 Base64:    97yD9DBThCSxMpjmqm+xQ+9NWaFJRhdZl0edvC0aPNg=
HMAC-SHA256 Base64URL: 97yD9DBThCSxMpjmqm-xQ-9NWaFJRhdZl0edvC0aPNg

Al verificar cabeceras de webhooks reales, construye el payload exacto previo a la firma definido por cada proveedor antes de eliminar los prefijos de la cabecera:

GitHub (X-Hub-Signature-256: sha256=<hex>):
  Signed input = <raw_http_body>

Stripe (Stripe-Signature: t=1730419200,v1=<hex>):
  Signed input = 1730419200.<raw_http_body>

Slack (X-Slack-Signature: v0=<hex>):
  Signed input = v0:1730419200:<raw_http_body>

Shopify (X-Shopify-Hmac-Sha256: <base64>):
  Signed input = <raw_http_body>

Construcción RFC 2104, Reglas de Normalización de Claves y Resistencia a Ataques de Temporización

Respuesta rápida: El RFC 2104 define HMAC como H((K_0 XOR opad) || H((K_0 XOR ipad) || m)), normalizando las claves secretas frente al tamaño de bloque de compresión interno de la función hash B (64 bytes para MD5/SHA-1/SHA-256; 128 bytes para SHA-384/SHA-512) en lugar de su longitud de salida de resumen L.

Definido en IETF RFC 2104 y NIST FIPS 198-1, HMAC envuelve cualquier función hash criptográfica iterativa H en una envoltura anidada de dos pasadas que previene los ataques de extensión de longitud en construcciones Merkle-Damgard:

HMAC(K, m) = H( (K_0 XOR opad) || H( (K_0 XOR ipad) || m ) )

Tamaño de Bloque (`B`) vs Longitud de Salida (`L`) y Normalización de Claves

Un error de implementación frecuente en código HMAC personalizado es normalizar la clave secreta K frente a la longitud en bytes de salida del resumen L en lugar de la longitud en bytes del bloque de compresión B:

  • MD5 (L = 16), SHA-1 (L = 20), SHA-256 (L = 32): Tamaño de bloque interno B = 64 bytes (512 bits).
  • SHA-384 (L = 48), SHA-512 (L = 64): Tamaño de bloque interno B = 128 bytes (1024 bits).

Antes de aplicar XOR con ipad (0x36 repetido B veces) y opad (0x5c repetido B veces), los bytes puros de la clave K se normalizan en un bloque exacto de B bytes K_0:

  1. Claves cortas (len(K) < B): Se añaden B - len(K) bytes cero (0x00) a la derecha de K.
  2. Claves alineadas al bloque (len(K) == B): Se usa K sin modificar (K_0 = K).
  3. Claves sobredimensionadas (len(K) > B): Se aplica el hash a K una vez usando H(K) para producir un resumen de L bytes, y luego se añaden B - L bytes cero (0x00) hasta alcanzar B bytes.

Según el RFC 2104 Sección 3, las claves secretas deben contener al menos L bytes de entropía criptográfica (>= 32 bytes CSPRNG para HMAC-SHA256, >= 64 bytes CSPRNG para HMAC-SHA512). Las claves más cortas que L reducen la seguridad efectiva contra fuerza bruta por debajo del límite de cumpleaños del hash.

Errores Comunes de Codificación de Claves y Verificación en Tiempo Constante

  • Cadena Hex vs Bytes Hex Puros: Si una API emite un secreto hexadecimal de 64 caracteres como 4a656665..., comprueba si su SDK trata esa cadena como 64 bytes ASCII UTF-8 (0x34 0x61...) o la decodifica desde hexadecimal en 32 bytes puros (0x4a 0x65...) antes de llamar a importKey. Alternar el selector de codificación de clave entre UTF-8, Hex y Base64 aísla de inmediato las discrepancias de decodificación de claves al depurar integraciones.
  • Verificación en Tiempo Constante: Nunca valides un MAC no confiable en el código del servidor usando una comparación estándar de igualdad de cadenas (computedHex === headerHex). La comparación de cadenas estándar devuelve false en el primer byte que no coincide, creando un oráculo de tiempo a escala de nanosegundos que permite a atacantes remotos forzar MACs válidos byte por byte (256 * L intentos en lugar de 2^(8*L)). La verificación en el navegador utiliza crypto.subtle.verify('HMAC', cryptoKey, signatureBuffer, messageBuffer) (o acumulación XOR bit a bit de longitud fija sobre matrices de bytes decodificadas), reflejando crypto.timingSafeEqual de Node.js y hmac.compare_digest de Python.

Generador HMAC vs Generador de Hash Criptográfico vs Generador JWT: ¿Cuál Necesitas?

Respuesta rápida: Usa el Generador HMAC para firmar o verificar payloads crudos (cuerpos HTTP, cadenas canónicas, eventos de webhook) con una clave secreta compartida. Usa el Generador de Hash Criptográfico para resúmenes de cadenas o archivos sin clave, y usa el Generador JWT para construir JSON Web Tokens estructurados RFC 7519 firmados con HS256, HS384 o HS512.

Aunque los resúmenes sin clave, los HMAC puros y los JSON Web Tokens simétricos comparten primitivas SHA-2 subyacentes, resuelven distintas capas de seguridad de protocolo:

Característica Generador y Verificador HMAC (Esta Herramienta) Generador de Hash Criptográfico Generador JWT
Primitiva Criptográfica MAC con Clave (RFC 2104 / FIPS 198-1) Resumen sin Clave (FIPS 180-4 / RFC 1321) Envoltura de Token JWS / JWT (RFC 7515 / RFC 7519)
Requiere Clave Secreta Sí (secreto compartido en UTF-8, Hex o Base64) No Sí (Secreto simétrico o par de claves RSA/ECDSA)
Garantía de Seguridad Autenticidad + Integridad de Datos Solo Integridad de Datos Accidental / Pública Claims Estructurados Autenticados (iss, sub, exp)
Algoritmos Soportados HMAC-SHA256, SHA384, SHA512, SHA1, MD5 MD5, SHA-1, SHA-256, SHA-384, SHA-512 HS256, HS384, HS512 (más suites JWS asimétricas)
Formato de Salida Hex, Base64, Base64URL Hex Minús/Mayús, Base64 <header>.<payload>.<signature> (Base64URL)

Cómo Elegir la Utilidad Adecuada

  • ¿Depurando resúmenes de archivos sin clave, hashes W3C SRI o claves de caché / ETag? No interviene ninguna clave secreta: utiliza el Generador de Hash Criptográfico.
  • ¿Construyendo o inspeccionando tokens de autenticación portador (HS256, HS384, HS512)? Según el RFC 7515, una firma JWT HS256 es estrictamente la salida Base64URL sin relleno de HMAC-SHA256(secret, ASCII(BASE64URL(header) + "." + BASE64URL(payload))). Aunque puedes verificar el tercer segmento crudo directamente aquí pegando <base64url_header>.<base64url_payload> como mensaje y seleccionando la salida Base64URL, utiliza el Generador JWT para editar cabeceras JSON, validar marcas de tiempo exp/nbf y ensamblar tokens completos de tres partes.
  • HMAC Simétrico vs Firmas Asimétricas: Dado que HMAC es simétrico, cada servicio que verifica una firma posee exactamente el mismo secreto necesario para falsificar nuevas firmas. Utiliza HMAC para webhooks punto a punto y servicios internos de confianza; cuando terceros no confiables deban verificar tokens sin privilegios de firma, utiliza claves asimétricas (RS256, ES256, EdDSA) en el Generador JWT.
Preguntas frecuentes

Preguntas frecuentes y guía técnica de Generador y Verificador HMAC

Todo lo que necesitas saber sobre el uso gratuito en línea de generador hmac en Utiliome.

¿Por qué falla la verificación HMAC de mi webhook incluso cuando mi clave secreta y los campos JSON parecen idénticos?

Dos problemas causan más del 90 % de los fallos de coincidencia de HMAC en webhooks. Primero, middlewares como express.json() de Express analizan y vuelven a serializar el JSON, alterando los espacios en blanco, el escape Unicode o el orden de las claves con respecto al flujo de bytes TCP crudo que firmó el remitente; firma siempre el búfer crudo sin analizar de la petición e incluye los prefijos de marca de tiempo del proveedor (como <timestamp>.<body> de Stripe o v0:<timestamp>:<body> de Slack). Segundo, comprueba si el secreto del proveedor debe decodificarse desde Base64 o Hex a bytes puros en lugar de leerse como una cadena UTF-8.

¿Por qué SHA256(secret + message) es inseguro en comparación con HMAC-SHA256 del RFC 2104?

MD5, SHA-1, SHA-256 y SHA-512 utilizan la construcción Merkle-Damgard, cuyo resumen final expone el estado completo de compresión interna. Dados SHA256(secret || message) y la longitud en bytes de secret, un atacante puede calcular SHA256(secret || message || padding || attacker_suffix) sin conocer nunca secret (un ataque de extensión de longitud). El HMAC RFC 2104 elimina esto introduciendo el resumen interno en un segundo hash externo con clave H((K_0 XOR opad) || inner_hash).

¿Qué ocurre si mi clave secreta HMAC tiene más de 64 o 128 bytes?

Según el RFC 2104 Sección 2, si una clave secreta supera estrictamente el tamaño de bloque interno B de la función hash (len(K) > 64 bytes para MD5, SHA-1 y SHA-256; len(K) > 128 bytes para SHA-384 y SHA-512), la clave se comprime primero aplicándole el hash una vez con H(K) en L bytes y luego se rellena a la derecha con bytes 0x00 hasta alcanzar B bytes. Tanto Web Crypto (crypto.subtle.importKey) como las librerías de servidor compatibles con el RFC realizan este paso de pre-hash automáticamente.

¿Qué codificación de salida debo seleccionar para GitHub, Stripe, Slack, Shopify y JWT HS256?

GitHub (X-Hub-Signature-256), Stripe (Stripe-Signature v1) y Slack (X-Slack-Signature v0) transmiten resúmenes HMAC-SHA256 en Hex en minúsculas después de sus respectivos prefijos sha256=, v1= o v0=. Shopify (X-Shopify-Hmac-Sha256) y AWS Signature v1/v2 utilizan Base64 estándar con relleno. Los JSON Web Tokens (HS256, HS384, HS512) requieren Base64URL sin relleno según el RFC 7515; consulta el Generador JWT para el ensamblaje completo de tokens.

¿Están rotos HMAC-MD5 y HMAC-SHA1 por los ataques de colisión de MD5 y SHA-1?

No directamente. Los ataques de colisión contra MD5 y SHA-1 sin clave dependen de que un atacante elija libremente bloques de mensaje frente a un IV fijo público, mientras que HMAC enmascara el IV interno detrás de pasos secretos K_0 XOR ipad y K_0 XOR opad (documentado en IETF RFC 6151). No obstante, NIST SP 800-131A y los principales proveedores de webhooks (como GitHub al retirar X-Hub-Signature SHA-1) desaprueban HMAC-MD5 y el heredado HMAC-SHA1 para sistemas nuevos; elige siempre HMAC-SHA256 o HMAC-SHA512 a menos que mantengas compatibilidad con protocolos heredados.