HMAC Generator & Signature Verifier

What Is an 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);
}

Key Features

HMAC Examples

Hello, World!

cf3141611e22ea26a9cac6fe41d941274dd6653622c83cba13972d177bd69699

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

Cd2f7zTKaJFeG6k+t1FcvDPn51OAZ2f4GrxkCUgMhGs=

what do ya want for nothing?

5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843

The quick brown fox

36f44b125a8a90639dc46733039571792e081e0fd8685ff746784b02ed14aa35629d562c7117cde4a701570551faa5a5e1b7ef1eb5c3bcd4cc1fdb8923fcf14e

How to Generate & Verify an HMAC

1. 1

   Choose the algorithm

   Pick HMAC-SHA256 (the default and the right choice for nearly all webhooks, APIs, and JWTs), or switch to SHA-1, SHA-384, or SHA-512 to match a system that requires it. All four run natively in your browser via the Web Crypto API.

2. 2

   Enter the secret key and set its encoding

   Type or paste your secret key, then set Key encoding to match how the server interprets it: Text (UTF-8) for a plain string, Hex for a hexadecimal blob, or Base64 for a base64 secret. Getting this wrong is the top cause of HMAC mismatches, so when in doubt try all three.

3. 3

   Enter the message

   Paste the exact bytes you want to sign — for a webhook this is the raw request body, byte-for-byte, with no re-serialization or whitespace changes. The HMAC recomputes live as you edit, with nothing sent to a server.

4. 4

   Pick the output format and copy

   Select Hex (GitHub-style), Base64 (Stripe/AWS-style), or Base64URL (JWT-style) to match what your integration expects, then click Copy to grab the signature.

5. 5

   Verify an existing signature

   Switch to the Verify tab, paste the Expected HMAC from a header or token, and the tool confirms in constant time whether your computed signature matches — so you can authenticate a payload before acting on it.

Common HMAC Mistakes

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

What HMAC Is Used For

Verify webhook signatures

Providers like GitHub, Stripe, Slack, and Twilio sign each webhook with HMAC over the request body and a secret only you share. Recompute the tag and compare it to the header (for example X-Hub-Signature-256) to confirm the event is genuine before you act on it. Use the Verify tab to do this without writing throwaway code.

Sign API requests

Authenticated APIs often require the client to HMAC-sign the request (method, path, timestamp, body) with a shared secret instead of sending the secret itself. AWS Signature Version 4 is the canonical example. This tool lets you reproduce and debug those signatures step by step.

Guarantee message integrity

When you pass a token, cookie, or message between services, attaching an HMAC lets the receiver detect any tampering. Because the tag depends on a secret, an attacker cannot recompute it after modifying the data — unlike a plain checksum.

Understand JWT HS256 signing

A JWT signed with HS256 is just base64url(header) + '.' + base64url(payload), signed with HMAC-SHA256 and the result emitted as Base64URL. Set the algorithm to SHA-256 and the output to Base64URL here to see exactly how that signature is produced, then cross-check in the JWT encoder.

Debug a mismatching signature

When your HMAC will not match the server's, this tool is the fastest way to isolate why: try the key as Text, Hex, and Base64, switch the output between Hex and Base64, and confirm you are signing the exact raw bytes — all without redeploying any code.

How HMAC Works

RFC 2104 construction

HMAC is defined as H((K ⊕ opad) ‖ H((K ⊕ ipad) ‖ m)), where ipad is the byte 0x36 repeated and opad is 0x5c repeated, both to the hash's block size. A key longer than the block size is first hashed; a shorter key is zero-padded. This two-pass nesting is what gives HMAC its security proof, which holds even if the underlying hash is not collision-resistant.

Why a keyed hash beats a plain hash

A plain hash proves only that data was not accidentally corrupted, because anyone can recompute it for any message — including a tampered one. HMAC mixes in a secret, so only key-holders can produce a valid tag. That converts integrity-only into integrity plus authenticity, which is the property webhooks and signed requests actually need.

Length-extension resistance

Bare SHA-1, SHA-256, and SHA-512 are Merkle–Damgård hashes vulnerable to length-extension: given H(secret ‖ msg) an attacker can compute H(secret ‖ msg ‖ extra) without knowing the secret. Naive 'secret-prefix MAC' schemes are broken by this. HMAC's outer hash neutralizes the attack, which is the main reason to use HMAC instead of hashing a secret and message together.

Choosing SHA-256 vs SHA-512

HMAC-SHA256 produces a 256-bit (64 hex char) tag and is the interoperability default — fast, ubiquitous, and supported everywhere. HMAC-SHA512 produces a 512-bit (128 hex char) tag and is often faster on 64-bit CPUs because SHA-512 uses 64-bit words. Pick SHA-256 unless a specification or peer system requires SHA-512; both are secure for authentication.

Web Crypto implementation

This tool calls crypto.subtle.importKey to load your key (decoded from Text, Hex, or Base64) and crypto.subtle.sign('HMAC', ...) to compute the tag, then encodes the raw bytes as Hex, Base64, or Base64URL. It is the same native, audited implementation the browser uses for TLS, running outside the JavaScript engine for speed.

HMAC Best Practices

Use a key at least as long as the hash output

For HMAC-SHA256 use a secret of at least 32 random bytes (256 bits); for SHA-512 use 64. A short or low-entropy key is the weakest link. Generate keys from a cryptographically secure random source — never a password or a predictable string.

Always compare tags in constant time

Verify signatures with a constant-time comparison (crypto.timingSafeEqual in Node, hmac.compare_digest in Python) rather than == or string equality. A naive comparison returns early on the first differing byte, leaking timing that can let an attacker recover a valid tag byte by byte. This tool's Verify tab already compares in constant time.

Never log or expose the secret key

Keep signing secrets out of logs, error messages, URLs, and client-side code. Store them in a secrets manager or environment variables, rotate them periodically, and scope each integration to its own key so one leak does not compromise everything.

Prefer HMAC-SHA256 or stronger

Default to HMAC-SHA256; step up to SHA-384 or SHA-512 when a peer requires it. Avoid HMAC-SHA1 for new systems and never use HMAC-MD5. Even though HMAC tolerates a weaker hash better than a raw signature would, starting from a modern hash gives you the most margin.

Sign the exact bytes, including a timestamp

Sign the raw, unmodified payload — re-serializing JSON or trimming whitespace changes the bytes and breaks verification. For request signing, include a timestamp or nonce in the signed data and reject stale signatures to prevent replay attacks.

HMAC FAQ