How Standard Webhooks signs webhooks

const crypto = require('node:crypto');

const TOLERANCE_SECONDS = 300;

/**
 * Verify a Standard Webhooks webhook. rawBody: the request body as a Buffer, exactly as received
 * (before any JSON parsing); headers: lower-case names, as in req.headers.
 */
function verifyWebhook(rawBody, headers, secret, url = '', method = 'POST') {
  rawBody = Buffer.from(rawBody);
  const header = headers['webhook-signature'] || '';
  const signatures = header.split(' ').map((s) => s.split(',')).filter(([v]) => v === 'v1').map(([, s]) => s);
  const ts = headers['webhook-timestamp'] || '';
  const signed = Buffer.concat([Buffer.from((headers['webhook-id'] || '') + '.' + ts + '.'), rawBody]);
  const key = Buffer.from(secret.replace(/^whsec_/, ''), 'base64');
  const expected = crypto.createHmac('sha256', key).update(signed).digest('base64');
  const valid = signatures.some((sig) => {
    const a = Buffer.from(sig);
    const b = Buffer.from(expected);
    return a.length === b.length && crypto.timingSafeEqual(a, b);
  });
  if (!valid) return false;
  const signedAt = Number(ts);
  return Number.isFinite(signedAt) && Math.abs(Date.now() / 1000 - signedAt) <= TOLERANCE_SECONDS;
}

// Express: keep the raw body for this route
// app.post('/webhooks/standard-webhooks', express.raw({ type: '*/*' }), (req, res) => {
//   if (!verifyWebhook(req.body, req.headers, process.env.STANDARD_WEBHOOKS_WEBHOOK_SECRET)) return res.sendStatus(401);
//   res.sendStatus(200); // then process the event asynchronously
// });

import base64
import hashlib
import hmac
import time

TOLERANCE_SECONDS = 300


def verify_webhook(raw_body: bytes, headers, secret: str, url: str = '', method: str = 'POST') -> bool:
    """Verify a Standard Webhooks webhook. raw_body: the request body exactly as received (bytes);
    headers: a mapping with lower-case names (Flask and Django headers are case-insensitive)."""
    header = headers.get('webhook-signature', '')
    signatures = [s.split(',', 1)[1] for s in header.split(' ') if s.startswith('v1,')]
    ts = headers.get('webhook-timestamp', '')
    signed = (headers.get('webhook-id', '') + '.' + ts + '.').encode() + raw_body
    key = base64.b64decode(secret.removeprefix('whsec_'))
    digest = hmac.new(key, signed, hashlib.sha256).digest()
    expected = base64.b64encode(digest).decode()
    if not any(hmac.compare_digest(sig, expected) for sig in signatures):
        return False
    try:
        signed_at = int(ts)
    except ValueError:
        return False
    return abs(time.time() - signed_at) <= TOLERANCE_SECONDS


# Flask: verify_webhook(request.get_data(), request.headers, SECRET)

<?php

const TOLERANCE_SECONDS = 300;

/**
 * Verify a Standard Webhooks webhook. $rawBody: file_get_contents('php://input'), before any decoding;
 * $headers: lower-case names, e.g. array_change_key_case(getallheaders()).
 */
function verify_webhook(string $rawBody, array $headers, string $secret, string $url = '', string $method = 'POST'): bool
{
    $header = (string) ($headers['webhook-signature'] ?? '');
    $signatures = [];
    foreach (explode(' ', $header) as $entry) {
        [$version, $sig] = array_pad(explode(',', $entry, 2), 2, '');
        if ($version === 'v1') {
            $signatures[] = $sig;
        }
    }
    $ts = (string) ($headers['webhook-timestamp'] ?? '');
    $signed = ($headers['webhook-id'] ?? '') . '.' . $ts . '.' . $rawBody;
    $key = base64_decode(preg_replace('/^whsec_/', '', $secret));
    $expected = base64_encode(hash_hmac('sha256', $signed, $key, true));
    $valid = false;
    foreach ($signatures as $sig) {
        $valid = $valid || hash_equals($expected, $sig);
    }
    if (! $valid) {
        return false;
    }
    $signedAt = (int) $ts;

    return $signedAt > 0 && abs(time() - $signedAt) <= TOLERANCE_SECONDS;
}

package webhooks

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

const toleranceSeconds = 300

// VerifyWebhook checks a Standard Webhooks webhook. rawBody is the request body exactly as received
// (io.ReadAll(r.Body) before any decoding).
func VerifyWebhook(rawBody []byte, h http.Header, secret, url, method string) bool {
	header := h.Get("webhook-signature")
	var signatures []string
	for _, entry := range strings.Split(header, " ") {
		if version, sig, ok := strings.Cut(entry, ","); ok && version == "v1" {
			signatures = append(signatures, sig)
		}
	}
	ts := h.Get("webhook-timestamp")
	signed := []byte{}
	signed = append(signed, h.Get("webhook-id")...)
	signed = append(signed, "."...)
	signed = append(signed, ts...)
	signed = append(signed, "."...)
	signed = append(signed, rawBody...)
	key, err := base64.StdEncoding.DecodeString(strings.TrimPrefix(secret, "whsec_"))
	if err != nil {
		return false
	}
	mac := hmac.New(sha256.New, key)
	mac.Write(signed)
	expected := base64.StdEncoding.EncodeToString(mac.Sum(nil))
	valid := false
	for _, sig := range signatures {
		if hmac.Equal([]byte(sig), []byte(expected)) {
			valid = true
		}
	}
	if !valid {
		return false
	}
	n, err := strconv.ParseFloat(ts, 64)
	if err != nil {
		return false
	}
	signedAt := n
	return math.Abs(float64(time.Now().Unix())-signedAt) <= toleranceSeconds
}