Gerador e Verificador HMAC

Calcule e verifique assinaturas RFC 2104 HMAC-SHA256, SHA-384, SHA-512, SHA-1 e MD5 em Hex, Base64 ou Base64URL localmente no navegador via Web Crypto.

Sem uploadsSem cadastroResultados instantâneos
HMAC-SHA256 · SHA512 · MD5Hex · Base64 · Base64URL100% Local • Zero Envios
Calcular HMAC
Motor offline prontoEspaço de trabalho 100% privado no navegador • Sem uploads para a nuvem
100% Privado • Sem Upload de Arquivos para Servidor

Por que usar o Gerador e Verificador HMAC gratuito do Utiliome?

Criado do zero para privacidade estrita, execução instantânea e sem atrito. Sem assinaturas, paywalls ou cadastro.

Construção Compatível com RFC 2104 e FIPS 198-1

Implementa preenchimento de chave XOR interno (0x36) e externo (0x5c) com tamanho de bloco padrão para HMAC-SHA256, HMAC-SHA384, HMAC-SHA512, HMAC-SHA1 e HMAC-MD5, verificado contra vetores de teste IETF RFC 2202 e RFC 4231.

Decodificação de Chave Secreta em UTF-8, Hex e Base64

Interpreta segredos de assinatura como texto UTF-8, octetos hexadecimais brutos ou buffers de bytes Base64 RFC 4648 para que chaves binárias de API sejam decodificadas nos bytes exatos antes da derivação do HMAC.

Modo de Verificação de Assinatura em Tempo Constante

Valida cabeçalhos MAC recebidos de webhooks ou APIs contra assinaturas calculadas usando crypto.subtle.verify da Web Crypto e comparação XOR bit a bit de comprimento fixo sem vazar o tempo de prefixo.

Saídas de Webhook em Hex, Base64 e Base64URL

Produz digests em Hex minúsculo/maiúsculo (GitHub, Stripe, Slack), Base64 padrão com padding (Shopify, AWS) e Base64URL sem padding (segmentos JWS/JWT) totalmente offline na memória local do navegador.

Utiliome vs Alternativas Tradicionais em Nuvem

Compare nosso motor WebAssembly local contra ferramentas de nuvem legadas.

Recurso Utiliome (Navegador Local) Conversores de Nuvem Legados
Construção Compatível com RFC 2104 e FIPS 198-1 Implementa preenchimento de chave XOR interno (0x36) e externo (0x5c) com tamanho de bloco padrão para HMAC-SHA256, HMAC-SHA384, HMAC-SHA512, HMAC-SHA1 e HMAC-MD5, verificado contra vetores de teste IETF RFC 2202 e RFC 4231. Opções limitadas sem personalização avançada
Decodificação de Chave Secreta em UTF-8, Hex e Base64 Interpreta segredos de assinatura como texto UTF-8, octetos hexadecimais brutos ou buffers de bytes Base64 RFC 4648 para que chaves binárias de API sejam decodificadas nos bytes exatos antes da derivação do HMAC. Requer ferramentas externas ou ajuste manual
Privacidade e Processamento 100% local no navegador (zero upload para servidor) Envia os dados para servidores externos na nuvem
Preço e Cadastro 100% gratuito para sempre e sem criar conta Exige cadastro de conta ou assinatura paga
Como funciona

Como usar o Gerador e Verificador HMAC em 3 passos simples

Nenhuma instalação necessária. Tudo roda diretamente dentro do seu navegador.

1

Forneça o Payload Exato da Mensagem

Cole o corpo bruto não formatado da requisição HTTP ou a string canônica de assinatura — preservando espaços em branco exatos e a ordem das chaves — ou solte um arquivo de payload capturado.

2

Configure a Codificação da Chave Secreta e o Hash

Insira seu segredo compartilhado, selecione sua representação de bytes (texto simples UTF-8, Hex ou Base64) e escolha HMAC-SHA256, HMAC-SHA384, HMAC-SHA512, HMAC-SHA1 ou HMAC-MD5.

3

Copie o MAC ou Verifique a Assinatura Recebida

