Generatore e Verificatore HMAC

Calcola e verifica firme RFC 2104 HMAC-SHA256, SHA-384, SHA-512, SHA-1 e MD5 in Hex, Base64 o Base64URL localmente nel browser tramite Web Crypto.

Nessun caricamentoNessuna registrazioneRisultati istantanei
HMAC-SHA256 · SHA512 · MD5Hex · Base64 · Base64URL100% Locale • Zero Upload
Calcola HMAC
Motore offline prontoSpazio di lavoro 100% privato nel browser • Zero upload in cloud
100% Privato • Nessun Caricamento File su Server

Perché usare il Generatore e Verificatore HMAC gratuito di Utiliome?

Creato da zero per garantire massima privacy, esecuzione istantanea e zero intoppi. Senza abbonamento né registrazione.

Costruzione Conforme a RFC 2104 e FIPS 198-1

Implementa il padding standard della chiave XOR interno (0x36) ed esterno (0x5c) a dimensione di blocco su HMAC-SHA256, HMAC-SHA384, HMAC-SHA512, HMAC-SHA1 e HMAC-MD5, verificato rispetto ai vettori di test IETF RFC 2202 e RFC 4231.

Decodifica Chiave Segreta in UTF-8, Hex e Base64

Analizza i segreti di firma come testo UTF-8, ottetti esadecimali grezzi o buffer di byte Base64 RFC 4648 in modo che le chiavi API binarie vengano decodificate nei byte esatti della chiave prima della derivazione HMAC.

Modalità di Verifica Firma a Tempo Costante

Convalida gli header MAC in entrata di webhook o API rispetto alle firme calcolate utilizzando crypto.subtle.verify di Web Crypto e il confronto XOR bit a bit a lunghezza fissa senza esporre tempistiche sui prefissi.

Output Webhook in Hex, Base64 e Base64URL

Produce digest in Hex minuscolo/maiuscolo (GitHub, Stripe, Slack), Base64 standard con padding (Shopify, AWS) e Base64URL senza padding (segmenti JWS/JWT) completamente offline nella memoria locale del browser.

Utiliome vs le alternative cloud tradizionali

Confronta il nostro motore locale WebAssembly con i vecchi strumenti in cloud.

Funzionalità Utiliome (Browser Locale) Convertitori Cloud Datati
Costruzione Conforme a RFC 2104 e FIPS 198-1 Implementa il padding standard della chiave XOR interno (0x36) ed esterno (0x5c) a dimensione di blocco su HMAC-SHA256, HMAC-SHA384, HMAC-SHA512, HMAC-SHA1 e HMAC-MD5, verificato rispetto ai vettori di test IETF RFC 2202 e RFC 4231. Opzioni limitate senza personalizzazione avanzata
Decodifica Chiave Segreta in UTF-8, Hex e Base64 Analizza i segreti di firma come testo UTF-8, ottetti esadecimali grezzi o buffer di byte Base64 RFC 4648 in modo che le chiavi API binarie vengano decodificate nei byte esatti della chiave prima della derivazione HMAC. Richiede strumenti esterni o modifiche manuali
Privacy e Elaborazione Dati Elaborazione 100% locale nel browser (zero upload) Carica i dati su server cloud di terze parti
Prezzo e Registrazione 100% gratuito per sempre senza registrazione Richiede registrazione o abbonamento a pagamento
Come funziona

Come usare Generatore e Verificatore HMAC in 3 semplici passaggi

Nessuna installazione richiesta. Tutto viene eseguito direttamente nel tuo browser web.

1

Fornisci il Payload Esatto del Messaggio

Incolla il corpo grezzo non formattato della richiesta HTTP o la stringa canonica di firma—preservando gli spazi bianchi esatti e l'ordine delle chiavi—oppure trascina un file di payload acquisito.

2

Configura Codifica della Chiave Segreta e Hash

Inserisci il tuo segreto condiviso, seleziona la sua rappresentazione in byte (testo in chiaro UTF-8, Hex o Base64) e scegli tra HMAC-SHA256, HMAC-SHA384, HMAC-SHA512, HMAC-SHA1 o HMAC-MD5.

3

Copia il MAC o Verifica la Firma in Entrata

Copia il digest Hex, Base64 o Base64URL risultante, oppure incolla una firma attesa (rimuovendo i prefissi di trasporto come sha256= o v0=) per eseguire una verifica a tempo costante.

