@algovoi/rfc9421-verifier 0.2.0 → 0.2.1

package/dist/verify.js

@@ -111,10 +111,10 @@ export async function verifyRequest(input) {
         return fail(result, `Signature label ${sigParsed.label} does not match Signature-Input label ${parsedSi.label}`);
     }
     const requireCd = input.requireContentDigest ?? true;
-    // null = no algorithm requirement (accept any); undefined = default to sha-256
-    const requireAlg = input.requireAlgorithm === null
-        ? undefined
-        : (input.requireAlgorithm ?? "sha-256");
+    // string = enforce that specific algorithm; null or undefined = accept any
+    // supported algorithm present in the Content-Digest header (SHA-256 or
+    // SHA-512 in this v0.2.x). Default is permissive.
+    const requireAlg = input.requireAlgorithm == null ? undefined : input.requireAlgorithm;
     if (requireCd) {
         const cdHeader = normHeaders["content-digest"];
         if (!cdHeader)

package/package.json

@@ -1,62 +1,62 @@
-{
-  "name": "@algovoi/rfc9421-verifier",
-  "version": "0.2.0",
-  "description": "AlgoVoi RFC 9421 HTTP Message Signatures + RFC 9530 Content-Digest reference verifier",
-  "keywords": [
-    "rfc9421",
-    "rfc9530",
-    "http-signatures",
-    "ed25519",
-    "agentic-payments",
-    "compliance"
-  ],
-  "homepage": "https://github.com/chopmob-cloud/algovoi-rfc9421-verifier",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/chopmob-cloud/algovoi-rfc9421-verifier.git",
-    "directory": "typescript"
-  },
-  "bugs": {
-    "url": "https://github.com/chopmob-cloud/algovoi-rfc9421-verifier/issues"
-  },
-  "license": "Apache-2.0",
-  "author": "AlgoVoi <chopmob@gmail.com>",
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "files": [
-    "dist/**/*",
-    "src/**/*",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "clean": "rimraf dist",
-    "prepublishOnly": "npm run clean && npm run build && npm test"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "dependencies": {
-    "@noble/ed25519": "^2.1.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "rimraf": "^5.0.0",
-    "typescript": "^5.4.0",
-    "vitest": "^1.6.0"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}
+{
+  "name": "@algovoi/rfc9421-verifier",
+  "version": "0.2.1",
+  "description": "AlgoVoi RFC 9421 HTTP Message Signatures + RFC 9530 Content-Digest reference verifier",
+  "keywords": [
+    "rfc9421",
+    "rfc9530",
+    "http-signatures",
+    "ed25519",
+    "agentic-payments",
+    "compliance"
+  ],
+  "homepage": "https://github.com/chopmob-cloud/algovoi-rfc9421-verifier",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chopmob-cloud/algovoi-rfc9421-verifier.git",
+    "directory": "typescript"
+  },
+  "bugs": {
+    "url": "https://github.com/chopmob-cloud/algovoi-rfc9421-verifier/issues"
+  },
+  "license": "Apache-2.0",
+  "author": "AlgoVoi <chopmob@gmail.com>",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist/**/*",
+    "src/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rimraf dist",
+    "prepublishOnly": "npm run clean && npm run build && npm test"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@noble/ed25519": "^2.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "rimraf": "^5.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^1.6.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/parse.ts

@@ -1,148 +1,148 @@
-/**
- * RFC 9421 Signature-Input and Signature header parsers.
- *
- * Mirror of the Python algovoi_rfc9421_verifier.parse module.
- */
-
-export class SignatureInputParseError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "SignatureInputParseError";
-  }
-}
-
-export interface ParsedSignatureInput {
-  label: string;
-  covered_components: string[];
-  parameters: Record<string, string | number>;
-  raw: string;
-  /**
-   * The post-label portion of the Signature-Input header value, i.e.
-   * the Inner List + parameters block exactly as it appeared on the
-   * wire. This is the value that the @signature-params line in the
-   * RFC 9421 §2.5 signing base must carry. Empty string if the input
-   * was the unlabelled form.
-   */
-  params_block: string;
-}
-
-const LABEL_RE = /^\s*([A-Za-z][A-Za-z0-9_-]*)\s*=\s*/;
-const COVERED_RE = /\(\s*(?:"[^"]*"\s*)*\)/;
-const QUOTED_RE = /"([^"]*)"/g;
-const PARAM_RE = /([A-Za-z][A-Za-z0-9_-]*)=([^;,\s]+|"[^"]*")/g;
-
-export function parseSignatureInput(headerValue: string): ParsedSignatureInput {
-  if (typeof headerValue !== "string") {
-    throw new SignatureInputParseError(
-      `header must be string, got ${typeof headerValue}`,
-    );
-  }
-  const trimmed = headerValue.trim();
-  if (trimmed.length === 0) {
-    throw new SignatureInputParseError("empty header value");
-  }
-
-  let label: string;
-  let rest: string;
-
-  const labelMatch = LABEL_RE.exec(trimmed);
-  if (labelMatch) {
-    label = labelMatch[1];
-    rest = trimmed.slice(labelMatch[0].length);
-  } else if (trimmed.startsWith("(")) {
-    label = "";
-    rest = trimmed;
-  } else {
-    throw new SignatureInputParseError(
-      `no label or covered-components list found at start: ${JSON.stringify(trimmed.slice(0, 40))}`,
-    );
-  }
-
-  // Capture the post-label portion verbatim. This is what the
-  // @signature-params line of the RFC 9421 signing base must contain.
-  const paramsBlock = rest;
-
-  const coveredMatch = COVERED_RE.exec(rest);
-  if (!coveredMatch) {
-    throw new SignatureInputParseError("no covered-components list found");
-  }
-  const coveredRaw = coveredMatch[0];
-  const covered: string[] = [];
-  let qm: RegExpExecArray | null;
-  const localQuoted = /"([^"]*)"/g;
-  while ((qm = localQuoted.exec(coveredRaw)) !== null) {
-    covered.push(qm[1]);
-  }
-  rest = rest.slice(coveredMatch.index + coveredRaw.length);
-
-  const parameters: Record<string, string | number> = {};
-  const localParam = new RegExp(PARAM_RE.source, "g");
-  let pm: RegExpExecArray | null;
-  while ((pm = localParam.exec(rest)) !== null) {
-    const key = pm[1];
-    const raw = pm[2];
-    if (raw.startsWith('"') && raw.endsWith('"')) {
-      parameters[key] = raw.slice(1, -1);
-    } else if (/^-?\d+$/.test(raw)) {
-      parameters[key] = parseInt(raw, 10);
-    } else {
-      parameters[key] = raw;
-    }
-  }
-
-  return {
-    label,
-    covered_components: covered,
-    parameters,
-    raw: trimmed,
-    params_block: paramsBlock,
-  };
-}
-
-export function parseSignatureValue(headerValue: string): {
-  label: string;
-  signature: Uint8Array;
-} {
-  if (typeof headerValue !== "string") {
-    throw new SignatureInputParseError(
-      `header must be string, got ${typeof headerValue}`,
-    );
-  }
-  const trimmed = headerValue.trim();
-  if (trimmed.length === 0) {
-    throw new SignatureInputParseError("empty Signature header value");
-  }
-
-  let label: string;
-  let rest: string;
-
-  const labelMatch = LABEL_RE.exec(trimmed);
-  if (labelMatch) {
-    label = labelMatch[1];
-    rest = trimmed.slice(labelMatch[0].length).trim();
-  } else if (trimmed.startsWith(":")) {
-    label = "";
-    rest = trimmed;
-  } else {
-    throw new SignatureInputParseError(
-      `no label or signature-value prefix found at start: ${JSON.stringify(trimmed.slice(0, 40))}`,
-    );
-  }
-
-  if (!rest.startsWith(":") || !rest.endsWith(":")) {
-    throw new SignatureInputParseError(
-      "signature value must be wrapped in colons (RFC 8941 byte-sequence form)",
-    );
-  }
-
-  const sigB64 = rest.slice(1, -1);
-  let sigBytes: Uint8Array;
-  try {
-    sigBytes = new Uint8Array(Buffer.from(sigB64, "base64"));
-  } catch (e) {
-    throw new SignatureInputParseError(
-      `signature value is not valid base64: ${(e as Error).message}`,
-    );
-  }
-  return { label, signature: sigBytes };
-}
+/**
+ * RFC 9421 Signature-Input and Signature header parsers.
+ *
+ * Mirror of the Python algovoi_rfc9421_verifier.parse module.
+ */
+
+export class SignatureInputParseError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "SignatureInputParseError";
+  }
+}
+
+export interface ParsedSignatureInput {
+  label: string;
+  covered_components: string[];
+  parameters: Record<string, string | number>;
+  raw: string;
+  /**
+   * The post-label portion of the Signature-Input header value, i.e.
+   * the Inner List + parameters block exactly as it appeared on the
+   * wire. This is the value that the @signature-params line in the
+   * RFC 9421 §2.5 signing base must carry. Empty string if the input
+   * was the unlabelled form.
+   */
+  params_block: string;
+}
+
+const LABEL_RE = /^\s*([A-Za-z][A-Za-z0-9_-]*)\s*=\s*/;
+const COVERED_RE = /\(\s*(?:"[^"]*"\s*)*\)/;
+const QUOTED_RE = /"([^"]*)"/g;
+const PARAM_RE = /([A-Za-z][A-Za-z0-9_-]*)=([^;,\s]+|"[^"]*")/g;
+
+export function parseSignatureInput(headerValue: string): ParsedSignatureInput {
+  if (typeof headerValue !== "string") {
+    throw new SignatureInputParseError(
+      `header must be string, got ${typeof headerValue}`,
+    );
+  }
+  const trimmed = headerValue.trim();
+  if (trimmed.length === 0) {
+    throw new SignatureInputParseError("empty header value");
+  }
+
+  let label: string;
+  let rest: string;
+
+  const labelMatch = LABEL_RE.exec(trimmed);
+  if (labelMatch) {
+    label = labelMatch[1];
+    rest = trimmed.slice(labelMatch[0].length);
+  } else if (trimmed.startsWith("(")) {
+    label = "";
+    rest = trimmed;
+  } else {
+    throw new SignatureInputParseError(
+      `no label or covered-components list found at start: ${JSON.stringify(trimmed.slice(0, 40))}`,
+    );
+  }
+
+  // Capture the post-label portion verbatim. This is what the
+  // @signature-params line of the RFC 9421 signing base must contain.
+  const paramsBlock = rest;
+
+  const coveredMatch = COVERED_RE.exec(rest);
+  if (!coveredMatch) {
+    throw new SignatureInputParseError("no covered-components list found");
+  }
+  const coveredRaw = coveredMatch[0];
+  const covered: string[] = [];
+  let qm: RegExpExecArray | null;
+  const localQuoted = /"([^"]*)"/g;
+  while ((qm = localQuoted.exec(coveredRaw)) !== null) {
+    covered.push(qm[1]);
+  }
+  rest = rest.slice(coveredMatch.index + coveredRaw.length);
+
+  const parameters: Record<string, string | number> = {};
+  const localParam = new RegExp(PARAM_RE.source, "g");
+  let pm: RegExpExecArray | null;
+  while ((pm = localParam.exec(rest)) !== null) {
+    const key = pm[1];
+    const raw = pm[2];
+    if (raw.startsWith('"') && raw.endsWith('"')) {
+      parameters[key] = raw.slice(1, -1);
+    } else if (/^-?\d+$/.test(raw)) {
+      parameters[key] = parseInt(raw, 10);
+    } else {
+      parameters[key] = raw;
+    }
+  }
+
+  return {
+    label,
+    covered_components: covered,
+    parameters,
+    raw: trimmed,
+    params_block: paramsBlock,
+  };
+}
+
+export function parseSignatureValue(headerValue: string): {
+  label: string;
+  signature: Uint8Array;
+} {
+  if (typeof headerValue !== "string") {
+    throw new SignatureInputParseError(
+      `header must be string, got ${typeof headerValue}`,
+    );
+  }
+  const trimmed = headerValue.trim();
+  if (trimmed.length === 0) {
+    throw new SignatureInputParseError("empty Signature header value");
+  }
+
+  let label: string;
+  let rest: string;
+
+  const labelMatch = LABEL_RE.exec(trimmed);
+  if (labelMatch) {
+    label = labelMatch[1];
+    rest = trimmed.slice(labelMatch[0].length).trim();
+  } else if (trimmed.startsWith(":")) {
+    label = "";
+    rest = trimmed;
+  } else {
+    throw new SignatureInputParseError(
+      `no label or signature-value prefix found at start: ${JSON.stringify(trimmed.slice(0, 40))}`,
+    );
+  }
+
+  if (!rest.startsWith(":") || !rest.endsWith(":")) {
+    throw new SignatureInputParseError(
+      "signature value must be wrapped in colons (RFC 8941 byte-sequence form)",
+    );
+  }
+
+  const sigB64 = rest.slice(1, -1);
+  let sigBytes: Uint8Array;
+  try {
+    sigBytes = new Uint8Array(Buffer.from(sigB64, "base64"));
+  } catch (e) {
+    throw new SignatureInputParseError(
+      `signature value is not valid base64: ${(e as Error).message}`,
+    );
+  }
+  return { label, signature: sigBytes };
+}

