HMAC-Generator & Signaturprüfer

Was ist ein 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);
}

Hauptfunktionen

HMAC-Beispiele

Hello, World!

cf3141611e22ea26a9cac6fe41d941274dd6653622c83cba13972d177bd69699

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

Cd2f7zTKaJFeG6k+t1FcvDPn51OAZ2f4GrxkCUgMhGs=

what do ya want for nothing?

5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843

The quick brown fox

36f44b125a8a90639dc46733039571792e081e0fd8685ff746784b02ed14aa35629d562c7117cde4a701570551faa5a5e1b7ef1eb5c3bcd4cc1fdb8923fcf14e

So generierst & prüfst du einen HMAC

1. 1

   Den Algorithmus wählen

   Wähle HMAC-SHA256 (die Standardeinstellung und die richtige Wahl für nahezu alle Webhooks, APIs und JWTs) oder wechsle zu SHA-1, SHA-384 oder SHA-512, um einem System zu entsprechen, das es erfordert. Alle vier laufen nativ in deinem Browser über die Web-Crypto-API.

2. 2

   Den geheimen Schlüssel eingeben und seine Kodierung festlegen

   Tippe oder füge deinen geheimen Schlüssel ein und stelle dann die Schlüsselkodierung passend dazu ein, wie der Server ihn interpretiert: Text (UTF-8) für eine einfache Zeichenkette, Hex für einen hexadezimalen Block oder Base64 für ein Base64-Geheimnis. Hier einen Fehler zu machen ist die häufigste Ursache für HMAC-Abweichungen, also probiere im Zweifel alle drei.

3. 3

   Die Nachricht eingeben

   Füge die exakten Bytes ein, die du signieren willst — bei einem Webhook ist das der rohe Anfragetext, Byte für Byte, ohne Neuserialisierung oder Leerzeichenänderungen. Der HMAC wird live beim Bearbeiten neu berechnet, ohne dass etwas an einen Server gesendet wird.

4. 4

   Das Ausgabeformat wählen und kopieren

   Wähle Hex (GitHub-Stil), Base64 (Stripe/AWS-Stil) oder Base64URL (JWT-Stil) passend zu dem, was deine Integration erwartet, und klicke dann auf Kopieren, um die Signatur zu übernehmen.

5. 5

   Eine vorhandene Signatur prüfen

   Wechsle zum Tab Prüfen, füge den erwarteten HMAC aus einem Header oder Token ein, und das Tool bestätigt in konstanter Zeit, ob deine berechnete Signatur übereinstimmt — so kannst du eine Nutzlast authentifizieren, bevor du darauf reagierst.

Häufige HMAC-Fehler

// 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 */ }

Wofür HMAC verwendet wird

Webhook-Signaturen prüfen

Anbieter wie GitHub, Stripe, Slack und Twilio signieren jeden Webhook mit einem HMAC über den Anfragetext und einem Geheimnis, das nur du teilst. Berechne das Tag neu und vergleiche es mit dem Header (zum Beispiel X-Hub-Signature-256), um zu bestätigen, dass das Ereignis echt ist, bevor du darauf reagierst. Verwende den Tab Prüfen, um das ohne Wegwerf-Code zu erledigen.

API-Anfragen signieren

Authentifizierte APIs verlangen oft, dass der Client die Anfrage per HMAC signiert (Methode, Pfad, Zeitstempel, Body) mit einem gemeinsamen Geheimnis, statt das Geheimnis selbst zu senden. AWS Signature Version 4 ist das kanonische Beispiel. Dieses Tool lässt dich solche Signaturen Schritt für Schritt reproduzieren und debuggen.

Nachrichtenintegrität garantieren

Wenn du ein Token, ein Cookie oder eine Nachricht zwischen Diensten weitergibst, lässt das Anhängen eines HMAC den Empfänger jede Manipulation erkennen. Da das Tag von einem Geheimnis abhängt, kann ein Angreifer es nach dem Ändern der Daten nicht neu berechnen — anders als eine einfache Prüfsumme.

Die JWT-HS256-Signierung verstehen

Ein mit HS256 signiertes JWT ist einfach base64url(Header) + '.' + base64url(Nutzlast), signiert mit HMAC-SHA256, wobei das Ergebnis als Base64URL ausgegeben wird. Stelle hier den Algorithmus auf SHA-256 und die Ausgabe auf Base64URL, um genau zu sehen, wie diese Signatur erzeugt wird, und gleiche es dann im JWT-Kodierer ab.

Eine nicht übereinstimmende Signatur debuggen

Wenn dein HMAC nicht mit dem des Servers übereinstimmen will, ist dieses Tool der schnellste Weg, die Ursache einzugrenzen: Probiere den Schlüssel als Text, Hex und Base64, wechsle die Ausgabe zwischen Hex und Base64 und bestätige, dass du genau die rohen Bytes signierst — alles ohne erneutes Deployment.

Wie HMAC funktioniert

RFC-2104-Konstruktion

