Verifying signatures

// No package needed: Node 16+ verifies Ed25519 natively.
import crypto from "node:crypto";

export function verifyNdeipiWebhook(rawBody, header, publicKeyPem, toleranceSeconds = 600) {
  let t;
  const signatures = [];
  for (const part of (header ?? "").split(",")) {
    const i = part.indexOf("=");
    const key = part.slice(0, i).trim(), value = part.slice(i + 1).trim();
    if (key === "t") t = Number(value);
    else if (key === "v1") signatures.push(Buffer.from(value, "base64"));
  }
  if (!Number.isInteger(t) || signatures.length === 0) throw new Error("Malformed Ndeipi-Signature header");
  if (Math.abs(Date.now() / 1000 - t) > toleranceSeconds) throw new Error("Webhook timestamp outside tolerance");

  const message = Buffer.concat([Buffer.from(`${t}.`), rawBody]);
  const publicKey = crypto.createPublicKey(publicKeyPem);
  if (!signatures.some((sig) => crypto.verify(null, message, publicKey, sig))) throw new Error("Invalid signature");
  return JSON.parse(rawBody.toString("utf8"));
}

// Express: keep the body raw for this route.
app.post("/ndeipi/webhooks", express.raw({ type: "application/json" }), (req, res) => {
  let event;
  try {
    event = verifyNdeipiWebhook(req.body, req.get("Ndeipi-Signature"), process.env.NDEIPI_WEBHOOK_PUBLIC_KEY);
  } catch {
    return res.sendStatus(400);
  }
  res.sendStatus(200);
  handleEvent(event); // deduplicate on event.id; skip snapshots older than you have
});

# pip install cryptography
import base64, json, time
from cryptography.exceptions import InvalidSignature
from cryptography.hazmat.primitives.serialization import load_pem_public_key

def verify_ndeipi_webhook(raw_body: bytes, header: str, public_key_pem: str, tolerance: int = 600) -> dict:
    t, signatures = None, []
    for part in (header or "").split(","):
        key, _, value = part.strip().partition("=")
        if key == "t":
            t = int(value)
        elif key == "v1":
            signatures.append(base64.b64decode(value))
    if t is None or not signatures:
        raise ValueError("Malformed Ndeipi-Signature header")
    if abs(time.time() - t) > tolerance:
        raise ValueError("Webhook timestamp outside tolerance")

    public_key = load_pem_public_key(public_key_pem.encode())
    message = f"{t}.".encode() + raw_body
    for signature in signatures:
        try:
            public_key.verify(signature, message)
            return json.loads(raw_body)
        except InvalidSignature:
            continue
    raise ValueError("Invalid signature")

// dotnet add package BouncyCastle.Cryptography
using System.Text;
using System.Text.Json;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Crypto.Signers;
using Org.BouncyCastle.Security;

public static class NdeipiWebhook
{
    public static JsonDocument Verify(byte[] rawBody, string header, string publicKeyPem, TimeSpan? tolerance = null)
    {
        long? t = null;
        var signatures = new List<byte[]>();
        foreach (var part in (header ?? "").Split(','))
        {
            var kv = part.Trim().Split('=', 2);
            if (kv.Length != 2) continue;
            if (kv[0] == "t" && long.TryParse(kv[1], out var seconds)) t = seconds;
            else if (kv[0] == "v1") signatures.Add(Convert.FromBase64String(kv[1]));
        }
        if (t is null || signatures.Count == 0)
            throw new InvalidOperationException("Malformed Ndeipi-Signature header");
        var limit = (tolerance ?? TimeSpan.FromMinutes(10)).TotalSeconds;
        if (Math.Abs(DateTimeOffset.UtcNow.ToUnixTimeSeconds() - t.Value) > limit)
            throw new InvalidOperationException("Webhook timestamp outside tolerance");

        var der = Convert.FromBase64String(string.Concat(publicKeyPem.Split('\n')
            .Select(l => l.Trim()).Where(l => l.Length > 0 && !l.StartsWith("-----"))));
        var publicKey = (Ed25519PublicKeyParameters)PublicKeyFactory.CreateKey(der);
        var message = Encoding.ASCII.GetBytes($"{t}.").Concat(rawBody).ToArray();

        foreach (var signature in signatures)
        {
            var verifier = new Ed25519Signer();
            verifier.Init(false, publicKey);
            verifier.BlockUpdate(message, 0, message.Length);
            if (verifier.VerifySignature(signature)) return JsonDocument.Parse(rawBody);
        }
        throw new InvalidOperationException("Invalid signature");
    }
}