package/src/signing-base.ts

@@ -1,139 +1,139 @@
-/**
- * RFC 9421 Section 2.5 signing-base construction.
- *
- * Mirror of the Python algovoi_rfc9421_verifier.signing_base module.
- */
-
-export class SigningBaseError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "SigningBaseError";
-  }
-}
-
-export type SigningBaseMode = "algovoi-v0" | "rfc9421";
-
-export interface SigningBaseInput {
-  coveredComponents: string[];
-  method?: string;
-  authority?: string;
-  path?: string;
-  targetUri?: string;
-  scheme?: string;
-  status?: number;
-  headers?: Record<string, string>;
-  parameters?: Record<string, string | number>;
-  /**
-   * Signing-base mode.
-   * - "algovoi-v0" (default): preserves the v0.1.0 behaviour for
-   *   backward compatibility with the AlgoVoi internal fixture and
-   *   the rfc9421_proxy_chain_v0 conformance set. @method is
-   *   lowercased and no @signature-params line is appended.
-   * - "rfc9421": full RFC 9421 §2.5 compliance. @method is preserved
-   *   as-supplied (HTTP convention is uppercase), and a final
-   *   "@signature-params" line is appended carrying
-   *   signatureParamsRaw verbatim. This is the shape required to
-   *   verify external fixtures (Envoys envoys-rfc9421, Hippo
-   *   hippo-rfc9421, RFC 9421 §B test vectors, and any other
-   *   RFC-compliant implementation).
-   */
-  mode?: SigningBaseMode;
-  /**
-   * The post-label portion of the Signature-Input header value, i.e.
-   * the Inner List + parameters block exactly as it appeared on the
-   * wire. Required when mode is "rfc9421".
-   */
-  signatureParamsRaw?: string;
-}
-
-export function buildSigningBase(input: SigningBaseInput): string {
-  const mode: SigningBaseMode = input.mode ?? "algovoi-v0";
-  if (mode !== "algovoi-v0" && mode !== "rfc9421") {
-    throw new SigningBaseError(
-      `mode must be "algovoi-v0" or "rfc9421", got ${JSON.stringify(mode)}`,
-    );
-  }
-  if (mode === "rfc9421" && input.signatureParamsRaw === undefined) {
-    throw new SigningBaseError(
-      "rfc9421 mode requires signatureParamsRaw (the post-label portion of the Signature-Input header)",
-    );
-  }
-
-  const normHeaders: Record<string, string> = {};
-  for (const [k, v] of Object.entries(input.headers ?? {})) {
-    normHeaders[k.toLowerCase()] = v;
-  }
-  const parameters = input.parameters ?? {};
-  const lines: string[] = [];
-
-  for (const component of input.coveredComponents) {
-    const c = component.toLowerCase();
-    let value: string;
-
-    switch (c) {
-      case "@method":
-        if (input.method === undefined)
-          throw new SigningBaseError("@method covered but method not supplied");
-        value = mode === "rfc9421" ? input.method : input.method.toLowerCase();
-        break;
-      case "@authority":
-        if (input.authority === undefined)
-          throw new SigningBaseError("@authority covered but authority not supplied");
-        value = input.authority.toLowerCase();
-        break;
-      case "@path":
-        if (input.path === undefined)
-          throw new SigningBaseError("@path covered but path not supplied");
-        value = input.path;
-        break;
-      case "@target-uri":
-        if (input.targetUri === undefined)
-          throw new SigningBaseError("@target-uri covered but targetUri not supplied");
-        value = input.targetUri;
-        break;
-      case "@scheme":
-        if (input.scheme === undefined)
-          throw new SigningBaseError("@scheme covered but scheme not supplied");
-        value = input.scheme.toLowerCase();
-        break;
-      case "@status":
-        if (input.status === undefined)
-          throw new SigningBaseError("@status covered but status not supplied");
-        value = String(input.status);
-        break;
-      case "created":
-        if (!("created" in parameters))
-          throw new SigningBaseError(
-            "'created' covered but no 'created' parameter in Signature-Input",
-          );
-        value = String(parameters["created"]);
-        break;
-      case "expires":
-        if (!("expires" in parameters))
-          throw new SigningBaseError(
-            "'expires' covered but no 'expires' parameter in Signature-Input",
-          );
-        value = String(parameters["expires"]);
-        break;
-      default:
-        if (c.startsWith("@")) {
-          throw new SigningBaseError(`unsupported derived component: ${component}`);
-        }
-        if (!(c in normHeaders)) {
-          throw new SigningBaseError(
-            `covered header ${JSON.stringify(component)} not present in supplied headers`,
-          );
-        }
-        value = normHeaders[c];
-        break;
-    }
-
-    lines.push(`"${c}": ${value}`);
-  }
-
-  if (mode === "rfc9421") {
-    lines.push(`"@signature-params": ${input.signatureParamsRaw}`);
-  }
-
-  return lines.join("\n");
-}
+/**
+ * RFC 9421 Section 2.5 signing-base construction.
+ *
+ * Mirror of the Python algovoi_rfc9421_verifier.signing_base module.
+ */
+
+export class SigningBaseError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "SigningBaseError";
+  }
+}
+
+export type SigningBaseMode = "algovoi-v0" | "rfc9421";
+
+export interface SigningBaseInput {
+  coveredComponents: string[];
+  method?: string;
+  authority?: string;
+  path?: string;
+  targetUri?: string;
+  scheme?: string;
+  status?: number;
+  headers?: Record<string, string>;
+  parameters?: Record<string, string | number>;
+  /**
+   * Signing-base mode.
+   * - "algovoi-v0" (default): preserves the v0.1.0 behaviour for
+   *   backward compatibility with the AlgoVoi internal fixture and
+   *   the rfc9421_proxy_chain_v0 conformance set. @method is
+   *   lowercased and no @signature-params line is appended.
+   * - "rfc9421": full RFC 9421 §2.5 compliance. @method is preserved
+   *   as-supplied (HTTP convention is uppercase), and a final
+   *   "@signature-params" line is appended carrying
+   *   signatureParamsRaw verbatim. This is the shape required to
+   *   verify external fixtures (Envoys envoys-rfc9421, Hippo
+   *   hippo-rfc9421, RFC 9421 §B test vectors, and any other
+   *   RFC-compliant implementation).
+   */
+  mode?: SigningBaseMode;
+  /**
+   * The post-label portion of the Signature-Input header value, i.e.
+   * the Inner List + parameters block exactly as it appeared on the
+   * wire. Required when mode is "rfc9421".
+   */
+  signatureParamsRaw?: string;
+}
+
+export function buildSigningBase(input: SigningBaseInput): string {
+  const mode: SigningBaseMode = input.mode ?? "algovoi-v0";
+  if (mode !== "algovoi-v0" && mode !== "rfc9421") {
+    throw new SigningBaseError(
+      `mode must be "algovoi-v0" or "rfc9421", got ${JSON.stringify(mode)}`,
+    );
+  }
+  if (mode === "rfc9421" && input.signatureParamsRaw === undefined) {
+    throw new SigningBaseError(
+      "rfc9421 mode requires signatureParamsRaw (the post-label portion of the Signature-Input header)",
+    );
+  }
+
+  const normHeaders: Record<string, string> = {};
+  for (const [k, v] of Object.entries(input.headers ?? {})) {
+    normHeaders[k.toLowerCase()] = v;
+  }
+  const parameters = input.parameters ?? {};
+  const lines: string[] = [];
+
+  for (const component of input.coveredComponents) {
+    const c = component.toLowerCase();
+    let value: string;
+
+    switch (c) {
+      case "@method":
+        if (input.method === undefined)
+          throw new SigningBaseError("@method covered but method not supplied");
+        value = mode === "rfc9421" ? input.method : input.method.toLowerCase();
+        break;
+      case "@authority":
+        if (input.authority === undefined)
+          throw new SigningBaseError("@authority covered but authority not supplied");
+        value = input.authority.toLowerCase();
+        break;
+      case "@path":
+        if (input.path === undefined)
+          throw new SigningBaseError("@path covered but path not supplied");
+        value = input.path;
+        break;
+      case "@target-uri":
+        if (input.targetUri === undefined)
+          throw new SigningBaseError("@target-uri covered but targetUri not supplied");
+        value = input.targetUri;
+        break;
+      case "@scheme":
+        if (input.scheme === undefined)
+          throw new SigningBaseError("@scheme covered but scheme not supplied");
+        value = input.scheme.toLowerCase();
+        break;
+      case "@status":
+        if (input.status === undefined)
+          throw new SigningBaseError("@status covered but status not supplied");
+        value = String(input.status);
+        break;
+      case "created":
+        if (!("created" in parameters))
+          throw new SigningBaseError(
+            "'created' covered but no 'created' parameter in Signature-Input",
+          );
+        value = String(parameters["created"]);
+        break;
+      case "expires":
+        if (!("expires" in parameters))
+          throw new SigningBaseError(
+            "'expires' covered but no 'expires' parameter in Signature-Input",
+          );
+        value = String(parameters["expires"]);
+        break;
+      default:
+        if (c.startsWith("@")) {
+          throw new SigningBaseError(`unsupported derived component: ${component}`);
+        }
+        if (!(c in normHeaders)) {
+          throw new SigningBaseError(
+            `covered header ${JSON.stringify(component)} not present in supplied headers`,
+          );
+        }
+        value = normHeaders[c];
+        break;
+    }
+
+    lines.push(`"${c}": ${value}`);
+  }
+
+  if (mode === "rfc9421") {
+    lines.push(`"@signature-params": ${input.signatureParamsRaw}`);
+  }
+
+  return lines.join("\n");
+}

