Webhooks

# ID, TS and SIG hold the three webhook-* headers; BODY holds the raw request body.
KEY_HEX=$(printf '%s' "${NAIRI_WEBHOOK_SECRET#whsec_}" | base64 -d | xxd -p -c 256)
EXPECTED="v1,$(printf '%s.%s.%s' "$ID" "$TS" "$BODY" \
  | openssl dgst -sha256 -mac HMAC -macopt hexkey:"$KEY_HEX" -binary | base64)"

NOW=$(date +%s)
if [ $((NOW > TS ? NOW - TS : TS - NOW)) -gt 300 ]; then echo "stale timestamp"; exit 1; fi
case " $SIG " in
  *" $EXPECTED "*) echo "verified" ;;
  *) echo "bad signature"; exit 1 ;;
esac

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

const key = Buffer.from(
  (process.env.NAIRI_WEBHOOK_SECRET ?? "").replace(/^whsec_/, ""),
  "base64",
);

// headers: the request headers, lower-cased. rawBody: the exact bytes received.
export function verify(headers: Record<string, string | undefined>, rawBody: Buffer): boolean {
  const id = headers["webhook-id"];
  const timestamp = headers["webhook-timestamp"];
  const signatures = headers["webhook-signature"];
  if (!id || !timestamp || !signatures) return false;
  const sentAt = Number(timestamp);
  if (!Number.isFinite(sentAt) || Math.abs(Date.now() / 1000 - sentAt) > 300) return false;

  const expected = createHmac("sha256", key)
    .update(`${id}.${timestamp}.`)
    .update(rawBody)
    .digest();
  return signatures.split(" ").some((signature) => {
    const [version, value] = signature.split(",");
    if (version !== "v1" || !value) return false;
    const given = Buffer.from(value, "base64");
    return given.length === expected.length && timingSafeEqual(given, expected);
  });
}

require "openssl"
require "base64"

KEY = Base64.decode64(ENV.fetch("NAIRI_WEBHOOK_SECRET").delete_prefix("whsec_"))

# headers: the request headers, lower-cased. raw_body: the exact bytes received.
def verify(headers, raw_body)
  id, timestamp, signatures = headers.values_at("webhook-id", "webhook-timestamp", "webhook-signature")
  return false if id.nil? || timestamp.nil? || signatures.nil?
  return false if (Time.now.to_i - timestamp.to_i).abs > 300

  expected = OpenSSL::HMAC.digest("SHA256", KEY, "#{id}.#{timestamp}.#{raw_body}")
  signatures.split(" ").any? do |signature|
    version, value = signature.split(",", 2)
    version == "v1" && !value.nil? && secure_equal(Base64.decode64(value), expected)
  end
end

def secure_equal(a, b)
  return false unless a.bytesize == b.bytesize
  a.bytes.zip(b.bytes).reduce(0) { |acc, (x, y)| acc | (x ^ y) }.zero?
end

import base64
import binascii
import hashlib
import hmac
import os
import time

KEY = base64.b64decode(os.environ["NAIRI_WEBHOOK_SECRET"].removeprefix("whsec_"))


# headers: the request headers, lower-cased. raw_body: the exact bytes received.
def verify(headers: dict[str, str], raw_body: bytes) -> bool:
    event_id = headers.get("webhook-id")
    timestamp = headers.get("webhook-timestamp")
    signatures = headers.get("webhook-signature")
    if not event_id or not timestamp or not signatures:
        return False
    if not timestamp.isdigit() or abs(time.time() - int(timestamp)) > 300:
        return False

    expected = hmac.new(KEY, f"{event_id}.{timestamp}.".encode() + raw_body, hashlib.sha256).digest()
    for signature in signatures.split(" "):
        version, _, value = signature.partition(",")
        if version != "v1" or not value:
            continue
        try:
            given = base64.b64decode(value, validate=True)
        except (ValueError, binascii.Error):
            continue  # a malformed signature is skipped, the next one may still match
        if hmac.compare_digest(given, expected):
            return True
    return False

package main

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

var key, _ = base64.StdEncoding.DecodeString(
	strings.TrimPrefix(os.Getenv("NAIRI_WEBHOOK_SECRET"), "whsec_"),
)

// verify takes the request headers and the exact body bytes received.
func verify(headers http.Header, rawBody []byte) bool {
	id := headers.Get("webhook-id")
	timestamp := headers.Get("webhook-timestamp")
	signatures := headers.Get("webhook-signature")
	if id == "" || timestamp == "" || signatures == "" {
		return false
	}
	sent, err := strconv.ParseInt(timestamp, 10, 64)
	if err != nil || time.Since(time.Unix(sent, 0)).Abs() > 5*time.Minute {
		return false
	}

	mac := hmac.New(sha256.New, key)
	mac.Write([]byte(id + "." + timestamp + "."))
	mac.Write(rawBody)
	expected := mac.Sum(nil)
	for _, signature := range strings.Split(signatures, " ") {
		value, ok := strings.CutPrefix(signature, "v1,")
		if !ok {
			continue
		}
		given, err := base64.StdEncoding.DecodeString(value)
		if err == nil && hmac.Equal(given, expected) {
			return true
		}
	}
	return false
}