Copie o digest resultante em Hex, Base64 ou Base64URL, ou cole uma assinatura esperada (removendo prefixos de transporte como sha256= ou v0=) para executar a verificação em tempo constante.

Calculando e Verificando Assinaturas HMAC de Webhooks e APIs: Guia Prático

Resposta Rápida: Assinar a mensagem what do ya want for nothing? com o segredo de 4 bytes Jefe (Caso de Teste 2 da IETF RFC 4231) sob HMAC-SHA256 produz 5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843 em Hex e W9zBRr9gdU5qBCQmCJV1x1oAPwidJzmDnexYuWTsOEM= em Base64 nos modos de chave UTF-8, Hex (4a656665) e Base64 (SmVmZQ==).

Um Código de Autenticação de Mensagem Baseado em Hash com Chave (HMAC) comprova tanto a integridade dos dados (o payload não foi alterado em trânsito) quanto a autenticidade (o remetente detém a chave secreta compartilhada). Reproduzir a assinatura de um provedor exige corresponder a três parâmetros exatos: a primitiva de hash subjacente, a decodificação em bytes brutos da chave secreta e a sequência exata de bytes do payload assinado.

Exemplo 1: Caso de Teste 2 da IETF RFC 2104 / RFC 2202 / RFC 4231

Quer você insira a chave secreta de 4 bytes como texto UTF-8 Jefe, hexadecimal bruto 4a656665 ou Base64 SmVmZQ==, ela é decodificada para o mesmo buffer de chave [0x4a, 0x65, 0x66, 0x65]. Assinar a mensagem UTF-8 de 28 bytes what do ya want for nothing? resulta em:

{
  "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"
  }
}

Exemplo 2: Base64 vs Base64URL e Payloads Canônicos de Webhooks

O Base64 padrão (RFC 4648 Seção 4) emite +, / e padding final =, enquanto o Base64URL seguro para URLs (RFC 4648 Seção 5, usado em assinaturas JWS/JWT e URLs assinadas) substitui + por -, / por _ e remove o padding =. Assinar The quick brown fox jumps over the lazy dog com a chave UTF-8 key sob HMAC-SHA256 ilustra diretamente a diferença de codificação:

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

Ao verificar cabeçalhos de webhooks reais, construa o payload exato de pré-assinatura definido por cada provedor antes de remover os prefixos do cabeçalho:

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>

Construção RFC 2104, Regras de Normalização de Chaves e Resistência a Ataques de Tempo

Resposta Rápida: A RFC 2104 define o HMAC como H((K_0 XOR opad) || H((K_0 XOR ipad) || m)), normalizando as chaves secretas contra o tamanho do bloco de compressão interna da função de hash B (64 bytes para MD5/SHA-1/SHA-256; 128 bytes para SHA-384/SHA-512) em vez do comprimento de saída do digest L.

Definido na IETF RFC 2104 e NIST FIPS 198-1, o HMAC envolve qualquer função de hash criptográfico iterativa H em um envelope aninhado de duas passagens que impede ataques de extensão de comprimento em construções Merkle-Damgard:

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

Tamanho do Bloco (`B`) vs Comprimento de Saída (`L`) e Normalização de Chaves

Um erro frequente de implementação em código HMAC personalizado é normalizar a chave secreta K pelo comprimento em bytes da saída do digest L em vez do comprimento em bytes do bloco de compressão B:

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

Antes de aplicar o XOR contra ipad (0x36 repetido B vezes) e opad (0x5c repetido B vezes), os bytes brutos da chave K são normalizados em um bloco exato de B bytes K_0:

  1. Chaves curtas (len(K) < B): Acrescentam-se B - len(K) bytes zero (0x00) à direita de K.
  2. Chaves alinhadas ao bloco (len(K) == B): Usa-se K sem modificação (K_0 = K).
  3. Chaves maiores que o bloco (len(K) > B): Calcula-se o hash de K uma vez usando H(K) para produzir um digest de L bytes e, em seguida, acrescentam-se B - L bytes zero (0x00) para atingir B bytes.