Calcolo e Verifica di Firme HMAC per Webhook e API: Guida Pratica

Risposta Rapida: Firmare il messaggio what do ya want for nothing? con il segreto di 4 byte Jefe (Caso di Test 2 IETF RFC 4231) con HMAC-SHA256 produce 5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843 in Hex e W9zBRr9gdU5qBCQmCJV1x1oAPwidJzmDnexYuWTsOEM= in Base64 in tutte le modalità di chiave UTF-8, Hex (4a656665) e Base64 (SmVmZQ==).

Un Keyed-Hash Message Authentication Code (HMAC) dimostra sia l'integrità dei dati (il payload non è stato alterato durante il transito) sia l'autenticità (il mittente possiede la chiave segreta condivisa). Riprodurre la firma di un provider richiede la corrispondenza esatta di tre parametri: la primitiva di hash sottostante, la decodifica in byte grezzi della chiave segreta e la sequenza esatta di byte del payload firmato.

Esempio 1: Caso di Test 2 IETF RFC 2104 / RFC 2202 / RFC 4231

Sia che tu inserisca la chiave segreta di 4 byte come testo UTF-8 Jefe, esadecimale grezzo 4a656665 o Base64 SmVmZQ==, essa viene decodificata nell'identico buffer di chiave [0x4a, 0x65, 0x66, 0x65]. Firmando il messaggio UTF-8 di 28 byte what do ya want for nothing? si ottiene:

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

Esempio 2: Base64 vs Base64URL e Payload Canonici dei Webhook

Il formato Base64 standard (RFC 4648 Sezione 4) emette +, / e il padding finale =, mentre il formato URL-safe Base64URL (RFC 4648 Sezione 5, utilizzato nelle firme JWS/JWT e negli URL firmati) sostituisce + con -, / con _ e rimuove il padding =. Firmare The quick brown fox jumps over the lazy dog con la chiave UTF-8 key sotto HMAC-SHA256 illustra direttamente la differenza di codifica:

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

Quando verifichi gli header dei webhook reali, costruisci l'esatto payload pre-firma definito da ciascun provider prima di rimuovere i prefissi degli header:

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>

Costruzione RFC 2104, Regole di Normalizzazione della Chiave e Resistenza ai Timing Attack

Risposta Rapida: L'RFC 2104 definisce l'HMAC come H((K_0 XOR opad) || H((K_0 XOR ipad) || m)), normalizzando le chiavi segrete rispetto alla dimensione del blocco di compressione interno B della funzione di hash (64 byte per MD5/SHA-1/SHA-256; 128 byte per SHA-384/SHA-512) anziché rispetto alla lunghezza di output del digest L.

Definito in IETF RFC 2104 e NIST FIPS 198-1, l'HMAC avvolge qualsiasi funzione di hash crittografica iterativa H in un involucro annidato a due passaggi che previene gli attacchi di estensione della lunghezza (length-extension attack) su Merkle-Damgard:

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

Dimensione del Blocco (`B`) vs Lunghezza di Output (`L`) e Normalizzazione della Chiave

Un errore di implementazione frequente nel codice HMAC personalizzato consiste nel normalizzare la chiave segreta K rispetto alla lunghezza in byte dell'output del digest L invece che rispetto alla lunghezza in byte del blocco di compressione B:

  • MD5 (L = 16), SHA-1 (L = 20), SHA-256 (L = 32): Dimensione del blocco interno B = 64 byte (512 bit).
  • SHA-384 (L = 48), SHA-512 (L = 64): Dimensione del blocco interno B = 128 byte (1024 bit).

Prima di eseguire lo XOR con ipad (0x36 ripetuto B volte) e opad (0x5c ripetuto B volte), i byte grezzi della chiave K vengono normalizzati in un blocco K_0 di esattamente B byte:

  1. Chiavi corte (len(K) < B): Aggiungi B - len(K) byte zero (0x00) a destra di K.
  2. Chiavi allineate al blocco (len(K) == B): Usa K senza modifiche (K_0 = K).
  3. Chiavi sovradimensionate (len(K) > B): Calcola l'hash di K una volta usando H(K) per produrre un digest di L byte, quindi aggiungi B - L byte zero (0x00) per raggiungere B byte.

