HMAC Signature Tester and Verifier

All three examples read the raw request body, recompute the HMAC-SHA256 digest, and compare it to the received signature in constant time. A non-timing-safe compare such as == or === leaks information about the expected signature through timing side channels — always use the platform's constant-time helper.

import crypto from 'node:crypto';

// Sign the raw bytes of the request body — never the parsed JSON.
export function verifyWebhookSignature(params: {
  body: string;
  secret: string;
  receivedHex: string;
}): boolean {
  const expected = crypto
    .createHmac('sha256', params.secret)
    .update(params.body, 'utf8')
    .digest('hex');

  const expectedBuf = Buffer.from(expected, 'utf8');
  const receivedBuf = Buffer.from(params.receivedHex, 'utf8');

  if (expectedBuf.length !== receivedBuf.length) {
    return false;
  }

  // Constant-time compare. Never use `===` or `==` on signatures.
  return crypto.timingSafeEqual(expectedBuf, receivedBuf);
}

import hmac
import hashlib


def verify_webhook_signature(body: bytes, secret: str, received_hex: str) -> bool:
    expected = hmac.new(
        secret.encode("utf-8"),
        msg=body,
        digestmod=hashlib.sha256,
    ).hexdigest()

    # hmac.compare_digest is constant-time. Never use `==` on signatures.
    return hmac.compare_digest(expected, received_hex)

package webhook

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
)

// VerifyWebhookSignature recomputes an HMAC-SHA256 over body with secret and
// compares it to receivedHex in constant time.
func VerifyWebhookSignature(body []byte, secret string, receivedHex string) bool {
	mac := hmac.New(sha256.New, []byte(secret))
	mac.Write(body)
	expected := hex.EncodeToString(mac.Sum(nil))

	// hmac.Equal is constant-time. Never use == on signatures.
	return hmac.Equal([]byte(expected), []byte(receivedHex))
}

• Signing the parsed body instead of the raw body. Most web frameworks parse JSON before your handler runs. Re-serializing the parsed object often reorders keys, changes whitespace, or drops unicode escapes. Sign the exact bytes the sender signed. In Express, read from the raw body buffer; in FastAPI, read from await request.body(); in Go, do the HMAC before json.Unmarshal.
• Trailing newlines and CRLF. Some HTTP clients append a newline to request bodies. Some proxies convert line endings from \n to \r\n. Either will change the digest. If you cannot find the difference, hash the body with SHA-256 on both sides and compare before you worry about HMAC.
• Encoding mismatches. GitHub and Stripe emit hex. Shopify emits base64. If you hand a base64 signature to a hex comparator you will always get a mismatch — even when the underlying digest is identical. The Verify tab on this page surfaces this specifically because it is so common.
• Non-timing-safe comparisons. A byte-by-byte compare that returns on the first mismatch leaks the expected signature through timing differences. Use crypto.timingSafeEqual, hmac.compare_digest, or hmac.Equal.
• Missing replay protection. HMAC proves the body did not change, not that the request is fresh. If your signing scheme does not already include a timestamp, add one and reject any request whose timestamp is older than a small window (Stripe uses five minutes).
• Algorithm downgrade. Hard-code the algorithm your receiver expects. Do not let the sender dictate it through an alg header or similar field — that lets an attacker pick a weaker algorithm if one is ever introduced.