De acordo com a RFC 2104 Seção 3, as chaves secretas devem conter pelo menos L bytes de entropia criptográfica (>= 32 bytes CSPRNG para HMAC-SHA256, >= 64 bytes CSPRNG para HMAC-SHA512). Chaves menores que L reduzem a segurança efetiva contra força bruta abaixo do limite do paradoxo do aniversário do hash.

Armadilhas na Codificação de Chaves e Verificação em Tempo Constante

  • String Hex vs Bytes Hex Brutos: Se uma API emite um segredo hexadecimal de 64 caracteres como 4a656665..., verifique se o SDK trata essa string como 64 bytes ASCII UTF-8 (0x34 0x61...) ou se a decodifica de hexadecimal para 32 bytes brutos (0x4a 0x65...) antes de chamar importKey. Alternar o seletor de Codificação da Chave entre UTF-8, Hex e Base64 isola imediatamente divergências de decodificação de chave durante a depuração de integrações.
  • Verificação em Tempo Constante: Nunca valide um MAC não confiável no código do servidor usando igualdade padrão de strings (computedHex === headerHex). A comparação padrão de strings retorna false no primeiro byte divergente, criando um oráculo de tempo em escala de nanossegundos que permite a invasores remotos descobrir MACs válidos por força bruta um byte por vez (256 * L tentativas em vez de 2^(8*L)). A verificação no navegador utiliza crypto.subtle.verify('HMAC', cryptoKey, signatureBuffer, messageBuffer) (ou acumulação XOR bit a bit de comprimento fixo em arrays de bytes decodificados), espelhando o crypto.timingSafeEqual do Node.js e o hmac.compare_digest do Python.

Gerador HMAC vs Gerador de Hash Criptográfico vs Gerador JWT: Qual Você Precisa?

Resposta Rápida: Use o Gerador HMAC para assinar ou verificar payloads brutos (corpos HTTP, strings canônicas, eventos de webhook) com uma chave secreta compartilhada. Use o Gerador de Hash Criptográfico para digests de strings ou arquivos sem chave, e use o Gerador JWT para construir JSON Web Tokens estruturados RFC 7519 assinados com HS256, HS384 ou HS512.

Embora digests sem chave, HMACs brutos e JSON Web Tokens simétricos compartilhem primitivas SHA-2 subjacentes, eles resolvem camadas distintas de segurança de protocolo:

Recurso Gerador e Verificador HMAC (Esta Ferramenta) Gerador de Hash Criptográfico Gerador JWT
Primitiva Criptográfica MAC com Chave (RFC 2104 / FIPS 198-1) Digest sem Chave (FIPS 180-4 / RFC 1321) Envelope de Token JWS / JWT (RFC 7515 / RFC 7519)
Requer Chave Secreta Sim (segredo compartilhado em UTF-8, Hex ou Base64) Não Sim (Segredo simétrico ou par de chaves RSA/ECDSA)
Garantia de Segurança Autenticidade + Integridade dos Dados Apenas Integridade de Dados Acidental / Pública Claims Estruturadas Autenticadas (iss, sub, exp)
Algoritmos Suportados HMAC-SHA256, SHA384, SHA512, SHA1, MD5 MD5, SHA-1, SHA-256, SHA-384, SHA-512 HS256, HS384, HS512 (além de suítes JWS assimétricas)
Formato de Saída Hex, Base64, Base64URL Hex Minús/Maiús, Base64 <header>.<payload>.<signature> (Base64URL)

Escolhendo o Utilitário Certo

  • Depurando digests de arquivos sem chave, hashes W3C SRI ou chaves de cache / ETag? Nenhuma chave secreta está envolvida — use o Gerador de Hash Criptográfico.
  • Construindo ou inspecionando tokens de autenticação bearer (HS256, HS384, HS512)? Pela RFC 7515, uma assinatura JWT HS256 é estritamente a saída Base64URL sem padding de HMAC-SHA256(secret, ASCII(BASE64URL(header) + "." + BASE64URL(payload))). Embora você possa verificar o terceiro segmento bruto diretamente aqui colando <base64url_header>.<base64url_payload> como mensagem e selecionando a saída Base64URL, use o Gerador JWT para editar cabeçalhos JSON, validar timestamps exp/nbf e montar tokens completos de três partes.
  • HMAC Simétrico vs Assinaturas Assimétricas: Como o HMAC é simétrico, todo serviço que verifica uma assinatura detém exatamente o segredo necessário para forjar novas assinaturas. Use HMAC para webhooks ponto a ponto e serviços internos confiáveis; quando terceiros não confiáveis precisarem verificar tokens sem privilégios de assinatura, use chaves assimétricas (RS256, ES256, EdDSA) no Gerador JWT.
