Verification

Zest-Signature: t=1714829400,v1=4f1a8b...

import hashlib
import hmac
import time
from fastapi import HTTPException, Request

WEBHOOK_SECRET = "whsec_..."  # from your secrets vault
REPLAY_WINDOW_SECONDS = 300

def parse_header(header: str) -> tuple[int, str] | None:
    parts: dict[str, str] = {}
    for segment in header.split(","):
        segment = segment.strip()
        if "=" not in segment:
            return None
        key, value = segment.split("=", 1)
        parts[key.strip()] = value.strip()
    try:
        return int(parts["t"]), parts["v1"]
    except (KeyError, ValueError):
        return None

def verify(secret: str, body: bytes, header: str, now_unix: int) -> bool:
    parsed = parse_header(header)
    if parsed is None:
        return False
    timestamp, provided = parsed
    if abs(now_unix - timestamp) > REPLAY_WINDOW_SECONDS:
        return False
    expected = hmac.new(
        key=secret.encode("utf-8"),
        msg=f"{timestamp}.".encode("ascii") + body,
        digestmod=hashlib.sha256,
    ).hexdigest()
    return hmac.compare_digest(expected, provided)

async def webhook_endpoint(request: Request):
    raw_body = await request.body()
    sig = request.headers.get("Zest-Signature", "")
    if not verify(WEBHOOK_SECRET, raw_body, sig, int(time.time())):
        raise HTTPException(status_code=401, detail="invalid signature")
    # ... dedup on eventId, then process

import crypto from "node:crypto";

const WEBHOOK_SECRET = process.env.ZEST_WEBHOOK_SECRET;
const REPLAY_WINDOW_SECONDS = 300;

function parseHeader(header) {
  const parts = Object.fromEntries(
    header.split(",").map((s) => s.trim().split("=").map((p) => p.trim())),
  );
  if (!parts.t || !parts.v1) return null;
  const t = Number.parseInt(parts.t, 10);
  if (Number.isNaN(t)) return null;
  return { t, v1: parts.v1 };
}

export function verifyWebhook(rawBody, header) {
  const parsed = parseHeader(header);
  if (!parsed) return false;
  const now = Math.floor(Date.now() / 1000);
  if (Math.abs(now - parsed.t) > REPLAY_WINDOW_SECONDS) return false;

  const payload = Buffer.concat([
    Buffer.from(`${parsed.t}.`, "ascii"),
    Buffer.isBuffer(rawBody) ? rawBody : Buffer.from(rawBody),
  ]);
  const expected = crypto
    .createHmac("sha256", WEBHOOK_SECRET)
    .update(payload)
    .digest("hex");

  const a = Buffer.from(expected, "hex");
  const b = Buffer.from(parsed.v1, "hex");
  return a.length === b.length && crypto.timingSafeEqual(a, b);
}

// Express handler. IMPORTANT: use express.raw({ type: "application/json" }) so
// req.body is a raw Buffer; signature must be computed over the *exact* bytes.
export function zestWebhookHandler(req, res) {
  const ok = verifyWebhook(req.body, req.get("Zest-Signature") || "");
  if (!ok) return res.status(401).send("invalid signature");
  const event = JSON.parse(req.body.toString("utf8"));
  // ... dedup on event.eventId, then process
  res.status(200).send("ok");
}