Secondo l'RFC 2104 Sezione 3, le chiavi segrete dovrebbero contenere almeno L byte di entropia crittografica (>= 32 byte CSPRNG per HMAC-SHA256, >= 64 byte CSPRNG per HMAC-SHA512). Chiavi più corte di L riducono l'efficace sicurezza contro attacchi brute-force al di sotto del limite del compleanno (birthday bound) dell'hash.

Insidie nella Codifica della Chiave e Verifica a Tempo Costante

  • Stringa Hex vs Byte Hex Grezzi: Se un'API emette un segreto esadecimale di 64 caratteri come 4a656665..., verifica se il relativo SDK tratta quella stringa come 64 byte ASCII UTF-8 (0x34 0x61...) oppure se la decodifica da esadecimale in 32 byte grezzi (0x4a 0x65...) prima di chiamare importKey. Commutare il selettore di Codifica Chiave tra UTF-8, Hex e Base64 isola immediatamente le discrepanze di decodifica della chiave durante il debug dell'integrazione.
  • Verifica a Tempo Costante: Non convalidare mai un MAC non attendibile nel codice server utilizzando l'uguaglianza standard tra stringhe (computedHex === headerHex). Il confronto standard tra stringhe restituisce false al primo byte non corrispondente, creando un oracolo temporale (timing oracle) su scala di nanosecondi che consente ad attaccanti remoti di forzare tramite brute-force MAC validi un byte alla volta (256 * L tentativi invece di 2^(8*L)). La verifica nel browser utilizza crypto.subtle.verify('HMAC', cryptoKey, signatureBuffer, messageBuffer) (o l'accumulazione XOR bit a bit a lunghezza fissa su array di byte decodificati), rispecchiando crypto.timingSafeEqual di Node.js e hmac.compare_digest di Python.

Generatore HMAC vs Generatore di Hash Crittografici vs Generatore JWT: Quale Scegliere?

Risposta Rapida: Usa il Generatore HMAC per firmare o verificare payload grezzi (corpi HTTP, stringhe canoniche, eventi webhook) con una chiave segreta condivisa. Usa il Generatore di Hash Crittografici per digest di stringhe o file senza chiave, e usa il Generatore JWT per costruire JSON Web Token strutturati RFC 7519 firmati con HS256, HS384 o HS512.

Sebbene i digest senza chiave, gli HMAC grezzi e i JSON Web Token simmetrici condividano le primitive SHA-2 sottostanti, essi risolvono livelli distinti di sicurezza dei protocolli:

Caratteristica Generatore e Verificatore HMAC (Questo Strumento) Generatore di Hash Crittografici Generatore JWT
Primitiva Crittografica MAC con chiave (RFC 2104 / FIPS 198-1) Digest senza chiave (FIPS 180-4 / RFC 1321) Involucro Token JWS / JWT (RFC 7515 / RFC 7519)
Richiede Chiave Segreta Sì (segreto condiviso UTF-8, Hex o Base64) No Sì (Segreto simmetrico o coppia di chiavi RSA/ECDSA)
Garanzia di Sicurezza Autenticità + Integrità dei Dati Solo Integrità dei Dati Accidentale / Pubblica Claim Strutturati Autenticati (iss, sub, exp)
Algoritmi Supportati HMAC-SHA256, SHA384, SHA512, SHA1, MD5 MD5, SHA-1, SHA-256, SHA-384, SHA-512 HS256, HS384, HS512 (più suite JWS asimmetriche)
Formato di Output Hex, Base64, Base64URL Hex Minuscolo/Maiuscolo, Base64 <header>.<payload>.<signature> (Base64URL)

Scegliere l'Utility Giusta

  • Debug di digest di file senza chiave, hash W3C SRI o chiavi ETag / cache? Non è coinvolta alcuna chiave segreta: usa il Generatore di Hash Crittografici.
  • Costruzione o ispezione di token di autenticazione bearer (HS256, HS384, HS512)? Secondo l'RFC 7515, una firma JWT HS256 è rigorosamente l'output Base64URL senza padding di HMAC-SHA256(secret, ASCII(BASE64URL(header) + "." + BASE64URL(payload))). Sebbene tu possa verificare direttamente il terzo segmento grezzo qui incollando <base64url_header>.<base64url_payload> come messaggio e selezionando l'output Base64URL, usa il Generatore JWT per modificare gli header JSON, convalidare i timestamp exp/nbf e assemblare token completi a tre parti.
  • HMAC Simmetrico vs Firme Asimmetriche: Poiché l'HMAC è simmetrico, ogni servizio che verifica una firma possiede l'esatto segreto necessario per falsificare nuove firme. Usa l'HMAC per webhook punto-punto e servizi interni fidati; quando terze parti non attendibili devono verificare i token senza privilegi di firma, usa chiavi asimmetriche (RS256, ES256, EdDSA) nel Generatore JWT.
