Verify a delivery on your receiver

import crypto from "crypto";

// %XX decoded as UTF-8; bytes that are not valid UTF-8 stay as they are,
// as .NET's Uri.UnescapeDataString and ASP.NET Core's path decoding leave them.
function decodePercent(text) {
  return text.replace(/(%[0-9A-Fa-f]{2})+/g, (run) => {
    try { return decodeURIComponent(run); } catch {}
    const bytes = run.match(/%[0-9A-Fa-f]{2}/g);
    let out = "";
    for (let i = 0; i < bytes.length; ) {
      let n = Math.min(4, bytes.length - i);
      for (; n > 0; n--) {
        try { out += decodeURIComponent(bytes.slice(i, i + n).join("")); break; } catch {}
      }
      if (n === 0) { out += bytes[i]; n = 1; }
      i += n;
    }
    return out;
  });
}

// The path as Queuey signs it: percent-decoded, as ASP.NET Core reads a
// request path, except %2F, which stays encoded.
// /hooks/caf%C3%A9/order%2F1/a%20b is signed as /hooks/café/order%2F1/a b.
function canonicalPath(rawPath) {
  return (rawPath || "/").split(/(%2[Ff])/)
    .map((part, i) => (i % 2 === 1 ? part : decodePercent(part)))
    .join("");
}

// The query as Queuey signs it: decode each key and value ("+" is a space),
// sort by key, then by value, re-encode (RFC 3986), join with "&".
function normalizeQuery(rawQuery) {
  if (!rawQuery || !rawQuery.trim()) return "";
  const raw = rawQuery.startsWith("?") ? rawQuery.slice(1) : rawQuery;
  if (!raw.trim()) return "";

  const decode = (s) => decodePercent(s.replace(/\+/g, " "));
  // encodeURIComponent leaves !'()* alone; RFC 3986 escapes them.
  const encode = (s) => encodeURIComponent(s)
    .replace(/[!'()*]/g, (c) => "%" + c.charCodeAt(0).toString(16).toUpperCase());

  const pairs = raw.split("&").filter((segment) => segment.length > 0).map((segment) => {
    const i = segment.indexOf("=");
    return i < 0 ? [decode(segment), ""] : [decode(segment.slice(0, i)), decode(segment.slice(i + 1))];
  });
  const ordinal = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
  pairs.sort((x, y) => ordinal(x[0], y[0]) || ordinal(x[1], y[1]));
  return pairs.map(([key, value]) => encode(key) + "=" + encode(value)).join("&");
}

// Express-style handler. IMPORTANT: verify against the RAW body bytes,
// before any JSON parsing/re-serialization.
export function verifyQueueyDelivery(req, secret, { acceptV1 = false } = {}) {
  const keyId = req.get("X-Queuey-Key-Id");
  const timestamp = req.get("X-Queuey-Timestamp");
  const nonce = req.get("X-Queuey-Nonce");
  const contentHash = req.get("X-Queuey-Content-SHA256");
  if (!keyId || !timestamp || !nonce || !contentHash) return false;

  // 1. Reject stale deliveries (±5 minutes).
  const skew = Math.abs(Math.floor(Date.now() / 1000) - Number(timestamp));
  if (!Number.isFinite(skew) || skew > 300) return false;

  // 2. Recompute the body hash from the raw bytes; it must match the header.
  const bodyHash = crypto.createHash("sha256")
    .update(req.rawBody)              // Buffer of the raw request body
    .digest("hex").toLowerCase();
  if (contentHash.trim().toLowerCase() !== bodyHash) return false;

  // 3. The six lines v1 signs, and v2 signs first.
  const lines = [
    req.method.trim().toUpperCase(),  // METHOD
    canonicalPath(req.path),          // PATH, decoded except %2F
    normalizeQuery(req.originalUrl.split("?")[1] ?? ""), // QUERY, normalized
    timestamp,                        // TIMESTAMP
    nonce,                            // NONCE
    bodyHash,                         // CONTENT_SHA256
  ];
  const hmac = (text) => crypto
    .createHmac("sha256", Buffer.from(secret, "utf8"))
    .update(Buffer.from(text, "utf8"))
    .digest("hex");
  const same = (provided, expected) => {
    const a = Buffer.from(provided.trim().toLowerCase(), "utf8");
    const b = Buffer.from(expected, "utf8");
    return a.length === b.length && crypto.timingSafeEqual(a, b);
  };

  // 4. v2, in X-Queuey-Signatures as v2=<hex>: the six lines, then the event id
  //    and the idempotency key, trimmed, empty when the delivery has none.
  const v2 = (req.get("X-Queuey-Signatures") ?? "").split(",")
    .map((part) => part.trim())
    .find((part) => part.startsWith("v2="))
    ?.slice(3);
  if (v2) {
    const eventId = (req.get("X-Queuey-Event-Id") ?? "").trim();
    const idempotencyKey = (req.get("Idempotency-Key") ?? "").trim();
    return same(v2, hmac([...lines, eventId, idempotencyKey].join("\n")));
  }

  // 5. Only a delivery from before v2: v1, in X-Queuey-Signature. It does not
  //    cover the event id or the idempotency key, so do not deduplicate on them.
  const v1 = req.get("X-Queuey-Signature");
  return acceptV1 && Boolean(v1) && same(v1, hmac(lines.join("\n")));
}