Webhooks

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

const TOLERANCE_SECONDS = 300;

/**
 * @param rawBody the EXACT bytes we sent — not a re-serialized object.
 * @param header  the X-XOsign-Signature header value.
 * @param secret  the endpoint's whsec_… secret.
 */
export function verifyXOsignWebhook(rawBody, header, secret) {
  const parts = Object.fromEntries(
    String(header ?? "").split(",").map((kv) => {
      const i = kv.indexOf("=");
      return [kv.slice(0, i).trim(), kv.slice(i + 1).trim()];
    }),
  );
  const { t, v1 } = parts;
  if (!t || !v1) return false;

  // Reject old captures. The timestamp is inside the signed string, so it
  // cannot be edited without breaking the signature.
  if (Math.abs(Date.now() / 1000 - Number(t)) > TOLERANCE_SECONDS) return false;

  const expected = createHmac("sha256", secret)
    .update(`${t}.${rawBody}`)
    .digest("hex");

  const a = Buffer.from(v1, "hex");
  const b = Buffer.from(expected, "hex");
  // Constant-time — a plain === leaks how much of the digest matched.
  return a.length === b.length && timingSafeEqual(a, b);
}

import hashlib, hmac, time

TOLERANCE_SECONDS = 300


def verify_xosign_webhook(raw_body: bytes, header: str, secret: str) -> bool:
    """raw_body must be the EXACT bytes received, not a re-serialized dict."""
    try:
        parts = dict(kv.split("=", 1) for kv in (header or "").split(","))
        t, v1 = parts["t"].strip(), parts["v1"].strip()
    except (ValueError, KeyError):
        return False

    # Reject old captures. The timestamp is inside the signed string.
    if abs(time.time() - int(t)) > TOLERANCE_SECONDS:
        return False

    expected = hmac.new(
        secret.encode(),
        f"{t}.".encode() + raw_body,
        hashlib.sha256,
    ).hexdigest()

    # Constant-time — a plain == leaks how much of the digest matched.
    return hmac.compare_digest(v1, expected)

import express from "express";

const app = express();

app.post(
  "/webhooks/xosign",
  // express.raw is essential: express.json() would parse and discard the
  // exact bytes, and a re-serialized body will not match the signature.
  express.raw({ type: "application/json" }),
  (req, res) => {
    const ok = verifyXOsignWebhook(
      req.body.toString("utf8"),
      req.get("X-XOsign-Signature"),
      process.env.XOSIGN_WEBHOOK_SECRET,
    );
    if (!ok) return res.status(400).send("bad signature");

    const event = JSON.parse(req.body.toString("utf8"));

    // Acknowledge FIRST, work afterwards. We time out after 10 seconds and
    // will retry — slow handlers cause duplicate deliveries.
    res.status(200).end();

    // event.id is stable across retries and redeliveries: dedupe on it.
    void handleEvent(event);
  },
);