HMAC-generator & Verifierare

Beräkna och verifiera RFC 2104 HMAC-SHA256-, SHA-384-, SHA-512-, SHA-1- och MD5-signaturer i Hex, Base64 eller Base64URL lokalt i din webbläsare via Web Crypto.

Inga uppladdningarIngen registreringOmedelbara resultat
HMAC-SHA256 · SHA512 · MD5Hex · Base64 · Base64URL100% Lokalt • Noll Uppladdningar
Beräkna HMAC
Offlinemotorn är redo100 % privat arbetsyta i webbläsaren • Inga molnuppladdningar
100 % Privat • Ingen filuppladdning till server

Varför använda Utiliomes gratis HMAC-generator & Verifierare?

Byggd från grunden för strikt integritet, snabb körning och utan krångel. Inga prenumerationer eller konton krävs.

RFC 2104 & FIPS 198-1-kompatibel konstruktion

Implementerar standardiserad blockbaserad inre (0x36) och yttre (0x5c) XOR-nyckelutfyllnad över HMAC-SHA256, HMAC-SHA384, HMAC-SHA512, HMAC-SHA1 och HMAC-MD5, verifierad mot testvektorer i IETF RFC 2202 och RFC 4231.

Avkodning av hemlig nyckel i UTF-8, Hex och Base64

Tolkar signeringshemligheter som UTF-8-text, råa hexadecimala oktetter eller RFC 4648 Base64-bytebuffertar så att binära API-nycklar avkodas till exakta nyckelbyte före HMAC-beräkning.

Signaturverifiering i konstant tid

Validerar inkommande webhook- eller API MAC-headers mot beräknade signaturer med hjälp av Web Crypto crypto.subtle.verify och bitvis XOR-jämförelse med fast längd utan att läcka tidsinformation om prefix.

Webhook-utdata i Hex, Base64 & Base64URL

Genererar kontrollsummor i gemen/versal Hex (GitHub, Stripe, Slack), standardutfylld Base64 (Shopify, AWS) och outfylld Base64URL (JWS/JWT-segment) helt offline i webbläsarens lokala minne.

Utiliome jämfört med molnalternativ

Jämför vår lokala WebAssembly-motor med äldre molnverktyg.

Funktion Utiliome (Lokal webbläsare) Traditionella molnomvandlare
RFC 2104 & FIPS 198-1-kompatibel konstruktion Implementerar standardiserad blockbaserad inre (0x36) och yttre (0x5c) XOR-nyckelutfyllnad över HMAC-SHA256, HMAC-SHA384, HMAC-SHA512, HMAC-SHA1 och HMAC-MD5, verifierad mot testvektorer i IETF RFC 2202 och RFC 4231. Begränsade alternativ utan avancerad anpassning
Avkodning av hemlig nyckel i UTF-8, Hex och Base64 Tolkar signeringshemligheter som UTF-8-text, råa hexadecimala oktetter eller RFC 4648 Base64-bytebuffertar så att binära API-nycklar avkodas till exakta nyckelbyte före HMAC-beräkning. Kräver externa verktyg eller manuell hantering
Integritet och databehandling 100 % lokalt i webbläsaren (ingen serveruppladdning) Laddar upp data till externa molnservrar
Pris och kontokrav 100 % gratis för alltid utan registrering Kräver kontoregistrering eller betald prenumeration
Så fungerar det

Hur du använder HMAC-generator & Verifierare i 3 enkla steg

Ingen programinstallation krävs. Allt körs direkt i din webbläsare.

1

Ange exakt meddelande-payload

Klistra in den råa oformaterade HTTP-requestkroppen eller den kanoniska signeringssträngen – med exakt bevarade blanksteg och nyckelordning – eller släpp en inspelad payload-fil.

2

Konfigurera nyckelkodning & hashfunktion

Ange din delade hemlighet (shared secret), välj dess byterepresentation (UTF-8-klartext, Hex eller Base64) och välj HMAC-SHA256, HMAC-SHA384, HMAC-SHA512, HMAC-SHA1 eller HMAC-MD5.

3

Kopiera MAC eller verifiera inkommande signatur

Kopiera den resulterande kontrollsumman i Hex, Base64 eller Base64URL, eller klistra in en förväntad signatur (utan transportprefix som sha256= eller v0=) för att köra verifiering i konstant tid.