Perguntas frequentes

FAQ e Guia Técnico do Gerador e Verificador HMAC

Tudo o que você precisa saber sobre o gerador hmac online e gratuito do Utiliome.

Por que a verificação HMAC do meu webhook falha mesmo quando minha chave secreta e os campos JSON parecem idênticos?

Dois problemas causam mais de 90% das falhas de correspondência de HMAC em webhooks. Primeiro, middlewares como o express.json() do Express analisam e re-serializam o JSON, alterando espaços em branco, escape Unicode ou a ordenação de chaves em relação ao fluxo bruto de bytes TCP que o remetente assinou — assine sempre o buffer bruto não analisado da requisição e inclua os prefixos de timestamp do provedor (como <timestamp>.<body> do Stripe ou v0:<timestamp>:<body> do Slack). Segundo, verifique se o segredo do provedor deve ser decodificado de Base64 ou Hex para bytes brutos em vez de lido como uma string UTF-8.

Por que SHA256(secret + message) é inseguro em comparação ao HMAC-SHA256 da RFC 2104?

MD5, SHA-1, SHA-256 e SHA-512 usam a construção Merkle-Damgard, cujo digest final expõe todo o estado interno de compressão. Dados SHA256(secret || message) e o comprimento em bytes de secret, um invasor pode calcular SHA256(secret || message || padding || attacker_suffix) sem nunca conhecer secret (um ataque de extensão de comprimento). O HMAC da RFC 2104 elimina isso alimentando o digest interno em um segundo hash externo com chave H((K_0 XOR opad) || inner_hash).

O que acontece se minha chave secreta HMAC tiver mais de 64 ou 128 bytes?

De acordo com a RFC 2104 Seção 2, se uma chave secreta exceder estritamente o tamanho do bloco interno B da função de hash (len(K) > 64 bytes para MD5, SHA-1 e SHA-256; len(K) > 128 bytes para SHA-384 e SHA-512), a chave é primeiro comprimida aplicando-se o hash uma vez com H(K) em L bytes e depois preenchida à direita com bytes 0x00 até atingir B bytes. Tanto a Web Crypto (crypto.subtle.importKey) quanto bibliotecas de servidor compatíveis com a RFC realizam essa etapa de pré-hash automaticamente.

Qual codificação de saída devo selecionar para GitHub, Stripe, Slack, Shopify e JWT HS256?

GitHub (X-Hub-Signature-256), Stripe (Stripe-Signature v1) e Slack (X-Slack-Signature v0) transmitem digests HMAC-SHA256 em Hex minúsculo após seus respectivos prefixos sha256=, v1= ou v0=. Shopify (X-Shopify-Hmac-Sha256) e AWS Signature v1/v2 usam Base64 padrão com padding. JSON Web Tokens (HS256, HS384, HS512) exigem Base64URL sem padding conforme a RFC 7515 — consulte o Gerador JWT para a montagem completa de tokens.

O HMAC-MD5 e o HMAC-SHA1 foram quebrados pelos ataques de colisão de MD5 e SHA-1?

Não diretamente. Ataques de colisão contra MD5 e SHA-1 sem chave dependem de um invasor escolher livremente blocos de mensagem contra um IV fixo público, enquanto o HMAC mascara o IV interno atrás das etapas secretas K_0 XOR ipad e K_0 XOR opad (documentado na IETF RFC 6151). Ainda assim, o NIST SP 800-131A e os principais provedores de webhook (como o GitHub ao descontinuar o X-Hub-Signature SHA-1) desencorajam o HMAC-MD5 e o legado HMAC-SHA1 para novos sistemas — escolha sempre HMAC-SHA256 ou HMAC-SHA512, a menos que esteja mantendo compatibilidade com protocolos legados.