🔐 HMAC Generator (SHA-256, SHA-1, SHA-512)

What is the HMAC Generator?

HMAC is a way to prove two things at once: that a message has not been altered, and that it came from someone who knows a shared secret key. A plain hash like SHA-256 only protects against accidental change, because anyone can recompute it from the message alone. HMAC mixes a secret key into the hashing process, so only parties who hold the key can produce or check the value. The result is called a message authentication code, and it is what turns a hash function into an authentication primitive.

The algorithm is defined in RFC 2104 and standardized further in FIPS 198-1. It hashes the message together with two key-derived pads, an inner pad and an outer pad, in the pattern H(key XOR opad, H(key XOR ipad, message)). You do not have to do that by hand: the Web Crypto API does it for you. This tool calls importKey to load your secret as a raw HMAC key, then sign to produce the code, and finally converts the raw bytes to a hexadecimal string.

The output length depends on the chosen hash. HMAC-SHA1 returns 20 bytes (40 hex characters), HMAC-SHA256 returns 32 bytes (64 hex characters), and HMAC-SHA512 returns 64 bytes (128 hex characters). Because the result is deterministic, the same message and key always yield the same digest, which is exactly what lets a receiver verify it by computing the HMAC again and comparing the two strings.

A property that makes HMAC different from simply hashing the key and message together (like SHA256(key + message)) is resistance to length-extension attacks. Hash functions built on the Merkle-Damgard construction, including SHA-1, SHA-256, and SHA-512, let an attacker who knows H(secret + message) compute H(secret + message + extra) without ever learning the secret. The double-hashing structure of HMAC, with two independent pads, closes that gap, which is why RFC 2104 recommends HMAC instead of naive key-prefixing even when the underlying hash is otherwise trusted.

HMAC shows up across the stack: webhook providers sign event payloads with it, cloud APIs such as AWS Signature Version 4 build a canonical request and HMAC-SHA256 it in stages, and the HS256 and HS512 algorithms in a JWT are literally HMAC-SHA256 and HMAC-SHA512 applied to the header and payload with the JWT secret as the key. Understanding this tool means understanding a large slice of how modern web authentication actually works under the hood.

When to use it

• Verifying incoming webhook payloads from providers such as Stripe, GitHub, or Slack that sign each request with HMAC.
• Signing outgoing API requests where the server expects an HMAC of the request body or a canonical string, similar to AWS Signature Version 4.
• Reproducing a signature you were given so you can confirm your own signing code, in Node.js, Python, or another language, matches the expected output.
• Debugging a JWT that uses HS256 or HS512 by manually computing the HMAC of the header and payload against the shared secret.
• Teaching or learning how a keyed hash differs from a plain hash by changing one character and watching the digest change completely.
• Generating a short integrity tag for a configuration value, license key, or session token so tampering can be detected later.

How to use the HMAC Generator

1. Type or paste the message you want to authenticate into the Message box.
2. Enter the shared secret key in the Secret key field. It is treated as raw UTF-8 text.
3. Choose the hash algorithm: SHA-256 is the common default, SHA-1 is legacy, and SHA-512 is the longest.
4. Press Generate HMAC, or just edit any field and the digest updates automatically.
5. Read the hexadecimal HMAC in the result box and press Copy to put it on your clipboard.
6. To verify a signature you received, paste the same raw message and the same key, pick the matching algorithm, and compare the output character by character.

Formula & method

Worked examples

HMAC output length by hash algorithm

Common HMAC use in popular webhook and API providers

HMAC vs a plain hash vs a digital signature

Common mistakes to avoid

• Confusing HMAC with a plain hash. A plain SHA-256 hash uses no key, so anyone can recompute it. HMAC requires the secret key, which is what makes it an authentication code. Make sure you are using the keyed function, not a bare digest, when a provider asks for an HMAC signature.
• Mismatched key encoding. This tool treats the key as raw UTF-8 text. If the other side expects the key as base64 or hex bytes, decode it first. A different byte interpretation of the same key string produces a completely different HMAC.
• Hashing the wrong message bytes. Webhook providers usually sign the exact raw request body, sometimes joined with a timestamp. Re-serializing, pretty-printing, or changing key order in the JSON changes the bytes and breaks the match. Sign the original bytes exactly as received, before any parsing.
• Comparing signatures with a simple equality check. In production code, compare HMAC values with a constant-time comparison function, not a naive string equality check. An early-exit comparison can leak timing information about how many leading characters matched, which is a real (if narrow) side-channel risk.
• Assuming HMAC output is base64 by default. This tool and most libraries return raw HMAC bytes, which can be shown as hex or as base64. AWS and some webhook providers expect base64, while GitHub and Stripe expect hex prefixed with sha256=. Check the provider docs before assuming the format.
• Reusing a weak or guessable secret key. HMAC security depends entirely on the secrecy and randomness of the key. A short, predictable, or leaked key can be brute-forced or guessed even though the hash algorithm itself is strong. Use a long, randomly generated key and rotate it if it may have leaked.

Glossary

HMAC

Hash-based Message Authentication Code. A keyed hash that proves both the integrity and the authenticity of a message.

Secret key

A shared value known to both the sender and the verifier. Knowledge of the key is what lets a party create or check an HMAC.

Digest

The fixed-length output of a hash or HMAC, shown here as a hexadecimal string.

Hexadecimal

A base-16 text representation where each byte is written as two characters from 0 to 9 and a to f.

Avalanche effect

The property that a tiny change in the input flips about half the output bits, making outputs look unrelated.

Web Crypto API

A browser-native cryptography interface (SubtleCrypto) that provides hashing, HMAC, and other primitives without a third-party library.

Constant-time comparison

A way of comparing two secrets, such as HMAC digests, that always takes the same amount of time regardless of where they first differ, to avoid leaking information through timing.

Block size

The internal chunk size a hash function processes at a time (64 bytes for SHA-1 and SHA-256, 128 bytes for SHA-512), used when HMAC pads or hashes the key down to size.

Frequently asked questions