Gerador HMAC

O Que É HMAC?

HMAC (Hash-based Message Authentication Code) é uma construção criptográfica definida na RFC 2104 que combina uma função hash com uma chave secreta para produzir uma tag de autenticação de tamanho fixo. Ao contrário de um hash simples, que qualquer pessoa pode calcular, um HMAC só pode ser gerado e verificado por partes que compartilham a chave secreta. O HMAC é o mecanismo padrão para verificar tanto a integridade quanto a autenticidade de uma mensagem — confirmando que os dados não foram alterados e que foram produzidos por um remetente confiável.

O algoritmo HMAC funciona com qualquer função hash iterativa: SHA-256, SHA-384, SHA-512 e até funções legadas como SHA-1 ou MD5. A construção resultante é referenciada pelo hash subjacente — HMAC-SHA256, HMAC-SHA384 ou HMAC-SHA512. Como a prova de segurança do HMAC depende de a função hash ser resistente a colisões e ter certas propriedades pseudoaleatórias, os algoritmos da família SHA-2 são a escolha recomendada para novos sistemas. O HMAC-SHA256 é a variante mais amplamente implantada, utilizada em AWS Signature V4, webhooks do Stripe, segredos de webhook do GitHub, assinatura de requisições do Slack e JSON Web Tokens (HS256).

O design do HMAC oferece uma propriedade crítica que o hash simples não possui: resistência a ataques de extensão de comprimento. Com SHA-256 sozinho, um atacante que conhece H(mensagem) pode calcular H(mensagem || dados_do_atacante) sem conhecer a mensagem original. A estrutura de duplo hash do HMAC (hash interno e hash externo com chaves preenchidas diferentes) previne completamente esse ataque. É por isso que os esquemas de assinatura de API usam HMAC em vez de concatenar uma chave secreta à mensagem e fazer hash do resultado.

Por Que Usar um Gerador HMAC Online?

Calcular assinaturas HMAC normalmente requer escrever código ou usar ferramentas de linha de comando. Este gerador HMAC baseado em navegador permite criar assinaturas HMAC-SHA256, HMAC-SHA384 e HMAC-SHA512 instantaneamente, sem instalar software ou abrir um terminal.

Casos de Uso do Gerador HMAC

HMAC vs Hash Simples vs Criptografia

HMAC, hash simples e criptografia servem a propósitos diferentes. O HMAC fornece autenticação de mensagem — prova de que a mensagem foi criada por alguém com a chave secreta e não foi modificada. Um hash simples fornece integridade, mas não autenticação. A criptografia fornece confidencialidade. A tabela abaixo esclarece as distinções.

Comparação de Algoritmos HMAC

O HMAC pode usar qualquer função hash, mas a escolha do algoritmo subjacente determina o tamanho da saída, o nível de segurança e a compatibilidade com o navegador. O HMAC-SHA256 é a opção mais comum para novos sistemas. A tabela abaixo compara as variantes que você provavelmente encontrará.

Como o HMAC Funciona Internamente

O HMAC aplica a função hash subjacente duas vezes com dois preenchimentos derivados de chaves diferentes. A construção é definida na RFC 2104 e provada ser uma PRF (função pseudoaleatória) sob suposições criptográficas padrão. A chave é primeiro preenchida ou hasheada para corresponder ao tamanho do bloco da função hash (64 bytes para SHA-256, 128 bytes para SHA-512).

O algoritmo realiza XOR da chave preenchida com uma constante de preenchimento interna (ipad, 0x36 repetido), concatena com a mensagem e aplica hash ao resultado. Em seguida, realiza XOR da chave preenchida com uma constante de preenchimento externa (opad, 0x5C repetido), concatena com o resultado do hash interno e aplica hash novamente. Essa estrutura de duplo hash é o que previne ataques de extensão de comprimento e garante que a saída do HMAC não possa ser calculada sem conhecimento da chave secreta.

Exemplos de Código HMAC

O HMAC é suportado nativamente em todas as principais linguagens e runtimes. A Web Crypto API fornece HMAC-SHA256, HMAC-SHA384 e HMAC-SHA512 nos navegadores sem nenhuma biblioteca. Os exemplos abaixo mostram padrões de uso reais, incluindo verificação de webhook e comparação em tempo 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)"

Perguntas Frequentes