HMAC-generator & Verifier

Bereken en verifieer RFC 2104 HMAC-SHA256, SHA-384, SHA-512, SHA-1 en MD5-handtekeningen in Hex, Base64 of Base64URL lokaal in je browser via Web Crypto.

Geen uploadsGeen registratieDirect resultaat
HMAC-SHA256 · SHA512 · MD5Hex · Base64 · Base64URL100% Lokaal • Geen Uploads
HMAC berekenen
Offline engine gereed100% privé in-browser werkomgeving • Nul cloud-uploads
100% Privé • Geen Server Uploads

Waarom Utiliome's gratis HMAC-generator & Verifier gebruiken?

Van de grond af opgebouwd voor strikte privacy, directe uitvoering en nul wrijving. Geen registratie nodig.

RFC 2104 & FIPS 198-1 conforme constructie

Implementeert standaard blokgrootte inner (0x36) en outer (0x5c) XOR-sleutelpadding voor HMAC-SHA256, HMAC-SHA384, HMAC-SHA512, HMAC-SHA1 en HMAC-MD5, gevalideerd tegen IETF RFC 2202 en RFC 4231 testvectoren.

UTF-8-, Hex- en Base64-sleuteldecodering

Verwerkt geheime ondertekeningssleutels als UTF-8-tekst, ruwe hexadecimale octetten of RFC 4648 Base64-bytebuffers, zodat binaire API-sleutels vóór de HMAC-afleiding exact naar de juiste sleutelbytes worden gedecodeerd.

Constant-Time handtekeningverificatie

Valideert binnenkomende webhook- of API-MAC-headers tegen berekende handtekeningen met behulp van Web Crypto crypto.subtle.verify en bitwise XOR-vergelijking met vaste lengte, zonder timing-informatie over prefixen te lekken.

Hex-, Base64- & Base64URL-webhook-uitvoer

Genereert digests in kleine/hoofdletters Hex (GitHub, Stripe, Slack), standaard Base64 met padding (Shopify, AWS) en Base64URL zonder padding (JWS/JWT-segmenten) volledig offline in het lokale browsergeheugen.

Utiliome vs. traditionele cloudtools

Vergelijk onze lokale WebAssembly-engine met verouderde cloudtools.

Functie Utiliome (Lokale Browser) Verouderde Cloud Converters
RFC 2104 & FIPS 198-1 conforme constructie Implementeert standaard blokgrootte inner (0x36) en outer (0x5c) XOR-sleutelpadding voor HMAC-SHA256, HMAC-SHA384, HMAC-SHA512, HMAC-SHA1 en HMAC-MD5, gevalideerd tegen IETF RFC 2202 en RFC 4231 testvectoren. Beperkte opties zonder geavanceerde aanpassing
UTF-8-, Hex- en Base64-sleuteldecodering Verwerkt geheime ondertekeningssleutels als UTF-8-tekst, ruwe hexadecimale octetten of RFC 4648 Base64-bytebuffers, zodat binaire API-sleutels vóór de HMAC-afleiding exact naar de juiste sleutelbytes worden gedecodeerd. Vereist externe tools of handmatige bewerking
Privacy & Gegevensverwerking 100% lokale verwerking in je browser (geen uploads) Uploadt gegevens naar externe cloudservers
Prijsmodel & Accountvereisten 100% gratis voor altijd zonder registratie Vereist accountregistratie of betaald abonnement
Hoe het werkt

Hoe HMAC-generator & Verifier te gebruiken in 3 eenvoudige stappen

Geen software-installatie vereist. Alles draait direct in je webbrowser.

1

Lever de exacte bericht-payload aan

Plak de ruwe, onbewerkte HTTP-request-body of canonieke signing-string — met behoud van exacte witruimte en sleutelvolgorde — of sleep een opgeslagen payload-bestand in het vak.

2

Configureer sleutelcodering & hash-algoritme

Voer je gedeelde geheime sleutel (shared secret) in, selecteer de byte-representatie (UTF-8 platte tekst, Hex of Base64) en kies HMAC-SHA256, HMAC-SHA384, HMAC-SHA512, HMAC-SHA1 of HMAC-MD5.

3

Kopieer MAC of verifieer binnenkomende handtekening

Kopieer de resulterende Hex-, Base64- of Base64URL-digest, of plak een verwachte handtekening (zonder transportprefixen zoals sha256= of v0=) om een constant-time verificatie uit te voeren.

