Webhook signature verifier

import crypto from "node:crypto";
import express from "express";

const app = express();
// The endpoint secret: 64 hex characters, decoded to 32 raw bytes.
const SECRET = Buffer.from(process.env.KAIRO_WEBHOOK_SECRET, "hex");
const TOLERANCE_SECONDS = 300;

// express.raw keeps the exact bytes. Never verify a body that was parsed and serialised again.
app.post("/webhooks/kairo", express.raw({ type: "application/json" }), (req, res) => {
  const id = req.get("Kairo-Webhook-Id") ?? "";
  const timestamp = req.get("Kairo-Webhook-Timestamp") ?? "";
  const signature = req.get("Kairo-Webhook-Signature") ?? "";

  const now = Math.floor(Date.now() / 1000);
  if (!/^\d+$/.test(timestamp) || Math.abs(now - Number(timestamp)) > TOLERANCE_SECONDS) {
    return res.status(400).send("stale or missing timestamp");
  }

  const signed = Buffer.concat([Buffer.from(`${id}.${timestamp}.`), req.body]);
  const expected = "v1=" + crypto.createHmac("sha256", SECRET).update(signed).digest("hex");

  const a = Buffer.from(expected);
  const b = Buffer.from(signature);
  // timingSafeEqual throws on different lengths, so check the length first.
  if (a.length !== b.length || !crypto.timingSafeEqual(a, b)) {
    return res.status(401).send("bad signature");
  }

  const event = JSON.parse(req.body.toString("utf8"));
  // Store id and skip any delivery you have already handled.
  res.sendStatus(204);
});

app.listen(3000);

import hashlib
import hmac
import os
import time

from flask import Flask, abort, request

app = Flask(__name__)
# The endpoint secret: 64 hex characters, decoded to 32 raw bytes.
SECRET = bytes.fromhex(os.environ["KAIRO_WEBHOOK_SECRET"])
TOLERANCE_SECONDS = 300


@app.post("/webhooks/kairo")
def kairo_webhook():
    msg_id = request.headers.get("Kairo-Webhook-Id", "")
    timestamp = request.headers.get("Kairo-Webhook-Timestamp", "")
    signature = request.headers.get("Kairo-Webhook-Signature", "")
    body = request.get_data()  # raw bytes, exactly as sent

    if not timestamp.isdigit() or abs(time.time() - int(timestamp)) > TOLERANCE_SECONDS:
        abort(400)

    signed = f"{msg_id}.{timestamp}.".encode() + body
    expected = "v1=" + hmac.new(SECRET, signed, hashlib.sha256).hexdigest()

    # compare_digest takes the same time wherever the strings differ.
    if not hmac.compare_digest(expected, signature):
        abort(401)

    event = request.get_json()
    # Store msg_id and skip any delivery you have already handled.
    return "", 204

package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"io"
	"net/http"
	"os"
	"strconv"
	"time"
)

const toleranceSeconds = 300

// The endpoint secret: 64 hex characters, decoded to 32 raw bytes.
var secret = mustHex(os.Getenv("KAIRO_WEBHOOK_SECRET"))

func mustHex(s string) []byte {
	b, err := hex.DecodeString(s)
	if err != nil || len(b) == 0 {
		panic("KAIRO_WEBHOOK_SECRET must be hex")
	}
	return b
}

func kairoWebhook(w http.ResponseWriter, r *http.Request) {
	body, err := io.ReadAll(http.MaxBytesReader(w, r.Body, 1<<20))
	if err != nil {
		http.Error(w, "unreadable body", http.StatusBadRequest)
		return
	}
	id := r.Header.Get("Kairo-Webhook-Id")
	ts := r.Header.Get("Kairo-Webhook-Timestamp")
	sig := r.Header.Get("Kairo-Webhook-Signature")

	t, err := strconv.ParseInt(ts, 10, 64)
	age := time.Now().Unix() - t
	if err != nil || age > toleranceSeconds || age < -toleranceSeconds {
		http.Error(w, "stale or missing timestamp", http.StatusBadRequest)
		return
	}

	mac := hmac.New(sha256.New, secret)
	mac.Write([]byte(id + "." + ts + "."))
	mac.Write(body)
	expected := "v1=" + hex.EncodeToString(mac.Sum(nil))

	// hmac.Equal compares in constant time.
	if !hmac.Equal([]byte(expected), []byte(sig)) {
		http.Error(w, "bad signature", http.StatusUnauthorized)
		return
	}

	// Parse body here. Store id and skip any delivery you have already handled.
	w.WriteHeader(http.StatusNoContent)
}

func main() {
	http.HandleFunc("/webhooks/kairo", kairoWebhook)
	http.ListenAndServe(":8080", nil)
}