Beräkna och verifiera HMAC-signaturer för webhooks och API:er: Praktisk genomgång

Snabbsvar: Att signera meddelandet what do ya want for nothing? med den 4 byte långa hemligheten Jefe (IETF RFC 4231 Testfall 2) under HMAC-SHA256 ger 5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843 i Hex och W9zBRr9gdU5qBCQmCJV1x1oAPwidJzmDnexYuWTsOEM= i Base64 oavsett om nyckelläget är UTF-8, Hex (4a656665) eller Base64 (SmVmZQ==).

En Keyed-Hash Message Authentication Code (HMAC) bevisar både dataintegritet (att payloaden inte har ändrats under överföringen) och autenticitet (att avsändaren innehar den delade hemliga nyckeln). För att återskapa en tjänsteleverantörs signatur krävs att tre exakta parametrar matchar: den underliggande hashprimitiven, råbyteavkodningen av den hemliga nyckeln och den exakta bytesekvensen för den signerade payloaden.

Exempel 1: IETF RFC 2104 / RFC 2202 / RFC 4231 Testfall 2

Oavsett om du anger den 4 byte långa hemliga nyckeln som UTF-8-text Jefe, rå hexadecimal 4a656665 eller Base64 SmVmZQ==, avkodas den till den identiska nyckelbufferten [0x4a, 0x65, 0x66, 0x65]. Att signera det 28 byte långa UTF-8-meddelandet what do ya want for nothing? ger:

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

Exempel 2: Base64 kontra Base64URL och kanoniska payloads för webhooks

Standard-Base64 (RFC 4648 sektion 4) genererar +, / och avslutande =-utfyllnad, medan URL-säker Base64URL (RFC 4648 sektion 5, som används i JWS/JWT-signaturer och signerade URL:er) ersätter + med -, / med _ och tar bort =-utfyllnad. Att signera The quick brown fox jumps over the lazy dog med UTF-8-nyckeln key under HMAC-SHA256 illustrerar kodningsskillnaden direkt:

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

När du verifierar verkliga webhook-headers måste du konstruera den exakta payloaden som definieras av respektive leverantör innan du tar bort header-prefix:

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>

RFC 2104-konstruktion, regler för nyckelnormalisering och skydd mot timing-attacker

Snabbsvar: RFC 2104 definierar HMAC som H((K_0 XOR opad) || H((K_0 XOR ipad) || m)), där hemliga nycklar normaliseras mot hashfunktionens interna kompressionsblockstorlek B (64 byte för MD5/SHA-1/SHA-256; 128 byte för SHA-384/SHA-512) snarare än dess utdatalängd L.

Definierad i IETF RFC 2104 och NIST FIPS 198-1 kapslar HMAC in valfri iterativ kryptografisk hashfunktion H i en nästlad tvåstegskonstruktion som förhindrar längdförlängningsattacker (length-extension attacks) mot Merkle-Damgård-funktioner:

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

Blockstorlek (`B`) kontra utdatalängd (`L`) och nyckelnormalisering

Ett vanligt implementeringsmisstag i egenbyggd HMAC-kod är att normalisera den hemliga nyckeln K mot kontrollsummans utdatalängd L i byte istället för kompressionsblockets bytelängd B:

  • MD5 (L = 16), SHA-1 (L = 20), SHA-256 (L = 32): Intern blockstorlek B = 64 byte (512 bitar).
  • SHA-384 (L = 48), SHA-512 (L = 64): Intern blockstorlek B = 128 byte (1024 bitar).

Innan XOR-operationen mot ipad (0x36 upprepat B gånger) och opad (0x5c upprepat B gånger) utförs, normaliseras de råa nyckelbyten K till ett exakt B-byteblock K_0:

  1. Korta nycklar (len(K) < B): Fyll på med B - len(K) nollbyte (0x00) till höger om K.
  2. Blockjusterade nycklar (len(K) == B): Använd K oförändrad (K_0 = K).
  3. För långa nycklar (len(K) > B): Hasha K en gång med H(K) för att skapa en L byte lång kontrollsumma, och fyll sedan på med B - L nollbyte (0x00) för att nå B byte.