HMAC ist definiert als H((K ⊕ opad) ‖ H((K ⊕ ipad) ‖ m)), wobei ipad das wiederholte Byte 0x36 und opad das wiederholte 0x5c ist, beide bis zur Blockgröße des Hashes. Ein Schlüssel, der länger als die Blockgröße ist, wird zuerst gehasht; ein kürzerer Schlüssel wird mit Nullen aufgefüllt. Diese Zwei-Pass-Schachtelung verleiht HMAC seinen Sicherheitsbeweis, der selbst dann gilt, wenn der zugrunde liegende Hash nicht kollisionsresistent ist.

Warum ein schlüsselbasierter Hash einen reinen Hash schlägt

Ein reiner Hash beweist nur, dass Daten nicht versehentlich beschädigt wurden, denn jeder kann ihn für jede Nachricht neu berechnen — auch für eine manipulierte. HMAC mischt ein Geheimnis hinein, sodass nur Schlüsselinhaber ein gültiges Tag erzeugen können. Das verwandelt reine Integrität in Integrität plus Authentizität, also genau die Eigenschaft, die Webhooks und signierte Anfragen tatsächlich brauchen.

Resistenz gegen Längenerweiterung

Nacktes SHA-1, SHA-256 und SHA-512 sind Merkle–Damgård-Hashes, die anfällig für Längenerweiterung sind: Aus H(secret ‖ msg) kann ein Angreifer H(secret ‖ msg ‖ extra) berechnen, ohne das Geheimnis zu kennen. Naive „Secret-Prefix-MAC“-Schemata werden dadurch gebrochen. Der äußere Hash von HMAC neutralisiert den Angriff, was der Hauptgrund ist, HMAC zu verwenden, statt ein Geheimnis und eine Nachricht zusammen zu hashen.

SHA-256 vs. SHA-512 wählen

HMAC-SHA256 erzeugt ein 256-Bit-Tag (64 Hex-Zeichen) und ist der Standard für Interoperabilität — schnell, allgegenwärtig und überall unterstützt. HMAC-SHA512 erzeugt ein 512-Bit-Tag (128 Hex-Zeichen) und ist auf 64-Bit-CPUs oft schneller, weil SHA-512 64-Bit-Wörter verwendet. Wähle SHA-256, sofern keine Spezifikation oder kein Gegenstellen-System SHA-512 verlangt; beide sind für die Authentifizierung sicher.

Web-Crypto-Implementierung

Dieses Tool ruft crypto.subtle.importKey auf, um deinen Schlüssel zu laden (dekodiert aus Text, Hex oder Base64), und crypto.subtle.sign('HMAC', ...), um das Tag zu berechnen, und kodiert dann die rohen Bytes als Hex, Base64 oder Base64URL. Es ist dieselbe native, auditierte Implementierung, die der Browser für TLS verwendet, und läuft für mehr Geschwindigkeit außerhalb der JavaScript-Engine.

HMAC-Best-Practices

Einen Schlüssel verwenden, der mindestens so lang wie die Hash-Ausgabe ist

Verwende für HMAC-SHA256 ein Geheimnis von mindestens 32 zufälligen Bytes (256 Bit); für SHA-512 verwende 64. Ein kurzer oder entropiearmer Schlüssel ist das schwächste Glied. Generiere Schlüssel aus einer kryptografisch sicheren Zufallsquelle — niemals aus einem Passwort oder einer vorhersehbaren Zeichenkette.

Tags immer in konstanter Zeit vergleichen

Prüfe Signaturen mit einem Vergleich in konstanter Zeit (crypto.timingSafeEqual in Node, hmac.compare_digest in Python) statt mit == oder String-Gleichheit. Ein naiver Vergleich bricht beim ersten abweichenden Byte vorzeitig ab und gibt ein Timing preis, das einem Angreifer erlauben kann, ein gültiges Tag Byte für Byte zu rekonstruieren. Der Tab Prüfen dieses Tools vergleicht bereits in konstanter Zeit.

Den geheimen Schlüssel niemals loggen oder offenlegen

Halte Signaturgeheimnisse aus Logs, Fehlermeldungen, URLs und clientseitigem Code heraus. Speichere sie in einem Secrets-Manager oder in Umgebungsvariablen, rotiere sie regelmäßig und gib jeder Integration ihren eigenen Schlüssel, damit ein Leck nicht alles kompromittiert.

HMAC-SHA256 oder stärker bevorzugen

Verwende standardmäßig HMAC-SHA256; steige auf SHA-384 oder SHA-512 um, wenn eine Gegenstelle es verlangt. Vermeide HMAC-SHA1 für neue Systeme und verwende niemals HMAC-MD5. Auch wenn HMAC einen schwächeren Hash besser verträgt als eine rohe Signatur, gibt dir ein moderner Hash als Ausgangspunkt den größten Spielraum.

Die exakten Bytes signieren, samt Zeitstempel

Signiere die rohe, unveränderte Nutzlast — das Neuserialisieren von JSON oder Trimmen von Leerzeichen ändert die Bytes und zerstört die Prüfung. Nimm beim Signieren von Anfragen einen Zeitstempel oder Nonce in die signierten Daten auf und weise veraltete Signaturen zurück, um Replay-Angriffe zu verhindern.

HMAC-FAQ