package/src/verify.ts

@@ -1,256 +1,256 @@
-/**
- * RFC 9421 + RFC 9530 verification top-level.
- *
- * Mirror of the Python algovoi_rfc9421_verifier.verify module.
- * Uses @noble/ed25519 for Ed25519 verification.
- */
-
-import * as ed25519 from "@noble/ed25519";
-
-import {
-  parseSignatureInput,
-  parseSignatureValue,
-  SignatureInputParseError,
-} from "./parse.js";
-import {
-  buildSigningBase,
-  SigningBaseError,
-  type SigningBaseMode,
-} from "./signing-base.js";
-import {
-  verifyContentDigest,
-  ContentDigestError,
-} from "./content-digest.js";
-
-export class VerifyError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "VerifyError";
-  }
-}
-
-export type PublicKey = string | Uint8Array;
-
-export interface VerifyResult {
-  valid: boolean;
-  signature_valid: boolean;
-  content_digest_valid: boolean;
-  signing_base: string;
-  covered_components: string[];
-  parameters: Record<string, string | number>;
-  label: string;
-  errors: string[];
-}
-
-export interface VerifyRequestInput {
-  method: string;
-  authority: string;
-  path: string;
-  headers: Record<string, string>;
-  body: Uint8Array | Buffer | string;
-  publicKey: PublicKey;
-  scheme?: string;
-  requireContentDigest?: boolean;
-  requireAlgorithm?: string | null;
-  /**
-   * Signing-base mode. Default "algovoi-v0" preserves backward
-   * compatibility with the v0.1.0 internal fixture and the
-   * rfc9421_proxy_chain_v0 conformance set. Set to "rfc9421" to
-   * verify external RFC 9421-compliant fixtures (Envoys, Hippo,
-   * RFC 9421 §B test vectors).
-   */
-  mode?: SigningBaseMode;
-}
-
-function newResult(): VerifyResult {
-  return {
-    valid: false,
-    signature_valid: false,
-    content_digest_valid: false,
-    signing_base: "",
-    covered_components: [],
-    parameters: {},
-    label: "",
-    errors: [],
-  };
-}
-
-function fail(result: VerifyResult, msg: string): VerifyResult {
-  result.errors.push(msg);
-  result.valid = false;
-  return result;
-}
-
-function publicKeyBytes(pk: PublicKey): Uint8Array {
-  if (pk instanceof Uint8Array) {
-    if (pk.length !== 32) {
-      throw new VerifyError(
-        `Ed25519 public key must be 32 bytes, got ${pk.length}`,
-      );
-    }
-    return pk;
-  }
-  if (typeof pk === "string") {
-    const hex = pk.startsWith("0x") ? pk.slice(2) : pk;
-    if (!/^[0-9a-fA-F]+$/.test(hex)) {
-      throw new VerifyError("public key hex is invalid");
-    }
-    if (hex.length !== 64) {
-      throw new VerifyError(
-        `Ed25519 public key hex must decode to 32 bytes (64 hex chars), got ${hex.length}`,
-      );
-    }
-    const bytes = new Uint8Array(32);
-    for (let i = 0; i < 32; i++) {
-      bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-    }
-    return bytes;
-  }
-  throw new VerifyError("publicKey must be Uint8Array or hex string");
-}
-
-export async function verifySignature(
-  signingBase: string,
-  signatureBytes: Uint8Array,
-  publicKey: PublicKey,
-  algorithm: string = "ed25519",
-): Promise<boolean> {
-  if (algorithm.toLowerCase() !== "ed25519") {
-    throw new VerifyError(`v0.1.0 supports ed25519 only; got ${algorithm}`);
-  }
-  if (signatureBytes.length !== 64) {
-    throw new VerifyError(
-      `Ed25519 signature must be 64 bytes, got ${signatureBytes.length}`,
-    );
-  }
-  const pkBytes = publicKeyBytes(publicKey);
-  const messageBytes = new TextEncoder().encode(signingBase);
-  try {
-    return await ed25519.verifyAsync(signatureBytes, messageBytes, pkBytes);
-  } catch {
-    return false;
-  }
-}
-
-export async function verifyRequest(
-  input: VerifyRequestInput,
-): Promise<VerifyResult> {
-  const result = newResult();
-
-  const normHeaders: Record<string, string> = {};
-  for (const [k, v] of Object.entries(input.headers)) {
-    normHeaders[k.toLowerCase()] = v;
-  }
-
-  const siValue = normHeaders["signature-input"];
-  if (!siValue) return fail(result, "Signature-Input header missing");
-  const sValue = normHeaders["signature"];
-  if (!sValue) return fail(result, "Signature header missing");
-
-  let parsedSi;
-  try {
-    parsedSi = parseSignatureInput(siValue);
-  } catch (e) {
-    if (e instanceof SignatureInputParseError) {
-      return fail(result, `Signature-Input parse error: ${e.message}`);
-    }
-    throw e;
-  }
-  result.label = parsedSi.label;
-  result.covered_components = parsedSi.covered_components;
-  result.parameters = parsedSi.parameters;
-
-  let sigParsed;
-  try {
-    sigParsed = parseSignatureValue(sValue);
-  } catch (e) {
-    if (e instanceof SignatureInputParseError) {
-      return fail(result, `Signature parse error: ${e.message}`);
-    }
-    throw e;
-  }
-
-  if (
-    sigParsed.label &&
-    parsedSi.label &&
-    sigParsed.label !== parsedSi.label
-  ) {
-    return fail(
-      result,
-      `Signature label ${sigParsed.label} does not match Signature-Input label ${parsedSi.label}`,
-    );
-  }
-
-  const requireCd = input.requireContentDigest ?? true;
-  // null = no algorithm requirement (accept any); undefined = default to sha-256
-  const requireAlg: string | undefined =
-    input.requireAlgorithm === null
-      ? undefined
-      : (input.requireAlgorithm ?? "sha-256");
-
-  if (requireCd) {
-    const cdHeader = normHeaders["content-digest"];
-    if (!cdHeader)
-      return fail(result, "Content-Digest header required but missing");
-    try {
-      verifyContentDigest(input.body, cdHeader, requireAlg);
-      result.content_digest_valid = true;
-    } catch (e) {
-      if (e instanceof ContentDigestError) {
-        return fail(result, `Content-Digest verification failed: ${e.message}`);
-      }
-      throw e;
-    }
-  } else {
-    result.content_digest_valid = true;
-  }
-
-  const mode: SigningBaseMode = input.mode ?? "algovoi-v0";
-
-  let signingBase: string;
-  try {
-    signingBase = buildSigningBase({
-      coveredComponents: parsedSi.covered_components,
-      method: input.method,
-      authority: input.authority,
-      path: input.path,
-      scheme: input.scheme ?? "https",
-      headers: normHeaders,
-      parameters: parsedSi.parameters,
-      mode,
-      signatureParamsRaw:
-        mode === "rfc9421" ? parsedSi.params_block : undefined,
-    });
-  } catch (e) {
-    if (e instanceof SigningBaseError) {
-      return fail(result, `Signing-base build error: ${e.message}`);
-    }
-    throw e;
-  }
-  result.signing_base = signingBase;
-
-  const alg = parsedSi.parameters["alg"];
-  const algStr = typeof alg === "string" ? alg : "ed25519";
-
-  let sigOk: boolean;
-  try {
-    sigOk = await verifySignature(
-      signingBase,
-      sigParsed.signature,
-      input.publicKey,
-      algStr,
-    );
-  } catch (e) {
-    if (e instanceof VerifyError) {
-      return fail(result, `Signature verification setup error: ${e.message}`);
-    }
-    throw e;
-  }
-
-  if (!sigOk) {
-    return fail(result, "Ed25519 signature does not verify against signing base");
-  }
-  result.signature_valid = true;
-  result.valid = result.signature_valid && result.content_digest_valid;
-  return result;
-}
+/**
+ * RFC 9421 + RFC 9530 verification top-level.
+ *
+ * Mirror of the Python algovoi_rfc9421_verifier.verify module.
+ * Uses @noble/ed25519 for Ed25519 verification.
+ */
+
+import * as ed25519 from "@noble/ed25519";
+
+import {
+  parseSignatureInput,
+  parseSignatureValue,
+  SignatureInputParseError,
+} from "./parse.js";
+import {
+  buildSigningBase,
+  SigningBaseError,
+  type SigningBaseMode,
+} from "./signing-base.js";
+import {
+  verifyContentDigest,
+  ContentDigestError,
+} from "./content-digest.js";
+
+export class VerifyError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "VerifyError";
+  }
+}
+
+export type PublicKey = string | Uint8Array;
+
+export interface VerifyResult {
+  valid: boolean;
+  signature_valid: boolean;
+  content_digest_valid: boolean;
+  signing_base: string;
+  covered_components: string[];
+  parameters: Record<string, string | number>;
+  label: string;
+  errors: string[];
+}
+
+export interface VerifyRequestInput {
+  method: string;
+  authority: string;
+  path: string;
+  headers: Record<string, string>;
+  body: Uint8Array | Buffer | string;
+  publicKey: PublicKey;
+  scheme?: string;
+  requireContentDigest?: boolean;
+  requireAlgorithm?: string | null;
+  /**
+   * Signing-base mode. Default "algovoi-v0" preserves backward
+   * compatibility with the v0.1.0 internal fixture and the
+   * rfc9421_proxy_chain_v0 conformance set. Set to "rfc9421" to
+   * verify external RFC 9421-compliant fixtures (Envoys, Hippo,
+   * RFC 9421 §B test vectors).
+   */
+  mode?: SigningBaseMode;
+}
+
+function newResult(): VerifyResult {
+  return {
+    valid: false,
+    signature_valid: false,
+    content_digest_valid: false,
+    signing_base: "",
+    covered_components: [],
+    parameters: {},
+    label: "",
+    errors: [],
+  };
+}
+
+function fail(result: VerifyResult, msg: string): VerifyResult {
+  result.errors.push(msg);
+  result.valid = false;
+  return result;
+}
+
+function publicKeyBytes(pk: PublicKey): Uint8Array {
+  if (pk instanceof Uint8Array) {
+    if (pk.length !== 32) {
+      throw new VerifyError(
+        `Ed25519 public key must be 32 bytes, got ${pk.length}`,
+      );
+    }
+    return pk;
+  }
+  if (typeof pk === "string") {
+    const hex = pk.startsWith("0x") ? pk.slice(2) : pk;
+    if (!/^[0-9a-fA-F]+$/.test(hex)) {
+      throw new VerifyError("public key hex is invalid");
+    }
+    if (hex.length !== 64) {
+      throw new VerifyError(
+        `Ed25519 public key hex must decode to 32 bytes (64 hex chars), got ${hex.length}`,
+      );
+    }
+    const bytes = new Uint8Array(32);
+    for (let i = 0; i < 32; i++) {
+      bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+  }
+  throw new VerifyError("publicKey must be Uint8Array or hex string");
+}
+
+export async function verifySignature(
+  signingBase: string,
+  signatureBytes: Uint8Array,
+  publicKey: PublicKey,
+  algorithm: string = "ed25519",
+): Promise<boolean> {
+  if (algorithm.toLowerCase() !== "ed25519") {
+    throw new VerifyError(`v0.1.0 supports ed25519 only; got ${algorithm}`);
+  }
+  if (signatureBytes.length !== 64) {
+    throw new VerifyError(
+      `Ed25519 signature must be 64 bytes, got ${signatureBytes.length}`,
+    );
+  }
+  const pkBytes = publicKeyBytes(publicKey);
+  const messageBytes = new TextEncoder().encode(signingBase);
+  try {
+    return await ed25519.verifyAsync(signatureBytes, messageBytes, pkBytes);
+  } catch {
+    return false;
+  }
+}
+
+export async function verifyRequest(
+  input: VerifyRequestInput,
+): Promise<VerifyResult> {
+  const result = newResult();
+
+  const normHeaders: Record<string, string> = {};
+  for (const [k, v] of Object.entries(input.headers)) {
+    normHeaders[k.toLowerCase()] = v;
+  }
+
+  const siValue = normHeaders["signature-input"];
+  if (!siValue) return fail(result, "Signature-Input header missing");
+  const sValue = normHeaders["signature"];
+  if (!sValue) return fail(result, "Signature header missing");
+
+  let parsedSi;
+  try {
+    parsedSi = parseSignatureInput(siValue);
+  } catch (e) {
+    if (e instanceof SignatureInputParseError) {
+      return fail(result, `Signature-Input parse error: ${e.message}`);
+    }
+    throw e;
+  }
+  result.label = parsedSi.label;
+  result.covered_components = parsedSi.covered_components;
+  result.parameters = parsedSi.parameters;
+
+  let sigParsed;
+  try {
+    sigParsed = parseSignatureValue(sValue);
+  } catch (e) {
+    if (e instanceof SignatureInputParseError) {
+      return fail(result, `Signature parse error: ${e.message}`);
+    }
+    throw e;
+  }
+
+  if (
+    sigParsed.label &&
+    parsedSi.label &&
+    sigParsed.label !== parsedSi.label
+  ) {
+    return fail(
+      result,
+      `Signature label ${sigParsed.label} does not match Signature-Input label ${parsedSi.label}`,
+    );
+  }
+
+  const requireCd = input.requireContentDigest ?? true;
+  // string = enforce that specific algorithm; null or undefined = accept any
+  // supported algorithm present in the Content-Digest header (SHA-256 or
+  // SHA-512 in this v0.2.x). Default is permissive.
+  const requireAlg: string | undefined =
+    input.requireAlgorithm == null ? undefined : input.requireAlgorithm;
+
+  if (requireCd) {
+    const cdHeader = normHeaders["content-digest"];
+    if (!cdHeader)
+      return fail(result, "Content-Digest header required but missing");
+    try {
+      verifyContentDigest(input.body, cdHeader, requireAlg);
+      result.content_digest_valid = true;
+    } catch (e) {
+      if (e instanceof ContentDigestError) {
+        return fail(result, `Content-Digest verification failed: ${e.message}`);
+      }
+      throw e;
+    }
+  } else {
+    result.content_digest_valid = true;
+  }
+
+  const mode: SigningBaseMode = input.mode ?? "algovoi-v0";
+
+  let signingBase: string;
+  try {
+    signingBase = buildSigningBase({
+      coveredComponents: parsedSi.covered_components,
+      method: input.method,
+      authority: input.authority,
+      path: input.path,
+      scheme: input.scheme ?? "https",
+      headers: normHeaders,
+      parameters: parsedSi.parameters,
+      mode,
+      signatureParamsRaw:
+        mode === "rfc9421" ? parsedSi.params_block : undefined,
+    });
+  } catch (e) {
+    if (e instanceof SigningBaseError) {
+      return fail(result, `Signing-base build error: ${e.message}`);
+    }
+    throw e;
+  }
+  result.signing_base = signingBase;
+
+  const alg = parsedSi.parameters["alg"];
+  const algStr = typeof alg === "string" ? alg : "ed25519";
+
+  let sigOk: boolean;
+  try {
+    sigOk = await verifySignature(
+      signingBase,
+      sigParsed.signature,
+      input.publicKey,
+      algStr,
+    );
+  } catch (e) {
+    if (e instanceof VerifyError) {
+      return fail(result, `Signature verification setup error: ${e.message}`);
+    }
+    throw e;
+  }
+
+  if (!sigOk) {
+    return fail(result, "Ed25519 signature does not verify against signing base");
+  }
+  result.signature_valid = true;
+  result.valid = result.signature_valid && result.content_digest_valid;
+  return result;
+}