Enligt RFC 2104 sektion 3 bör hemliga nycklar innehålla minst L byte kryptografisk entropi (>= 32 CSPRNG-byte för HMAC-SHA256, >= 64 CSPRNG-byte för HMAC-SHA512). Nycklar som är kortare än L sänker den effektiva säkerheten mot brute-force under hashfunktionens birthday bound.

Fallgropar vid nyckelkodning och verifiering i konstant tid

  • Hex-sträng kontra råa Hex-byte: Om ett API utfärdar en hemlighet på 64 hexadecimala tecken som 4a656665..., kontrollera om deras SDK behandlar strängen som 64 ASCII UTF-8-byte (0x34 0x61...) eller hex-avkodar den till 32 råa byte (0x4a 0x65...) innan importKey anropas. Genom att växla väljaren för nyckelkodning mellan UTF-8, Hex och Base64 kan du omedelbart isolera avkodningsfel vid integrationsfelsökning.
  • Verifiering i konstant tid: Validera aldrig en opålitlig MAC i serverkod med vanlig strängjämförelse (computedHex === headerHex). Standardjämförelse av strängar returnerar false vid första felaktiga byte, vilket skapar ett tidsorakel på nanosekundnivå som låter fjärrangripare gissa sig fram till giltiga MAC-värden en byte i taget (256 * L gissningar istället för 2^(8*L)). Verifiering i webbläsaren använder crypto.subtle.verify('HMAC', cryptoKey, signatureBuffer, messageBuffer) (eller bitvis XOR-ackumulering med fast längd över avkodade bytearrayer), vilket motsvarar Node.js crypto.timingSafeEqual och Pythons hmac.compare_digest.

HMAC-generator kontra Kryptografisk hash-generator kontra JWT-generator: Vilken behöver du?

Snabbsvar: Använd HMAC-generator för att signera eller verifiera råa payloads (HTTP-kroppar, kanoniska strängar, webhook-händelser) med en delad hemlig nyckel. Använd Kryptografisk hash-generator för kontrollsummor av strängar eller filer utan nyckel, och använd JWT-generator för att bygga strukturerade RFC 7519 JSON Web Tokens signerade med HS256, HS384 eller HS512.

Även om kontrollsummor utan nyckel, råa HMAC-värden och symmetriska JSON Web Tokens delar underliggande SHA-2-primitiver, löser de olika lager av protokollsäkerhet:

Funktion HMAC-generator & Verifierare (Detta verktyg) Kryptografisk hash-generator JWT-generator
Kryptografisk primitiv Nyckelbaserad MAC (RFC 2104 / FIPS 198-1) Kontrollsumma utan nyckel (FIPS 180-4 / RFC 1321) JWS / JWT Token-kuvert (RFC 7515 / RFC 7519)
Kräver hemlig nyckel Ja (UTF-8, Hex eller Base64 delad hemlighet) Nej Ja (Symmetrisk hemlighet eller RSA/ECDSA-nyckelpar)
Säkerhetsgaranti Autenticitet + Dataintegritet Endast oavsiktlig / publik dataintegritet Autentiserade strukturerade anspråk (iss, sub, exp)
Algoritmer som stöds HMAC-SHA256, SHA384, SHA512, SHA1, MD5 MD5, SHA-1, SHA-256, SHA-384, SHA-512 HS256, HS384, HS512 (plus asymmetriska JWS-sviter)
Utdataformat Hex, Base64, Base64URL Gemen/versal Hex, Base64 <header>.<payload>.<signature> (Base64URL)

Välja rätt verktyg

  • Felsöker du filkontrollsummor utan nyckel, W3C SRI-hashar eller ETag-/cachenycklar? Ingen hemlig nyckel är inblandad – använd Kryptografisk hash-generator.
  • Bygger eller inspekterar du Bearer-autentiseringstokens (HS256, HS384, HS512)? Enligt RFC 7515 är en HS256 JWT-signatur strikt den outfyllda Base64URL-utdatan av HMAC-SHA256(secret, ASCII(BASE64URL(header) + "." + BASE64URL(payload))). Även om du kan verifiera det råa tredje segmentet direkt här genom att klistra in <base64url_header>.<base64url_payload> som meddelande och välja Base64URL-utdata, bör du använda JWT-generator för att redigera JSON-headers, validera exp/nbf-tidsstämplar och sätta ihop kompletta tredelade tokens.
  • Symmetrisk HMAC kontra asymmetriska signaturer: Eftersom HMAC är symmetrisk innehar varje tjänst som verifierar en signatur exakt samma hemlighet som krävs för att förfalska nya signaturer. Använd HMAC för punkt-till-punkt-webhooks och betrodda interna tjänster; när obetrodda tredje parter måste verifiera tokens utan signeringsrättigheter bör du använda asymmetriska nycklar (RS256, ES256, EdDSA) i JWT-generator.
