HMAC-SHA256 in Node.js, Python and Go: Verified Snippets

What HMAC adds on top of SHA-256

RFC 2104 defines HMAC as H(K XOR opad, H(K XOR ipad, text)): the message is hashed once with an inner-padded key, and that result is hashed again with an outer-padded key. Keys longer than the hash block size are hashed first; shorter keys are zero-padded. The RFC says a key shorter than the hash output length (32 bytes for SHA-256) “is strongly discouraged”. The practical consequences:

Node.js

import { createHmac, timingSafeEqual } from 'node:crypto';

const key = 'my-secret-key';
const message = '{"id":123,"event":"order.paid"}';

const hex = createHmac('sha256', key).update(message).digest('hex');
console.log(hex);
console.log(createHmac('sha256', key).update(message).digest('base64'));

function verify(message, receivedHex, key) {
  const expected = Buffer.from(createHmac('sha256', key).update(message).digest('hex'), 'hex');
  const received = Buffer.from(receivedHex, 'hex');
  return expected.length === received.length && timingSafeEqual(expected, received);
}
console.log('valid:', verify(message, hex, key));
console.log('tampered:', verify(message + ' ', hex, key));

// $ node hmac.mjs
// 240b11d681b1f0ec9e7e107c0e6f44d2f472a500fe71098f7807e9e1ebad5a3d
// JAsR1oGx8OyefhB8Dm9E0vRypQD+cQmPeAfp4eutWj0=
// valid: true
// tampered: false

The length check before timingSafeEqual matters: the function throws when the buffers differ in length, and a thrown error is itself a fast-path signal. update() accepts a string (UTF-8 by default) or a Buffer; for webhook bodies pass the raw request bytes, not a re-stringified object.

Python

import hmac, hashlib, base64

key = b"my-secret-key"
message = b'{"id":123,"event":"order.paid"}'

digest = hmac.new(key, message, hashlib.sha256)
print(digest.hexdigest())
print(base64.b64encode(hmac.new(key, message, hashlib.sha256).digest()).decode())

def verify(message: bytes, received_hex: str, key: bytes) -> bool:
    expected = hmac.new(key, message, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, received_hex)

print("valid:", verify(message, digest.hexdigest(), key))
print("tampered:", verify(message + b" ", digest.hexdigest(), key))

# $ python3 hmac_test.py
# 240b11d681b1f0ec9e7e107c0e6f44d2f472a500fe71098f7807e9e1ebad5a3d
# JAsR1oGx8OyefhB8Dm9E0vRypQD+cQmPeAfp4eutWj0=
# valid: True
# tampered: False

Both key and message must be bytes; passing a str raises TypeError. The hex and Base64 outputs match the Node run byte for byte, which is the property you rely on when one service signs and another verifies.

Go

This mirrors the ValidMAC example in the official crypto/hmac package documentation, which notes that receivers “should be careful to use Equal to compare MACs in order to avoid timing side-channels”:

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

func Sign(message, key []byte) string {
    mac := hmac.New(sha256.New, key)
    mac.Write(message)
    return hex.EncodeToString(mac.Sum(nil))
}

// ValidMAC reports whether messageMAC is a valid HMAC tag for message.
func ValidMAC(message, messageMAC, key []byte) bool {
    mac := hmac.New(sha256.New, key)
    mac.Write(message)
    expectedMAC := mac.Sum(nil)
    return hmac.Equal(messageMAC, expectedMAC)
}

hmac.New takes the hash constructor (sha256.New, not sha256.New()) and returns a hash.Hash. When the received tag arrives as hex, decode it with hex.DecodeString before calling hmac.Equal.

Typical use: webhook signatures

The common pattern is: the sender computes HMAC-SHA256 over the raw request body with a shared secret and puts the hex or Base64 tag in a header; the receiver recomputes it from the exact bytes it received and compares in constant time. Many providers also include a timestamp in the signed string so an intercepted request cannot be replayed later. The three mistakes that break verification in practice are parsing the JSON and re-serializing it before hashing (whitespace and key order change the bytes), using a UTF-8 key when the provider gave you a hex or Base64 key, and comparing strings with ==. The generic flow is described in the webhook guide.

Frequently Asked Questions

Related guides

• Hash Functions Explained: MD5, SHA-256, bcrypt & More
• Webhook Guide: Design, Security and Retries