Webhooks

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

const TOLERANCE_S = 5 * 60;

export function verifyWebhook(secret: string, headers: Record<string, string>, rawBody: string) {
  const id = headers["webhook-id"];
  const timestamp = headers["webhook-timestamp"];
  const signatures = headers["webhook-signature"];
  if (!id || !timestamp || !signatures) throw new Error("missing signature headers");

  const skew = Math.abs(Date.now() / 1000 - Number(timestamp));
  if (!Number.isFinite(skew) || skew > TOLERANCE_S) throw new Error("timestamp outside tolerance");

  const key = Buffer.from(secret.slice("whsec_".length), "base64");
  const expected = createHmac("sha256", key)
    .update(`${id}.${timestamp}.${rawBody}`)
    .digest("base64");

  const ok = signatures.split(" ").some((entry) => {
    const [version, sig] = entry.split(",");
    return (
      version === "v1" &&
      sig?.length === expected.length &&
      timingSafeEqual(Buffer.from(sig), Buffer.from(expected))
    );
  });
  if (!ok) throw new Error("no matching signature");
  return JSON.parse(rawBody);
}

import base64
import hashlib
import hmac
import json
import time

TOLERANCE_S = 5 * 60

def verify_webhook(secret: str, headers: dict, raw_body: bytes) -> dict:
    msg_id = headers.get("webhook-id")
    timestamp = headers.get("webhook-timestamp")
    signatures = headers.get("webhook-signature")
    if not (msg_id and timestamp and signatures):
        raise ValueError("missing signature headers")

    if abs(time.time() - float(timestamp)) > TOLERANCE_S:
        raise ValueError("timestamp outside tolerance")

    key = base64.b64decode(secret.removeprefix("whsec_"))
    signed = f"{msg_id}.{timestamp}.".encode() + raw_body
    expected = base64.b64encode(hmac.new(key, signed, hashlib.sha256).digest()).decode()

    for entry in signatures.split(" "):
        version, _, sig = entry.partition(",")
        if version == "v1" and hmac.compare_digest(sig, expected):
            return json.loads(raw_body)
    raise ValueError("no matching signature")

package webhooks

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/base64"
	"errors"
	"fmt"
	"math"
	"net/http"
	"strconv"
	"strings"
	"time"
)

const toleranceSeconds = 5 * 60

func VerifyWebhook(secret string, headers http.Header, rawBody []byte) error {
	id := headers.Get("webhook-id")
	timestamp := headers.Get("webhook-timestamp")
	signatures := headers.Get("webhook-signature")
	if id == "" || timestamp == "" || signatures == "" {
		return errors.New("missing signature headers")
	}

	ts, err := strconv.ParseFloat(timestamp, 64)
	if err != nil || math.Abs(float64(time.Now().Unix())-ts) > toleranceSeconds {
		return errors.New("timestamp outside tolerance")
	}

	key, err := base64.StdEncoding.DecodeString(strings.TrimPrefix(secret, "whsec_"))
	if err != nil {
		return err
	}

	mac := hmac.New(sha256.New, key)
	fmt.Fprintf(mac, "%s.%s.", id, timestamp)
	mac.Write(rawBody)
	expected := base64.StdEncoding.EncodeToString(mac.Sum(nil))

	for _, entry := range strings.Split(signatures, " ") {
		version, sig, found := strings.Cut(entry, ",")
		if found && version == "v1" && hmac.Equal([]byte(sig), []byte(expected)) {
			return nil
		}
	}
	return errors.New("no matching signature")
}

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

public final class WebhookVerifier {
    private static final long TOLERANCE_S = 5 * 60;