Webhook- & API-HMAC-handtekeningen berekenen en verifiëren: Praktische handleiding

Kort antwoord: Het ondertekenen van het bericht what do ya want for nothing? met het 4-byte geheim Jefe (IETF RFC 4231 Test Case 2) onder HMAC-SHA256 levert 5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843 op in Hex en W9zBRr9gdU5qBCQmCJV1x1oAPwidJzmDnexYuWTsOEM= in Base64, ongeacht of de sleutel als UTF-8, Hex (4a656665) of Base64 (SmVmZQ==) wordt ingevoerd.

Een Keyed-Hash Message Authentication Code (HMAC) bewijst zowel de data-integriteit (de payload is onderweg niet gewijzigd) als de authenticiteit (de afzender beschikt over de gedeelde geheime sleutel). Om de handtekening van een provider te reproduceren, moeten drie exacte parameters overeenkomen: de onderliggende hash-functie, de ruwe byte-decodering van de geheime sleutel en de exacte byte-reeks van de ondertekende payload.

Voorbeeld 1: IETF RFC 2104 / RFC 2202 / RFC 4231 Test Case 2

Of je de geheime sleutel van 4 bytes nu invoert als UTF-8-tekst Jefe, ruwe hexadecimale waarde 4a656665 of Base64 SmVmZQ==, deze wordt altijd gedecodeerd naar exact dezelfde sleutelbuffer [0x4a, 0x65, 0x66, 0x65]. Het ondertekenen van het 28-byte UTF-8-bericht what do ya want for nothing? geeft het volgende resultaat:

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

Voorbeeld 2: Base64 vs. Base64URL en canonieke webhook-payloads