FAQ

HMAC-generator & Verifierare FAQ och teknisk guide

Allt du behöver veta om att använda Utiliomes gratis hmac generator online online.

Varför misslyckas min webhook HMAC-verifiering trots att min hemliga nyckel och JSON-fälten ser identiska ut?

Två problem orsakar över 90 % av alla fel vid HMAC-verifiering av webhooks. För det första tolkar och omserialiserar middleware som Express express.json() JSON-data, vilket ändrar blanksteg, Unicode-kodning eller nyckelordning i förhållande till den råa TCP-byteström som avsändaren signerade – signera alltid den råa, otolkade requestbufferten och inkludera leverantörens tidsstämpelprefix (såsom Stripes <timestamp>.<body> eller Slacks v0:<timestamp>:<body>). För det andra bör du kontrollera om leverantörens hemlighet måste avkodas från Base64 eller Hex till råa byte istället för att läsas som en UTF-8-sträng.

Varför är SHA256(secret + message) osäkert jämfört med RFC 2104 HMAC-SHA256?

MD5, SHA-1, SHA-256 och SHA-512 använder Merkle-Damgård-konstruktionen, vars slutliga kontrollsumma exponerar hela det interna kompressionstillståndet. Givet SHA256(secret || message) och bytelängden på secret kan en angripare beräkna SHA256(secret || message || padding || attacker_suffix) utan att någonsin känna till secret (en längdförlängningsattack). RFC 2104 HMAC eliminerar detta genom att mata in den inre kontrollsumman i en andra, nyckelbaserad yttre hash H((K_0 XOR opad) || inner_hash).

Vad händer om min hemliga HMAC-nyckel är längre än 64 eller 128 byte?

Enligt RFC 2104 sektion 2: om en hemlig nyckel strikt överskrider hashfunktionens interna blockstorlek B (len(K) > 64 byte för MD5, SHA-1 och SHA-256; len(K) > 128 byte för SHA-384 och SHA-512), komprimeras nyckeln först genom att hashas en gång med H(K) till L byte och fylls sedan ut till höger med 0x00-byte upp till B byte. Både Web Crypto (crypto.subtle.importKey) och RFC-kompatibla serverbibliotek utför detta förhashningssteg automatiskt.

Vilken utdatakodning ska jag välja för GitHub, Stripe, Slack, Shopify och JWT HS256?

GitHub (X-Hub-Signature-256), Stripe (Stripe-Signature v1) och Slack (X-Slack-Signature v0) skickar alla gemen Hex (lowercase Hex) HMAC-SHA256-kontrollsummor efter sina respektive prefix sha256=, v1= eller v0=. Shopify (X-Shopify-Hmac-Sha256) och AWS Signature v1/v2 använder standardutfylld Base64. JSON Web Tokens (HS256, HS384, HS512) kräver outfylld Base64URL enligt RFC 7515 – se JWT-generator för komplett sammansättning av tokens.

Är HMAC-MD5 och HMAC-SHA1 knäckta av kollisionsattacker mot MD5 och SHA-1?

Inte direkt. Kollisionsattacker mot MD5 och SHA-1 utan nyckel förutsätter att en angripare fritt kan välja meddelandeblock mot en publik, fast initialiseringsvektor (IV), medan HMAC maskerar den interna IV:n bakom hemliga K_0 XOR ipad- och K_0 XOR opad-steg (dokumenterat i IETF RFC 6151). Trots detta avråder NIST SP 800-131A och stora webhook-leverantörer (exempelvis GitHub som fasat ut X-Hub-Signature SHA-1) från HMAC-MD5 och äldre HMAC-SHA1 i nya system – välj alltid HMAC-SHA256 eller HMAC-SHA512 om du inte måste upprätthålla bakåtkompatibilitet med äldre protokoll.