HMAC-generator en handtekeningverificatie

Wat is een HMAC?

const crypto = require('crypto');

// HMAC-SHA256 with a UTF-8 text key, hex output
const hmac = crypto
  .createHmac('sha256', 'my-secret-key')
  .update('Hello, World!')
  .digest('hex');

console.log(hmac);
// → 'cf3141611e22ea26a9cac6fe41d941274dd6653622c83cba13972d177bd69699'

// Verify a signature in constant time
function verify(message, key, expectedHex) {
  const actual = crypto.createHmac('sha256', key).update(message).digest();
  const expected = Buffer.from(expectedHex, 'hex');
  return actual.length === expected.length &&
    crypto.timingSafeEqual(actual, expected);
}

Belangrijkste functies

HMAC-voorbeelden

Hello, World!

cf3141611e22ea26a9cac6fe41d941274dd6653622c83cba13972d177bd69699

{"id":42,"event":"user.created"}

Cd2f7zTKaJFeG6k+t1FcvDPn51OAZ2f4GrxkCUgMhGs=

what do ya want for nothing?

5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843

The quick brown fox

36f44b125a8a90639dc46733039571792e081e0fd8685ff746784b02ed14aa35629d562c7117cde4a701570551faa5a5e1b7ef1eb5c3bcd4cc1fdb8923fcf14e

Een HMAC genereren en verifiëren

1. 1

   Kies het algoritme

   Kies HMAC-SHA256 (de standaard en de juiste keuze voor vrijwel alle webhooks, API's en JWT's), of schakel over naar SHA-1, SHA-384 of SHA-512 om aan te sluiten op een systeem dat dat vereist. Alle vier draaien native in je browser via de Web Crypto API.

2. 2

   Voer de geheime sleutel in en stel de codering in

   Typ of plak je geheime sleutel en stel de Sleutelcodering in zodat die overeenkomt met hoe de server hem interpreteert: Tekst (UTF-8) voor een gewone string, Hex voor een hexadecimale blob, of Base64 voor een base64-geheim. Dit fout instellen is de belangrijkste oorzaak van HMAC-verschillen, dus bij twijfel probeer je alle drie.

3. 3

   Voer het bericht in

   Plak de exacte bytes die je wilt ondertekenen — voor een webhook is dat de ruwe verzoekbody, byte voor byte, zonder her-serialisatie of wijzigingen in witruimte. De HMAC wordt live herberekend terwijl je bewerkt, zonder dat er iets naar een server wordt gestuurd.

4. 4

   Kies het uitvoerformaat en kopieer

   Selecteer Hex (GitHub-stijl), Base64 (Stripe/AWS-stijl) of Base64URL (JWT-stijl) om aan te sluiten op wat je integratie verwacht, en klik dan op Kopiëren om de handtekening over te nemen.

5. 5

   Verifieer een bestaande handtekening

   Schakel naar het tabblad Verifiëren, plak de verwachte HMAC uit een header of token, en de tool bevestigt in constante tijd of je berekende handtekening matcht — zodat je een payload kunt authenticeren voordat je erop reageert.

Veelgemaakte HMAC-fouten

// Server stored a base64 secret but you sign the literal string
createHmac('sha256', 'c2VjcmV0LWtleQ==').update(msg)

// Decode the base64 secret to raw bytes first
createHmac('sha256', Buffer.from('c2VjcmV0LWtleQ==', 'base64')).update(msg)

// Provider sends base64, you compare hex
expected = 'Cd2f7z...=' // base64
actual   = digest('hex') // hex — never matches

// Produce the same encoding the provider uses
actual = digest('base64')

// Re-serialization changes the bytes
body = JSON.stringify(JSON.parse(rawBody))
verify(hmac(body))

// Sign the raw bytes exactly as received
verify(hmac(rawBody))

if (received === computed) { /* trust */ }

if (crypto.timingSafeEqual(receivedBuf, computedBuf)) { /* trust */ }

Waarvoor HMAC wordt gebruikt

Webhook-handtekeningen verifiëren

Providers als GitHub, Stripe, Slack en Twilio ondertekenen elke webhook met HMAC over de verzoekbody en een geheim dat alleen jij deelt. Herbereken de tag en vergelijk hem met de header (bijvoorbeeld X-Hub-Signature-256) om te bevestigen dat de gebeurtenis echt is voordat je erop reageert. Gebruik het tabblad Verifiëren om dit te doen zonder wegwerpcode te schrijven.

API-verzoeken ondertekenen

Geauthenticeerde API's vereisen vaak dat de client het verzoek met HMAC ondertekent (methode, pad, timestamp, body) met een gedeeld geheim in plaats van het geheim zelf te versturen. AWS Signature Version 4 is het canonieke voorbeeld. Met deze tool kun je die handtekeningen stap voor stap reproduceren en debuggen.

Berichtintegriteit garanderen

Wanneer je een token, cookie of bericht tussen services doorgeeft, laat een bijgevoegde HMAC de ontvanger elke manipulatie detecteren. Omdat de tag van een geheim afhangt, kan een aanvaller hem niet herberekenen na het wijzigen van de data — anders dan bij een gewone checksum.

JWT HS256-ondertekening begrijpen