Standaard Base64 (RFC 4648 Sectie 4) gebruikt +, / en afsluitende =-padding, terwijl URL-veilige Base64URL (RFC 4648 Sectie 5, gebruikt in JWS/JWT-handtekeningen en ondertekende URL's) + vervangt door -, / door _ en de =-padding weglaat. Het ondertekenen van The quick brown fox jumps over the lazy dog met de UTF-8-sleutel key onder HMAC-SHA256 laat dit coderingsverschil direct zien:

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

Bij het verifiëren van echte webhook-headers moet je eerst de exacte pre-signing payload samenstellen zoals gedefinieerd door de betreffende provider, voordat je de header-prefixen verwijdert:

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 constructie, sleutelnormalisatie en bescherming tegen timing-aanvallen

Kort antwoord: RFC 2104 definieert HMAC als H((K_0 XOR opad) || H((K_0 XOR ipad) || m)), waarbij geheime sleutels worden genormaliseerd op basis van de interne compressieblokgrootte B van de hash-functie (64 bytes voor MD5/SHA-1/SHA-256; 128 bytes voor SHA-384/SHA-512) in plaats van de digest-uitvoerlengte L.

Zoals gedefinieerd in IETF RFC 2104 en NIST FIPS 198-1, wikkelt HMAC elke iteratieve cryptografische hash-functie H in een geneste tweetraps-envelop die Merkle-Damgard length-extension-aanvallen voorkomt:

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

Blokgrootte (`B`) vs. uitvoerlengte (`L`) en sleutelnormalisatie

Een veelvoorkomende implementatiefout in op maat gemaakte HMAC-code is het normaliseren van de geheime sleutel K tegen de byte-lengte van de digest-uitvoer L in plaats van de byte-lengte van het compressieblok B:

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

Voordat de XOR-bewerking plaatsvindt met ipad (0x36 B keer herhaald) en opad (0x5c B keer herhaald), worden de ruwe sleutelbytes K genormaliseerd naar een exact blok K_0 van B bytes:

  1. Korte sleutels (len(K) < B): Voeg rechts van K precies B - len(K) nul-bytes (0x00) toe.
  2. Blok-uitgelijnde sleutels (len(K) == B): Gebruik K ongewijzigd (K_0 = K).
  3. Te lange sleutels (len(K) > B): Hash K eenmalig met H(K) om een digest van L bytes te maken, en voeg vervolgens B - L nul-bytes (0x00) toe om op B bytes uit te komen.

Volgens RFC 2104 Sectie 3 moeten geheime sleutels ten minste L bytes aan cryptografische entropie bevatten (>= 32 CSPRNG-bytes voor HMAC-SHA256, >= 64 CSPRNG-bytes voor HMAC-SHA512). Sleutels korter dan L verlagen de effectieve brute-force-beveiliging tot onder de verjaardagsgrens (birthday bound) van de hash.

Valkuilen bij sleutelcodering en Constant-Time verificatie

  • Hex-string vs. ruwe Hex-bytes: Als een API een hex-geheim van 64 tekens uitgeeft zoals 4a656665..., controleer dan of hun SDK die string behandelt als 64 ASCII UTF-8-bytes (0x34 0x61...) of deze eerst hex-decodeert naar 32 ruwe bytes (0x4a 0x65...) voordat importKey wordt aangeroepen. Door de sleutelcodering te wisselen tussen UTF-8, Hex en Base64 spoor je fouten in de sleuteldecodering tijdens het debuggen van integraties direct op.
  • Constant-Time verificatie: Valideer een onvertrouwde MAC in servercode nooit met een standaard string-vergelijking (computedHex === headerHex). Een standaard string-vergelijking retourneert false zodra de eerste afwijkende byte wordt gevonden. Dit creëert een timing-orakel op nanosecondeschaal waarmee externe aanvallers geldige MAC's byte voor byte kunnen brute-forcen (256 * L pogingen in plaats van 2^(8*L)). De browserverificatie gebruikt crypto.subtle.verify('HMAC', cryptoKey, signatureBuffer, messageBuffer) (of bitwise XOR-accumulatie met vaste lengte over gedecodeerde byte-arrays), vergelijkbaar met Node.js crypto.timingSafeEqual en Python hmac.compare_digest.

HMAC Generator vs. Cryptografische Hash Generator vs. JWT Generator: Welke heb je nodig?

Kort antwoord: Gebruik de HMAC Generator om ruwe payloads (HTTP-bodies, canonieke strings, webhook-events) te ondertekenen of te verifiëren met een gedeelde geheime sleutel. Gebruik de Cryptografische Hash Generator voor sleutelloze string- of bestands-digests, en gebruik de JWT Generator om gestructureerde RFC 7519 JSON Web Tokens te bouwen die zijn ondertekend met HS256, HS384 of HS512.

Hoewel sleutelloze digests, ruwe HMAC's en symmetrische JSON Web Tokens dezelfde onderliggende SHA-2-primitieven delen, lossen ze verschillende lagen van protocolbeveiliging op:

Kenmerk HMAC Generator & Verifier (Deze tool) Cryptografische Hash Generator JWT Generator
Cryptografisch primitief Keyed MAC (RFC 2104 / FIPS 198-1) Sleutelloze Digest (FIPS 180-4 / RFC 1321) JWS / JWT Token-envelop (RFC 7515 / RFC 7519)
Vereist geheime sleutel Ja (UTF-8, Hex of Base64 shared secret) Nee Ja (Symmetrisch geheim of RSA/ECDSA-sleutelpaar)
Beveiligingsgarantie Authenticiteit + Data-integriteit Alleen onopzettelijke / publieke data-integriteit Geauthenticeerde gestructureerde claims (iss, sub, exp)
Ondersteunde algoritmen HMAC-SHA256, SHA384, SHA512, SHA1, MD5 MD5, SHA-1, SHA-256, SHA-384, SHA-512 HS256, HS384, HS512 (plus asymmetrische JWS-suites)
Uitvoerformaat Hex, Base64, Base64URL Kleine/hoofdletters Hex, Base64 <header>.<payload>.<signature> (Base64URL)

De juiste tool kiezen

  • Sleutelloze bestands-digests, W3C SRI-hashes of ETag-/cache-sleutels debuggen? Hier komt geen geheime sleutel aan te pas — gebruik de Cryptografische Hash Generator.
  • Bearer-authenticatietokens (HS256, HS384, HS512) bouwen of inspecteren? Volgens RFC 7515 is een HS256 JWT-handtekening strikt de Base64URL-uitvoer (zonder padding) van HMAC-SHA256(secret, ASCII(BASE64URL(header) + "." + BASE64URL(payload))). Hoewel je het ruwe derde segment hier direct kunt verifiëren door <base64url_header>.<base64url_payload> als bericht te plakken en Base64URL-uitvoer te kiezen, gebruik je de JWT Generator om JSON-headers te bewerken, exp/nbf-tijdstempels te valideren en volledige driedelige tokens samen te stellen.
  • Symmetrische HMAC vs. asymmetrische handtekeningen: Omdat HMAC symmetrisch is, beschikt elke service die een handtekening verifieert over exact hetzelfde geheim dat nodig is om nieuwe handtekeningen te vervalsen. Gebruik HMAC voor point-to-point webhooks en vertrouwde interne services; wanneer externe partijen tokens moeten verifiëren zonder ondertekeningsrechten, gebruik je asymmetrische sleutels (RS256, ES256, EdDSA) in de JWT Generator.
Veelgestelde vragen

HMAC-generator & Verifier FAQ en Technische Gids

Alles wat je moet weten over het gebruik van Utiliome's gratis online hmac generator.

Waarom mislukt mijn webhook HMAC-verificatie, zelfs als mijn geheime sleutel en JSON-velden er identiek uitzien?

Twee problemen veroorzaken meer dan 90% van alle webhook HMAC-fouten. Ten eerste parsen en her-serialiseren middlewares zoals Express express.json() de JSON, waardoor witruimte, Unicode-escaping of de sleutelvolgorde verandert ten opzichte van de ruwe TCP-bytestroom die de afzender heeft ondertekend — onderteken daarom altijd de ruwe, onbewerkte request-buffer en neem tijdstempel-prefixen van de provider mee (zoals Stripe's <timestamp>.<body> of Slack's v0:<timestamp>:<body>). Controleer ten tweede of het geheim van de provider vanuit Base64 of Hex naar ruwe bytes moet worden gedecodeerd in plaats van als UTF-8-string te worden ingelezen.

Waarom is SHA256(secret + message) onveilig vergeleken met RFC 2104 HMAC-SHA256?

MD5, SHA-1, SHA-256 en SHA-512 maken gebruik van de Merkle-Damgard-constructie, waarbij de uiteindelijke digest de volledige interne compressiestatus blootlegt. Met kennis van SHA256(secret || message) en de byte-lengte van secret kan een aanvaller SHA256(secret || message || padding || attacker_suffix) berekenen zonder secret ooit te kennen (een length-extension-aanval). RFC 2104 HMAC voorkomt dit door de binnenste digest als invoer te gebruiken voor een tweede, van een sleutel voorziene buitenste hash H((K_0 XOR opad) || inner_hash).

Wat gebeurt er als mijn geheime HMAC-sleutel langer is dan 64 of 128 bytes?

Volgens RFC 2104 Sectie 2 wordt een geheime sleutel die strikt groter is dan de interne blokgrootte B van de hash-functie (len(K) > 64 bytes voor MD5, SHA-1 en SHA-256; len(K) > 128 bytes voor SHA-384 en SHA-512) eerst gecomprimeerd door deze eenmalig te hashen met H(K) tot L bytes, en vervolgens aan de rechterkant aangevuld met 0x00-bytes tot B bytes. Zowel Web Crypto (crypto.subtle.importKey) als RFC-conforme serverbibliotheken voeren deze pre-hashing-stap automatisch uit.

Welke uitvoercodering moet ik kiezen voor GitHub, Stripe, Slack, Shopify en JWT HS256?

GitHub (X-Hub-Signature-256), Stripe (Stripe-Signature v1) en Slack (X-Slack-Signature v0) versturen allemaal kleine letters Hex HMAC-SHA256-digests na hun respectievelijke sha256=, v1= of v0= prefixen. Shopify (X-Shopify-Hmac-Sha256) en AWS Signature v1/v2 gebruiken standaard Base64 met padding. JSON Web Tokens (HS256, HS384, HS512) vereisen Base64URL zonder padding volgens RFC 7515 — zie de JWT Generator voor het volledig samenstellen van tokens.

Zijn HMAC-MD5 en HMAC-SHA1 gekraakt door MD5- en SHA-1-collision-aanvallen?

Niet direct. Collision-aanvallen op sleutelloze MD5 en SHA-1 zijn ervan afhankelijk dat een aanvaller vrijelijk berichtblokken kan kiezen tegen een publieke, vaste initialisatievector (IV), terwijl HMAC de interne IV afschermt achter geheime K_0 XOR ipad- en K_0 XOR opad-stappen (gedocumenteerd in IETF RFC 6151). Desondanks raden NIST SP 800-131A en grote webhook-providers (zoals GitHub dat X-Hub-Signature op basis van SHA-1 heeft uitgefaseerd) HMAC-MD5 en verouderde HMAC-SHA1 af voor nieuwe systemen — kies altijd HMAC-SHA256 of HMAC-SHA512, tenzij je compatibiliteit met legacy-protocollen moet ondersteunen.