    public static void verify(String secret, String id, String timestamp,
                              String signatures, byte[] rawBody) throws Exception {
        long skew = Math.abs(System.currentTimeMillis() / 1000 - Long.parseLong(timestamp));
        if (skew > TOLERANCE_S) throw new SecurityException("timestamp outside tolerance");

        byte[] key = Base64.getDecoder().decode(secret.substring("whsec_".length()));
        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(new SecretKeySpec(key, "HmacSHA256"));
        mac.update((id + "." + timestamp + ".").getBytes(StandardCharsets.UTF_8));
        byte[] expected = Base64.getEncoder().encode(mac.doFinal(rawBody));

        for (String entry : signatures.split(" ")) {
            String[] parts = entry.split(",", 2);
            if (parts.length == 2 && parts[0].equals("v1")
                    && MessageDigest.isEqual(parts[1].getBytes(StandardCharsets.UTF_8), expected)) {
                return;
            }
        }
        throw new SecurityException("no matching signature");
    }
}

using System.Linq;
using System.Security.Cryptography;
using System.Text;

public static class WebhookVerifier
{
    private const long ToleranceSeconds = 5 * 60;

    public static void Verify(string secret, string id, string timestamp,
                              string signatures, byte[] rawBody)
    {
        var skew = Math.Abs(DateTimeOffset.UtcNow.ToUnixTimeSeconds() - long.Parse(timestamp));
        if (skew > ToleranceSeconds)
            throw new InvalidOperationException("timestamp outside tolerance");

        var key = Convert.FromBase64String(secret["whsec_".Length..]);
        using var hmac = new HMACSHA256(key);
        var signed = Encoding.UTF8.GetBytes($"{id}.{timestamp}.").Concat(rawBody).ToArray();
        var expected = Encoding.UTF8.GetBytes(Convert.ToBase64String(hmac.ComputeHash(signed)));

        foreach (var entry in signatures.Split(' '))
        {
            var parts = entry.Split(',', 2);
            if (parts.Length == 2 && parts[0] == "v1" &&
                CryptographicOperations.FixedTimeEquals(Encoding.UTF8.GetBytes(parts[1]), expected))
                return;
        }
        throw new InvalidOperationException("no matching signature");
    }
}

<?php

const TOLERANCE_S = 300;

function verify_webhook(string $secret, array $headers, string $rawBody): array
{
    $id = $headers['webhook-id'] ?? '';
    $timestamp = $headers['webhook-timestamp'] ?? '';
    $signatures = $headers['webhook-signature'] ?? '';
    if ($id === '' || $timestamp === '' || $signatures === '') {
        throw new RuntimeException('missing signature headers');
    }

    if (abs(time() - (int) $timestamp) > TOLERANCE_S) {
        throw new RuntimeException('timestamp outside tolerance');
    }

    $key = base64_decode(substr($secret, strlen('whsec_')), true);
    $expected = base64_encode(hash_hmac('sha256', "$id.$timestamp.$rawBody", $key, true));

    foreach (explode(' ', $signatures) as $entry) {
        [$version, $sig] = array_pad(explode(',', $entry, 2), 2, '');
        if ($version === 'v1' && hash_equals($expected, $sig)) {
            return json_decode($rawBody, true, 512, JSON_THROW_ON_ERROR);
        }
    }
    throw new RuntimeException('no matching signature');
}

require "base64"
require "json"
require "openssl"

TOLERANCE_S = 5 * 60

def verify_webhook(secret, headers, raw_body)
  id = headers["webhook-id"]
  timestamp = headers["webhook-timestamp"]
  signatures = headers["webhook-signature"]
  raise "missing signature headers" unless id && timestamp && signatures

  raise "timestamp outside tolerance" if (Time.now.to_i - timestamp.to_i).abs > TOLERANCE_S

  key = Base64.decode64(secret.delete_prefix("whsec_"))
  digest = OpenSSL::HMAC.digest("SHA256", key, "#{id}.#{timestamp}.#{raw_body}")
  expected = Base64.strict_encode64(digest)

  ok = signatures.split(" ").any? do |entry|
    version, sig = entry.split(",", 2)
    version == "v1" && sig && OpenSSL.secure_compare(sig, expected)
  end
  raise "no matching signature" unless ok

  JSON.parse(raw_body)
end