Een met HS256 ondertekende JWT is gewoon base64url(header) + '.' + base64url(payload), ondertekend met HMAC-SHA256 en het resultaat uitgegeven als Base64URL. Zet het algoritme op SHA-256 en de uitvoer op Base64URL hier om precies te zien hoe die handtekening tot stand komt, en controleer het dan in de JWT-encoder.

Een niet-matchende handtekening debuggen

Wanneer je HMAC niet matcht met die van de server, is deze tool de snelste manier om te isoleren waarom: probeer de sleutel als Tekst, Hex en Base64, wissel de uitvoer tussen Hex en Base64, en bevestig dat je precies de ruwe bytes ondertekent — allemaal zonder code opnieuw te deployen.

Hoe HMAC werkt

RFC 2104-constructie

HMAC is gedefinieerd als H((K ⊕ opad) ‖ H((K ⊕ ipad) ‖ m)), waarbij ipad de byte 0x36 herhaald is en opad 0x5c herhaald, beide tot de blokgrootte van de hash. Een sleutel langer dan de blokgrootte wordt eerst gehasht; een kortere sleutel wordt met nullen opgevuld. Deze nesting met twee passes is wat HMAC zijn beveiligingsbewijs geeft, dat geldt zelfs als de onderliggende hash niet botsingsbestendig is.

Waarom een gesleutelde hash een gewone hash verslaat

Een gewone hash bewijst alleen dat data niet per ongeluk beschadigd is, want iedereen kan hem herberekenen voor elk bericht — ook een gemanipuleerd. HMAC mengt er een geheim doorheen, zodat alleen sleutelhouders een geldige tag kunnen produceren. Dat verandert alleen-integriteit in integriteit plus authenticiteit, precies de eigenschap die webhooks en ondertekende verzoeken nodig hebben.

Bestendigheid tegen length-extension

Kale SHA-1, SHA-256 en SHA-512 zijn Merkle–Damgård-hashes die kwetsbaar zijn voor length-extension: gegeven H(geheim ‖ msg) kan een aanvaller H(geheim ‖ msg ‖ extra) berekenen zonder het geheim te kennen. Naïeve 'secret-prefix MAC'-schema's worden hierdoor gebroken. De externe hash van HMAC neutraliseert de aanval, en dat is de belangrijkste reden om HMAC te gebruiken in plaats van een geheim en bericht samen te hashen.

SHA-256 versus SHA-512 kiezen

HMAC-SHA256 produceert een tag van 256 bits (64 hex-tekens) en is de standaard voor interoperabiliteit — snel, alomtegenwoordig en overal ondersteund. HMAC-SHA512 produceert een tag van 512 bits (128 hex-tekens) en is vaak sneller op 64-bits CPU's omdat SHA-512 64-bits woorden gebruikt. Kies SHA-256 tenzij een specificatie of partnersysteem SHA-512 vereist; beide zijn veilig voor authenticatie.

Web Crypto-implementatie

Deze tool roept crypto.subtle.importKey aan om je sleutel te laden (gedecodeerd uit Tekst, Hex of Base64) en crypto.subtle.sign('HMAC', ...) om de tag te berekenen, en codeert daarna de ruwe bytes als Hex, Base64 of Base64URL. Het is dezelfde native, geauditeerde implementatie die de browser voor TLS gebruikt, draaiend buiten de JavaScript-engine voor snelheid.

HMAC-best practices

Gebruik een sleutel minstens zo lang als de hash-uitvoer

Voor HMAC-SHA256 gebruik je een geheim van minstens 32 willekeurige bytes (256 bits); voor SHA-512 gebruik je er 64. Een korte sleutel of een sleutel met weinig entropie is de zwakste schakel. Genereer sleutels uit een cryptografisch veilige willekeurige bron — nooit een wachtwoord of een voorspelbare string.

Vergelijk tags altijd in constante tijd

Verifieer handtekeningen met een vergelijking in constante tijd (crypto.timingSafeEqual in Node, hmac.compare_digest in Python) in plaats van == of stringgelijkheid. Een naïeve vergelijking stopt vroeg bij de eerste afwijkende byte en lekt timing waarmee een aanvaller een geldige tag byte voor byte kan achterhalen. Het tabblad Verifiëren van deze tool vergelijkt al in constante tijd.

Log of toon de geheime sleutel nooit

Houd ondertekeningsgeheimen buiten logs, foutmeldingen, URL's en client-side code. Sla ze op in een secrets-manager of omgevingsvariabelen, roteer ze periodiek en geef elke integratie zijn eigen sleutel zodat één lek niet alles compromitteert.

Geef de voorkeur aan HMAC-SHA256 of sterker

Gebruik standaard HMAC-SHA256; stap op naar SHA-384 of SHA-512 wanneer een partner dat vereist. Vermijd HMAC-SHA1 voor nieuwe systemen en gebruik nooit HMAC-MD5. Ook al verdraagt HMAC een zwakkere hash beter dan een kale handtekening zou doen, starten met een moderne hash geeft je de meeste marge.

Onderteken de exacte bytes, inclusief een timestamp

Onderteken de ruwe, ongewijzigde payload — JSON her-serialiseren of witruimte bijsnijden verandert de bytes en breekt de verificatie. Neem voor verzoekondertekening een timestamp of nonce op in de ondertekende data en weiger verouderde handtekeningen om replay-aanvallen te voorkomen.

Veelgestelde vragen over HMAC