Domande frequenti

FAQ e Guida Tecnica su Generatore e Verificatore HMAC

Tutto ciò che devi sapere sull'uso di generatore hmac online e gratuito di Utiliome.

Perché la verifica HMAC del mio webhook fallisce anche quando la chiave segreta e i campi JSON sembrano identici?

Due problemi causano oltre il 90% delle mancate corrispondenze HMAC nei webhook. Innanzitutto, middleware come express.json() di Express analizzano e ri-serializzano il JSON, alterando spazi bianchi, escaping Unicode o l'ordine delle chiavi rispetto al flusso di byte TCP grezzo firmato dal mittente: firma sempre il buffer della richiesta grezzo non analizzato e includi i prefissi di timestamp del provider (come <timestamp>.<body> di Stripe o v0:<timestamp>:<body> di Slack). In secondo luogo, verifica se il segreto del provider deve essere decodificato da Base64 o Hex in byte grezzi anziché essere letto come stringa UTF-8.

Perché SHA256(secret + message) è insicuro rispetto a HMAC-SHA256 RFC 2104?

MD5, SHA-1, SHA-256 e SHA-512 utilizzano la costruzione di Merkle-Damgard, il cui digest finale espone l'intero stato di compressione interno. Dati SHA256(secret || message) e la lunghezza in byte di secret, un attaccante può calcolare SHA256(secret || message || padding || attacker_suffix) senza mai conoscere secret (un attacco di estensione della lunghezza o length-extension attack). L'HMAC RFC 2104 elimina questo problema passando il digest interno in un secondo hash esterno con chiave H((K_0 XOR opad) || inner_hash).

Cosa succede se la mia chiave segreta HMAC è più lunga di 64 o 128 byte?

Secondo l'RFC 2104 Sezione 2, se una chiave segreta supera strettamente la dimensione del blocco interno B della funzione di hash (len(K) > 64 byte per MD5, SHA-1 e SHA-256; len(K) > 128 byte per SHA-384 e SHA-512), la chiave viene prima compressa calcolandone l'hash una volta con H(K) in L byte e poi riempita a destra (right-padded) con byte 0x00 fino a raggiungere B byte. Sia Web Crypto (crypto.subtle.importKey) sia le librerie server conformi alle RFC eseguono questo passaggio di pre-hashing automaticamente.

Quale codifica di output devo selezionare per GitHub, Stripe, Slack, Shopify e JWT HS256?

GitHub (X-Hub-Signature-256), Stripe (Stripe-Signature v1) e Slack (X-Slack-Signature v0) trasmettono tutti digest HMAC-SHA256 in Hex minuscolo dopo i rispettivi prefissi sha256=, v1= o v0=. Shopify (X-Shopify-Hmac-Sha256) e AWS Signature v1/v2 utilizzano il formato Base64 standard con padding. I JSON Web Token (HS256, HS384, HS512) richiedono Base64URL senza padding secondo l'RFC 7515: consulta il Generatore JWT per l'assemblaggio completo del token.

HMAC-MD5 e HMAC-SHA1 sono compromessi dagli attacchi di collisione su MD5 e SHA-1?

Non direttamente. Gli attacchi di collisione contro MD5 e SHA-1 senza chiave si basano sulla possibilità per un attaccante di scegliere liberamente i blocchi del messaggio rispetto a un IV pubblico fisso, mentre l'HMAC maschera l'IV interno dietro i passaggi segreti K_0 XOR ipad e K_0 XOR opad (documentato in IETF RFC 6151). Ciò nonostante, la normativa NIST SP 800-131A e i principali provider di webhook (come GitHub che ha ritirato X-Hub-Signature SHA-1) deprecano HMAC-MD5 e il legacy HMAC-SHA1 per i nuovi sistemi: scegli sempre HMAC-SHA256 o HMAC-SHA512 a meno che tu non debba mantenere la compatibilità con protocolli legacy.