Verify signatures

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

const app = express();
const SECRET = process.env.CIAREM_WEBHOOK_SECRET; // whsec_…
const TOLERANCE_SECONDS = 300;

function verify(rawBody, header) {
  const parts = Object.fromEntries(
    (header ?? "").split(",").map((p) => p.split("=", 2)),
  );
  const timestamp = Number(parts.t);
  if (!timestamp || !parts.v1) return false;
  if (Math.abs(Date.now() / 1000 - timestamp) > TOLERANCE_SECONDS) return false;

  const expected = crypto
    .createHmac("sha256", SECRET)
    .update(`${timestamp}.`)
    .update(rawBody)
    .digest("hex");
  const a = Buffer.from(expected);
  const b = Buffer.from(parts.v1);
  return a.length === b.length && crypto.timingSafeEqual(a, b);
}

// express.raw keeps the body as bytes. Do not use express.json() on this route.
app.post("/hooks/ciarem", express.raw({ type: "application/json" }), (req, res) => {
  if (!verify(req.body, req.get("ciarem-signature"))) {
    return res.status(400).send("invalid signature");
  }
  const event = JSON.parse(req.body);
  // Queue the event for processing, then answer right away.
  res.sendStatus(200);
});

app.listen(3000);

import hashlib
import hmac
import json
import os
import time

from fastapi import FastAPI, HTTPException, Request

app = FastAPI()
SECRET = os.environ["CIAREM_WEBHOOK_SECRET"]  # whsec_…
TOLERANCE_SECONDS = 300


def verify(raw_body: bytes, header: str | None) -> bool:
    parts = dict(p.split("=", 1) for p in (header or "").split(",") if "=" in p)
    try:
        timestamp = int(parts["t"])
        signature = parts["v1"]
    except (KeyError, ValueError):
        return False
    if abs(time.time() - timestamp) > TOLERANCE_SECONDS:
        return False
    expected = hmac.new(
        SECRET.encode(), f"{timestamp}.".encode() + raw_body, hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, signature)


@app.post("/hooks/ciarem")
async def ciarem_webhook(request: Request):
    raw_body = await request.body()  # the bytes, not request.json()
    if not verify(raw_body, request.headers.get("ciarem-signature")):
        raise HTTPException(status_code=400, detail="invalid signature")
    event = json.loads(raw_body)
    # Queue the event for processing, then answer right away.
    return {"ok": True}

<?php
$secret = getenv('CIAREM_WEBHOOK_SECRET'); // whsec_…
$tolerance = 300;

$rawBody = file_get_contents('php://input'); // the bytes, before json_decode
$header = $_SERVER['HTTP_CIAREM_SIGNATURE'] ?? '';

$parts = [];
foreach (explode(',', $header) as $pair) {
    [$key, $value] = array_pad(explode('=', $pair, 2), 2, '');
    $parts[$key] = $value;
}
$timestamp = (int) ($parts['t'] ?? 0);
$signature = $parts['v1'] ?? '';

$expected = hash_hmac('sha256', $timestamp . '.' . $rawBody, $secret);

if (
    $timestamp === 0
    || abs(time() - $timestamp) > $tolerance
    || !hash_equals($expected, $signature)
) {
    http_response_code(400);
    exit('invalid signature');
}

$event = json_decode($rawBody, true);
// Queue the event for processing, then answer right away.
http_response_code(200);

require "json"
require "openssl"
require "sinatra"

SECRET = ENV.fetch("CIAREM_WEBHOOK_SECRET") # whsec_…
TOLERANCE_SECONDS = 300

def verify(raw_body, header)
  parts = header.to_s.scan(/(\w+)=([^,]+)/).to_h
  timestamp = parts["t"].to_i
  signature = parts["v1"].to_s
  return false if timestamp.zero? || signature.empty?
  return false if (Time.now.to_i - timestamp).abs > TOLERANCE_SECONDS

  expected = OpenSSL::HMAC.hexdigest("SHA256", SECRET, "#{timestamp}.#{raw_body}")
  Rack::Utils.secure_compare(expected, signature)
end

post "/hooks/ciarem" do
  raw_body = request.body.read # the bytes, before JSON.parse
  halt 400, "invalid signature" unless verify(raw_body, request.env["HTTP_CIAREM_SIGNATURE"])
  event = JSON.parse(raw_body)
  # Queue the event for processing, then answer right away.
  status 200
end