HMAC Generator

Introduction

A hash alone proves integrity — anyone can compute it. HMAC adds a secret key, proving both integrity AND authenticity. This tool generates HMAC authentication codes using HMAC-SHA-256, HMAC-SHA-384, and HMAC-SHA-512. Whether you're signing API webhooks, verifying JWT tokens, or building message authentication for inter-service communication, this is the tool that makes it concrete.

What This Tool Does

An HMAC generator creates Hash-based Message Authentication Codes using the Web Crypto API's subtle.importKey() and subtle.sign() methods. HMAC combines a cryptographic hash with a secret key through a nested construction defined in RFC 2104: HMAC(K, m) = H((K' ⊕ opad) || H((K' ⊕ ipad) || m)). It supports three hash variants: HMAC-SHA-256 (most common), HMAC-SHA-384, and HMAC-SHA-512. The output is a fixed-length hex string whose length depends on the chosen hash algorithm (64, 96, or 128 hex characters).

Why It Matters

How It Works

The Web Crypto API implements HMAC through two steps: key import and signing. First, subtle.importKey() creates a CryptoKey object from the raw secret bytes using the 'HMAC' algorithm and a specified hash (SHA-256, SHA-384, or SHA-512). Then, subtle.sign() computes the HMAC over the message using the imported key. Internally, this follows RFC 2104: the key is padded to the block size (64 bytes for SHA-256/384, 128 bytes for SHA-512), XORed with ipad (0x36) and opad (0x5c), and the hash is computed as H(K' ⊕ opad || H(K' ⊕ ipad || message)). The result is a binary digest converted to hexadecimal for display.

Step-by-Step Examples

Code Examples

async function hmacSHA256(key, message) {
  const encoder = new TextEncoder();
  
  // Import the key
  const cryptoKey = await crypto.subtle.importKey(
    'raw',
    encoder.encode(key),
    { name: 'HMAC', hash: 'SHA-256' },
    false,
    ['sign']
  );
  
  // Sign the message
  const signature = await crypto.subtle.sign(
    'HMAC',
    cryptoKey,
    encoder.encode(message)
  );
  
  // Convert to hex
  return Array.from(new Uint8Array(signature))
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');
}

// Usage
const hmac = await hmacSHA256('my-secret-key', 'Hello, World!');
console.log(hmac);

import hmac
import hashlib

def verify_hmac(key, message, expected_hmac):
    computed = hmac.new(
        key.encode(),
        message.encode(),
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(computed, expected_hmac)

# Usage (constant-time comparison prevents timing attacks)
is_valid = verify_hmac(
    'my-secret-key',
    'Hello, World!',
    'a3f2b8c9...'
)
print("Valid" if is_valid else "Invalid")

Benefits

• Generates HMAC signatures using the Web Crypto API for hardware-accelerated performance.
• Supports three SHA variants (256, 384, 512) for different security requirements.
• Uses the RFC 2104 nested construction for standards-compliant HMAC generation.
• Provides both integrity and authenticity — not just data verification but source verification.
• Client-side operation keeps secret keys in browser memory only.

Use Cases

Common Mistakes to Avoid

Security Implications

Security Information

All computation runs in browser memory using the Web Crypto API. The secret key is never transmitted. HMAC provides message integrity and authenticity — an attacker cannot forge a valid HMAC without knowing the secret key. However, HMAC does not provide confidentiality (the message is not encrypted) or non-repudiation (anyone with the key can create the HMAC).

Best Practices

• Use HMAC-SHA256 as the default for API authentication and webhook verification.
• Keep the secret key confidential — HMAC security depends entirely on key secrecy.
• Use different keys for different purposes to limit the impact of key compromise.
• Rotate HMAC keys periodically and update all consumers before the old key expires.
• Use constant-time comparison when verifying HMACs to prevent timing side-channel attacks.
• Store HMAC keys in a secrets manager or hardware security module, never in source code.