Skip to content

armgit / qm

Public Imported from GitHub
0

Multiplayer agent harness for work.

4.6 KB
Raw Blame
import { createHash, createHmac } from "node:crypto";
import type { Webhook } from "../types.ts";
import { constantTimeEqual } from "../util/crypto.ts";

export interface VerifierInput {
  secret?: string;
  headers: Record<string, string | string[] | undefined>;
  rawBody: string;
}

export interface Verifier {
  verify(input: VerifierInput): boolean;
  deliveryId(input: VerifierInput): string;
  handshake?(input: VerifierInput, parsedBody: unknown): string | null;
}

function header(headers: VerifierInput["headers"], name: string): string | undefined {
  const v = headers[name.toLowerCase()];
  return Array.isArray(v) ? v[0] : v;
}

function hmacHex(secret: string, body: string): string {
  return createHmac("sha256", secret).update(body).digest("hex");
}

function bodyHash(rawBody: string): string {
  return createHash("sha256").update(rawBody).digest("hex");
}

const isObj = (v: unknown): v is Record<string, unknown> => typeof v === "object" && v !== null;

function signedBodyId(rawBody: string, field: string): string {
  try {
    const b = JSON.parse(rawBody);
    if (isObj(b) && typeof b[field] === "string") return b[field];
  } catch {
    return bodyHash(rawBody);
  }
  return bodyHash(rawBody);
}

const github: Verifier = {
  verify({ secret, headers, rawBody }) {
    if (!secret) return false;
    const sig = header(headers, "x-hub-signature-256");
    if (!sig) return false;
    return constantTimeEqual(sig, `sha256=${hmacHex(secret, rawBody)}`);
  },
  deliveryId({ rawBody }) {
    return bodyHash(rawBody);
  },
  handshake({ headers }) {
    return header(headers, "x-github-event") === "ping" ? "pong" : null;
  },
};

const SLACK_TS_TOLERANCE_SECONDS = 60 * 5;

const slack: Verifier = {
  verify({ secret, headers, rawBody }) {
    if (!secret) return false;
    const sig = header(headers, "x-slack-signature");
    const ts = header(headers, "x-slack-request-timestamp");
    if (!sig || !ts) return false;
    const tsSeconds = Number(ts);
    if (!Number.isFinite(tsSeconds)) return false;
    if (Math.abs(Date.now() / 1000 - tsSeconds) > SLACK_TS_TOLERANCE_SECONDS) return false;
    return constantTimeEqual(sig, `v0=${hmacHex(secret, `v0:${ts}:${rawBody}`)}`);
  },
  deliveryId({ rawBody }) {
    return signedBodyId(rawBody, "event_id");
  },
  handshake(_input, parsedBody) {
    if (isObj(parsedBody) && parsedBody.type === "url_verification" && typeof parsedBody.challenge === "string") {
      return parsedBody.challenge;
    }
    return null;
  },
};

const stripe: Verifier = {
  verify({ secret, headers, rawBody }) {
    if (!secret) return false;
    const sig = header(headers, "stripe-signature");
    if (!sig) return false;
    const parts = sig.split(",").map((p) => p.split("=") as [string, string]);
    const t = parts.find(([k]) => k === "t")?.[1];
    const v1s = parts.filter(([k, v]) => k === "v1" && v).map(([, v]) => v);
    if (!t || v1s.length === 0) return false;
    const expected = hmacHex(secret, `${t}.${rawBody}`);
    return v1s.some((v1) => constantTimeEqual(v1, expected));
  },
  deliveryId({ rawBody }) {
    return signedBodyId(rawBody, "id");
  },
};

const hmacSha256: Verifier = {
  verify({ secret, headers, rawBody }) {
    if (!secret) return false;
    const raw = header(headers, "x-signature");
    if (!raw) return false;
    const sig = raw.startsWith("sha256=") ? raw.slice("sha256=".length) : raw;
    return constantTimeEqual(sig, hmacHex(secret, rawBody));
  },
  deliveryId({ rawBody }) {
    return bodyHash(rawBody);
  },
};

const LINEAR_TS_TOLERANCE_MS = 60 * 1000;

const linear: Verifier = {
  verify({ secret, headers, rawBody }) {
    if (!secret) return false;
    const sig = header(headers, "linear-signature");
    if (!sig) return false;
    if (!constantTimeEqual(sig, hmacHex(secret, rawBody))) return false;
    let body: unknown;
    try {
      body = JSON.parse(rawBody);
    } catch {
      return false;
    }
    if (
      !isObj(body) ||
      Array.isArray(body) ||
      typeof body.webhookTimestamp !== "number" ||
      !Number.isFinite(body.webhookTimestamp)
    ) {
      return false;
    }
    return Math.abs(Date.now() - body.webhookTimestamp) <= LINEAR_TS_TOLERANCE_MS;
  },
  deliveryId({ rawBody }) {
    return bodyHash(rawBody);
  },
};

const VERIFIERS: Record<WebhookScheme, Verifier> = { github, slack, stripe, linear, "hmac-sha256": hmacSha256 };

export type WebhookScheme = Webhook["verification"]["scheme"];

export const WEBHOOK_SCHEMES = Object.keys(VERIFIERS) as readonly WebhookScheme[];

export function getVerifier(scheme: string): Verifier | null {
  return (VERIFIERS as Partial<Record<string, Verifier>>)[scheme] ?? null;
}