Verifying Signatures

import crypto from 'node:crypto';

function verifyWebhookSignature(rawBody, signatureHeader, timestampHeader, secret) {
  // Use full secret as UTF-8 bytes (including whsec_ prefix)
  const key = Buffer.from(secret, 'utf8');

  // Parse headers
  const timestamp = timestampHeader;
  const signatures = signatureHeader
    .split(',')
    .filter(p => p.startsWith('sha256='))
    .map(p => p.slice(7));

  // Compute expected signature
  const signedPayload = `${timestamp}:${rawBody}`;
  const expected = crypto
    .createHmac('sha256', key)
    .update(signedPayload)
    .digest('hex');

  // Constant-time compare against any sha256 value
  return signatures.some(sig =>
    crypto.timingSafeEqual(Buffer.from(sig, 'hex'), Buffer.from(expected, 'hex'))
  );
}

import hashlib
import hmac

def verify_webhook_signature(raw_body: bytes, signature_header: str, timestamp_header: str, secret: str) -> bool:
    # Use full secret as UTF-8 bytes (including whsec_ prefix)
    key = secret.encode("utf-8")

    # Parse headers
    timestamp = timestamp_header
    signatures = [p[7:] for p in signature_header.split(",") if p.startswith("sha256=")]

    # Compute expected signature
    signed_payload = f"{timestamp}:".encode() + raw_body
    expected = hmac.new(key, signed_payload, hashlib.sha256).hexdigest()

    # Constant-time compare against any sha256 value
    return any(hmac.compare_digest(sig, expected) for sig in signatures)

package webhook

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

func VerifyWebhookSignature(rawBody []byte, signatureHeader, timestampHeader, secret string) bool {
	// Use full secret as UTF-8 bytes (including whsec_ prefix)
	key := []byte(secret)

	// Parse headers
	timestamp := timestampHeader
	var signatures []string
	for _, part := range strings.Split(signatureHeader, ",") {
		if strings.HasPrefix(part, "sha256=") {
			signatures = append(signatures, part[7:])
		}
	}

	// Compute expected signature
	signedPayload := fmt.Sprintf("%s:%s", timestamp, rawBody)
	mac := hmac.New(sha256.New, key)
	mac.Write([]byte(signedPayload))
	expected := hex.EncodeToString(mac.Sum(nil))

	// Constant-time compare against any sha256 value
	for _, sig := range signatures {
		if hmac.Equal([]byte(sig), []byte(expected)) {
			return true
		}
	}
	return false
}

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.security.MessageDigest;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;

public class WebhookVerifier {

    public static boolean verifyWebhookSignature(
            byte[] rawBody, String signatureHeader, String timestampHeader, String secret) throws Exception {
        // Use full secret as UTF-8 bytes (including whsec_ prefix)
        byte[] key = secret.getBytes(StandardCharsets.UTF_8);

        // Parse headers
        String timestamp = timestampHeader;
        List<String> signatures = new ArrayList<>();
        for (String part : signatureHeader.split(",")) {
            if (part.startsWith("sha256=")) {
                signatures.add(part.substring(7));
            }
        }

        // Compute expected signature
        byte[] signedPayload = (timestamp + ":").getBytes();
        byte[] fullPayload = new byte[signedPayload.length + rawBody.length];
        System.arraycopy(signedPayload, 0, fullPayload, 0, signedPayload.length);
        System.arraycopy(rawBody, 0, fullPayload, signedPayload.length, rawBody.length);

        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(new SecretKeySpec(key, "HmacSHA256"));
        String expected = bytesToHex(mac.doFinal(fullPayload));

        // Constant-time compare against any sha256 value
        for (String sig : signatures) {
            if (MessageDigest.isEqual(sig.getBytes(), expected.getBytes())) {
                return true;
            }
        }
        return false;
    }

    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }
}