@fedify/fedify 2.4.0-pr.936.41 → 2.4.1

package/dist/sig/http.test.mjs

@@ -1,18 +1,47 @@
 import { Temporal } from "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as esm_default } from "../esm-yYQfPhIY.mjs";
-import { t as assertEquals } from "../assert_equals-BV7oLMxm.mjs";
-import { r as assertExists, t as assertStringIncludes } from "../std__assert-B2NnY9bq.mjs";
-import { n as assertGreaterOrEqual, r as assertFalse, t as assertRejects } from "../assert_rejects-EgstcQy5.mjs";
-import { t as assertThrows } from "../assert_throws-NiFfqbnH.mjs";
-import { t as assert } from "../assert-CJ1KXcvv.mjs";
-import { t as exportJwk } from "../key-DfPsX8hv.mjs";
-import { a as parseRfc9421Signature, c as timingSafeEqual, i as formatRfc9421SignatureParameters, l as verifyRequest, n as doubleKnock, o as parseRfc9421SignatureInput, r as formatRfc9421Signature, s as signRequest, t as createRfc9421SignatureBase, u as verifyRequestDetailed } from "../http-CPVMUgsW.mjs";
-import { i as rsaPrivateKey2, l as rsaPublicKey5, o as rsaPublicKey1, s as rsaPublicKey2 } from "../keys-Dbyd7bhl.mjs";
+import { t as esm_default } from "../esm-BHXXx4Wx.mjs";
+import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
+import { t as AssertionError } from "../assertion_error-B-cx0fFA.mjs";
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import { t as assertExists } from "../assert_exists-cffSpJ7X.mjs";
+import { t as assertFalse } from "../assert_false-CPdRnc3E.mjs";
+import { t as assertGreaterOrEqual } from "../assert_greater_or_equal-BlafOF4-.mjs";
+import { t as assertThrows } from "../assert_throws-BYITOvPO.mjs";
+import "../std__assert-DvMDRPes.mjs";
+import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
+import { t as assert } from "../assert-D1Eafmd_.mjs";
+import { n as exportJwk } from "../key-hMoNKe7p.mjs";
+import { a as listRequestSignatures, c as selectRequestSignature, f as verifyRequest, i as formatRfc9421SignatureParameters, l as signRequest, n as doubleKnock, o as parseRfc9421Signature, p as verifyRequestDetailed, r as formatRfc9421Signature, s as parseRfc9421SignatureInput, t as createRfc9421SignatureBase, u as timingSafeEqual } from "../http-CNzz4a_O.mjs";
+import { a as rsaPrivateKey3, i as rsaPrivateKey2, l as rsaPublicKey5, n as ed25519PrivateKey, o as rsaPublicKey1, r as ed25519PublicKey, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
+import { t as KvKeyCache } from "../keycache-D-MNltOk.mjs";
+import { FetchError, UrlError, exportSpki, getDocumentLoader } from "@fedify/vocab-runtime";
 import { createTestMeterProvider, createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
-import { FetchError, exportSpki } from "@fedify/vocab-runtime";
 import { encodeBase64 } from "byte-encodings/base64";
+//#region ../../node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assert_string_includes.js
+/**
+* Make an assertion that actual includes expected. If not
+* then throw.
+*
+* @example Usage
+* ```ts no-eval
+* import { assertStringIncludes } from "@std/assert/assert-string-includes";
+*
+* assertStringIncludes("Hello", "ello"); // Doesn't throw
+* assertStringIncludes("Hello", "world"); // Throws
+* ```
+*
+* @param actual The actual string to check for inclusion.
+* @param expected The expected string to check for inclusion.
+* @param msg The optional message to display if the assertion fails.
+*/ function assertStringIncludes(actual, expected, msg) {
+	if (!actual.includes(expected)) {
+		msg = `Expected actual: "${actual}" to contain: "${expected}"${msg ? `: ${msg}` : "."}`;
+		throw new AssertionError(msg);
+	}
+}
+//#endregion
 //#region src/sig/http.test.ts
 test("signRequest() [draft-cavage]", async () => {
 	assertEquals(await verifyRequest(await signRequest(new Request("https://example.com/", {
@@ -231,7 +260,7 @@ test("verifyRequestDetailed() records failure details on span", async () => {
 	assertEquals(span.attributes["http_signatures.key_fetch_status"], 410);
 });
 test("verifyRequestDetailed() records verification duration metric", async (t) => {
-	const buildSignedRequest = () => signRequest(new Request("https://example.com/inbox", {
+	const buildSignedRequest = (spec) => signRequest(new Request("https://example.com/inbox", {
 		method: "POST",
 		headers: {
 			"Content-Type": "application/activity+json",
@@ -242,7 +271,7 @@ test("verifyRequestDetailed() records verification duration metric", async (t) =
 			type: "Create",
 			actor: "https://example.com/key2"
 		})
-	}), rsaPrivateKey2, new URL("https://example.com/key2"));
+	}), rsaPrivateKey2, new URL("https://example.com/key2"), { spec });
 	await t.step("verified path emits one measurement", async () => {
 		const [meterProvider, recorder] = createTestMeterProvider();
 		assert((await verifyRequestDetailed(await buildSignedRequest(), {
@@ -345,23 +374,26 @@ test("verifyRequestDetailed() records verification duration metric", async (t) =
 		assertEquals(recorder.getMeasurements("activitypub.signature.verification.duration").length, 1);
 	});
 	await t.step("cached-key retry emits one measurement, not two", async () => {
-		const [meterProvider, recorder] = createTestMeterProvider();
-		const cache = { "https://example.com/key2": rsaPublicKey1 };
-		assertExists(await verifyRequest(await buildSignedRequest(), {
-			contextLoader: mockDocumentLoader,
-			documentLoader: mockDocumentLoader,
-			meterProvider,
-			keyCache: {
-				get(keyId) {
-					return Promise.resolve(cache[keyId.href]);
-				},
-				set(keyId, k) {
-					cache[keyId.href] = k;
-					return Promise.resolve();
+		for (const spec of ["draft-cavage-http-signatures-12", "rfc9421"]) {
+			const [meterProvider, recorder] = createTestMeterProvider();
+			const cache = { "https://example.com/key2": rsaPublicKey1 };
+			assertExists(await verifyRequest(await buildSignedRequest(spec), {
+				contextLoader: mockDocumentLoader,
+				documentLoader: mockDocumentLoader,
+				meterProvider,
+				keyCache: {
+					get(keyId) {
+						return Promise.resolve(cache[keyId.href]);
+					},
+					set(keyId, k) {
+						cache[keyId.href] = k;
+						return Promise.resolve();
+					}
 				}
-			}
-		}));
-		assertEquals(recorder.getMeasurements("activitypub.signature.verification.duration").length, 1);
+			}), spec);
+			assertEquals(recorder.getMeasurements("activitypub.signature.verification.duration").length, 1, spec);
+			assertEquals(recorder.getMeasurements("activitypub.signature.key_fetch.duration").length, 2, spec);
+		}
 	});
 	await t.step("key fetch records result=fetched on a cold cache", async () => {
 		const [meterProvider, recorder] = createTestMeterProvider();
@@ -440,6 +472,63 @@ test("verifyRequestDetailed() records verification duration metric", async (t) =
 		assertFalse("http_signatures.algorithm" in measurements[0].attributes);
 	});
 });
+test("verifyRequestDetailed() preserves cached key fetch errors", async (t) => {
+	const keyId = new URL("https://unreachable.example/actors/alice#main-key");
+	const timeout = new FetchError("https://unreachable.example/resolved-key", "Timed out after 100 ms");
+	timeout.cause = new DOMException("The operation timed out", "TimeoutError");
+	const failures = [
+		timeout,
+		new UrlError("DNS lookup failed", {
+			reason: "dns",
+			cause: /* @__PURE__ */ new TypeError("No usable IP addresses")
+		}),
+		new UrlError("Private IP address is not allowed")
+	];
+	for (const failure of failures) await t.step(failure.message, async () => {
+		const kv = new MemoryKvStore();
+		let fetches = 0;
+		const documentLoader = (url) => {
+			if (url === keyId.href) {
+				fetches++;
+				throw failure;
+			}
+			return mockDocumentLoader(url);
+		};
+		for (const cached of [false, true]) {
+			const result = await verifyRequestDetailed(await signRequest(new Request("https://example.com/inbox", {
+				method: "POST",
+				body: "Test activity"
+			}), rsaPrivateKey2, keyId), {
+				documentLoader,
+				contextLoader: mockDocumentLoader,
+				keyCache: new KvKeyCache(kv, ["pk"])
+			});
+			assertFalse(result.verified);
+			assert(result.reason.type === "keyFetchError");
+			assert("error" in result.reason.result);
+			const error = result.reason.result.error;
+			assertEquals(error.name, failure.name);
+			assertEquals(error.message, failure.message);
+			if (failure instanceof FetchError) {
+				assert(error instanceof FetchError);
+				assertEquals(error.url.href, failure.url.href);
+				assertEquals(error.response, void 0);
+				assert(error.cause instanceof DOMException);
+				assertEquals(error.cause.name, "TimeoutError");
+				assertEquals(error.cause.message, "The operation timed out");
+			} else {
+				assert(error instanceof UrlError);
+				assertEquals(error.reason, failure.reason);
+				if (failure.cause instanceof Error) {
+					assert(error.cause instanceof Error);
+					assertEquals(error.cause.name, failure.cause.name);
+					assertEquals(error.cause.message, failure.cause.message);
+				} else assertEquals(error.cause, void 0);
+			}
+			assertEquals(fetches, 1, cached ? "Cached failure was refetched" : "");
+		}
+	});
+});
 test("signRequest() and verifyRequest() [rfc9421] implementation", async () => {
 	const currentTimestamp = 1709626184;
 	const currentTime = Temporal.Instant.from("2024-03-05T08:09:44Z");
@@ -628,6 +717,430 @@ test("verifyRequest() [rfc9421] successful GET verification", async () => {
 		currentTime: Temporal.Instant.from(`${(/* @__PURE__ */ new Date(currentTimestamp * 1e3)).toISOString()}`)
 	}), rsaPublicKey2, "Valid signature should verify to the correct public key");
 });
+for (const failure of [
+	"missing key",
+	"invalid signature",
+	"digest mismatch",
+	"empty body",
+	"cached key"
+]) test(`verifyRequest() [rfc9421] multiple POST signatures: ${failure}`, async () => {
+	const body = failure === "empty body" ? "" : "Hello, world!";
+	const currentTime = Temporal.Instant.from("2024-03-05T08:09:44Z");
+	const signed = await signRequest(new Request("https://example.com/inbox", {
+		method: "POST",
+		body
+	}), rsaPrivateKey2, new URL("https://example.com/key2"), {
+		spec: "rfc9421",
+		currentTime
+	});
+	const input = signed.headers.get("Signature-Input");
+	const signature = signed.headers.get("Signature");
+	const firstInput = failure === "missing key" ? input.replace("https://example.com/key2", "https://example.com/missing-key") : input;
+	signed.headers.set("Signature-Input", `${firstInput}, ${input.replace(/^sig1=/, "sig2=")}`);
+	signed.headers.set("Signature", `sig1=:AAAAAA==:, ${signature.replace(/^sig1=/, "sig2=")}`);
+	const request = failure === "digest mismatch" ? new Request(signed, { body: "Tampered body" }) : signed;
+	const loaded = [];
+	assertEquals(await verifyRequest(request, {
+		keyCache: failure === "cached key" ? {
+			get: () => Promise.resolve(rsaPublicKey1),
+			set: async () => {}
+		} : void 0,
+		spec: "rfc9421",
+		currentTime,
+		contextLoader: mockDocumentLoader,
+		documentLoader: (url, options) => {
+			loaded.push(url);
+			return mockDocumentLoader(url, options);
+		}
+	}), failure === "digest mismatch" ? null : rsaPublicKey2);
+	assertEquals(loaded, failure === "digest mismatch" ? [] : failure === "missing key" ? ["https://example.com/missing-key", "https://example.com/key2"] : ["https://example.com/key2"]);
+	assertFalse(request.bodyUsed);
+	assertEquals(await request.text(), failure === "digest mismatch" ? "Tampered body" : body);
+});
+async function signRfc9421Many(signatures, currentTime) {
+	let request = new Request("https://example.com/inbox", {
+		method: "POST",
+		body: "Hello, world!"
+	});
+	let i = 0;
+	for (const signature of signatures) {
+		const { label, keyId, privateKey } = typeof signature === "string" ? { keyId: signature } : signature;
+		i++;
+		request = await signRequest(request, privateKey ?? rsaPrivateKey2, new URL(keyId), {
+			spec: "rfc9421",
+			currentTime,
+			rfc9421: { label: label ?? `sig${i}` }
+		});
+	}
+	return request;
+}
+function splitRfc9421Header(header) {
+	return Object.fromEntries(header.split(/,\s*/).map((member) => [member.slice(0, member.indexOf("=")), member]));
+}
+function createCountingKeyLoader() {
+	const loaded = [];
+	const loader = (url, options) => {
+		loaded.push(url);
+		if (url === "https://example.com/key2") return mockDocumentLoader(url, options);
+		return Promise.reject(new FetchError(url, `Not found: ${url}`));
+	};
+	return Object.assign(loader, { loaded });
+}
+test("verifyRequestDetailed() [rfc9421] caps the number of signatures", async (t) => {
+	const currentTime = Temporal.Instant.from("2024-03-05T08:09:44Z");
+	const missing = (n) => `https://example.com/missing-${n}`;
+	const valid = "https://example.com/key2";
+	await t.step("fetches only the keys of the first signatures", async () => {
+		const request = await signRfc9421Many([
+			1,
+			2,
+			3,
+			4,
+			5
+		].map(missing), currentTime);
+		for (const [maxSignatures, count] of [
+			[void 0, 3],
+			[1, 1],
+			[5, 5],
+			[Infinity, 5]
+		]) {
+			const documentLoader = createCountingKeyLoader();
+			const result = await verifyRequestDetailed(request, {
+				documentLoader,
+				contextLoader: mockDocumentLoader,
+				currentTime,
+				maxSignatures
+			});
+			assertFalse(result.verified);
+			assertEquals(result.reason.type, "keyFetchError");
+			assertEquals("keyId" in result.reason ? result.reason.keyId?.href : void 0, missing(count));
+			assertEquals(documentLoader.loaded, [
+				1,
+				2,
+				3,
+				4,
+				5
+			].slice(0, count).map(missing));
+		}
+	});
+	await t.step("accepts a valid signature within the cap", async () => {
+		const documentLoader = createCountingKeyLoader();
+		const result = await verifyRequestDetailed(await signRfc9421Many([
+			missing(1),
+			missing(2),
+			valid,
+			missing(4)
+		], currentTime), {
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			currentTime
+		});
+		assert(result.verified);
+		assertEquals(result.key, rsaPublicKey2);
+		assertEquals(result.signatureLabel, "sig3");
+		assertEquals(documentLoader.loaded, [
+			missing(1),
+			missing(2),
+			valid
+		]);
+	});
+	await t.step("ignores a valid signature beyond the cap", async () => {
+		const request = await signRfc9421Many([
+			missing(1),
+			missing(2),
+			missing(3),
+			valid
+		], currentTime);
+		const documentLoader = createCountingKeyLoader();
+		const result = await verifyRequestDetailed(request, {
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			currentTime
+		});
+		assertFalse(result.verified);
+		assertEquals(result.reason.type, "keyFetchError");
+		assertEquals("keyId" in result.reason ? result.reason.keyId?.href : void 0, missing(3));
+		assertEquals(documentLoader.loaded, [
+			1,
+			2,
+			3
+		].map(missing));
+		assertEquals(await verifyRequest(request, {
+			documentLoader: createCountingKeyLoader(),
+			contextLoader: mockDocumentLoader,
+			currentTime,
+			maxSignatures: 4
+		}), rsaPublicKey2);
+	});
+	await t.step("tries signatures in the header order", async () => {
+		const request = await signRfc9421Many([
+			{
+				label: "z",
+				keyId: missing(1)
+			},
+			{
+				label: "a",
+				keyId: valid
+			},
+			{
+				label: "m",
+				keyId: missing(3)
+			}
+		], currentTime);
+		const documentLoader = createCountingKeyLoader();
+		assertEquals(await verifyRequest(request, {
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			currentTime,
+			maxSignatures: 1
+		}), null);
+		assertEquals(documentLoader.loaded, [missing(1)]);
+	});
+	await t.step("counts signatures that fail before their keys are fetched", async () => {
+		const outdated = await signRfc9421Many([{
+			label: "old",
+			keyId: missing(1)
+		}], currentTime.subtract({ hours: 2 }));
+		const signed = await signRfc9421Many([
+			{
+				label: "nobytes1",
+				keyId: missing(2)
+			},
+			{
+				label: "nobytes2",
+				keyId: missing(3)
+			},
+			{
+				label: "valid",
+				keyId: valid
+			}
+		], currentTime);
+		const inputs = {
+			...splitRfc9421Header(outdated.headers.get("Signature-Input")),
+			...splitRfc9421Header(signed.headers.get("Signature-Input"))
+		};
+		const signatures = {
+			...splitRfc9421Header(outdated.headers.get("Signature")),
+			...splitRfc9421Header(signed.headers.get("Signature"))
+		};
+		const build = (labels) => {
+			const headers = new Headers(signed.headers);
+			headers.set("Signature-Input", [`dropped=("@method");keyid="${missing(0)}"`, ...labels.map((label) => inputs[label])].join(", "));
+			headers.set("Signature", labels.filter((label) => !label.startsWith("nobytes")).map((label) => signatures[label]).join(", "));
+			return new Request(signed.url, {
+				method: "POST",
+				headers,
+				body: "Hello, world!"
+			});
+		};
+		let documentLoader = createCountingKeyLoader();
+		let result = await verifyRequestDetailed(build([
+			"old",
+			"nobytes1",
+			"valid"
+		]), {
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			currentTime
+		});
+		assert(result.verified);
+		assertEquals(result.signatureLabel, "valid");
+		assertEquals(documentLoader.loaded, [valid]);
+		documentLoader = createCountingKeyLoader();
+		result = await verifyRequestDetailed(build([
+			"old",
+			"nobytes1",
+			"nobytes2",
+			"valid"
+		]), {
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			currentTime
+		});
+		assertFalse(result.verified);
+		assertEquals(documentLoader.loaded, []);
+	});
+	await t.step("rejects an invalid maxSignatures", async () => {
+		const unsigned = new Request("https://example.com/inbox");
+		for (const maxSignatures of [
+			0,
+			-1,
+			1.5,
+			NaN,
+			2 ** 53,
+			-Infinity
+		]) {
+			await assertRejects(() => verifyRequestDetailed(unsigned, { maxSignatures }), RangeError);
+			await assertRejects(() => verifyRequest(unsigned, { maxSignatures }), RangeError);
+		}
+		await assertRejects(() => verifyRequestDetailed(unsigned, { maxSignatures: null }), RangeError);
+	});
+});
+test("verifyRequestDetailed() [rfc9421] looks up each key once per request", async (t) => {
+	const currentTime = Temporal.Instant.from("2024-03-05T08:09:44Z");
+	const missing = (n) => `https://example.com/missing-${n}`;
+	const valid = "https://example.com/key2";
+	const forged = {
+		keyId: valid,
+		privateKey: rsaPrivateKey3
+	};
+	await t.step("signatures naming the same key", async () => {
+		const request = await signRfc9421Many([
+			forged,
+			forged,
+			valid
+		], currentTime);
+		for (const keyCache of [void 0, new KvKeyCache(new MemoryKvStore(), ["pk"])]) {
+			const documentLoader = createCountingKeyLoader();
+			const result = await verifyRequestDetailed(request, {
+				documentLoader,
+				contextLoader: mockDocumentLoader,
+				currentTime,
+				keyCache
+			});
+			assert(result.verified);
+			assertEquals(result.signatureLabel, "sig3");
+			assertEquals(documentLoader.loaded, [valid]);
+		}
+	});
+	await t.step("signatures naming the same missing key", async () => {
+		const documentLoader = createCountingKeyLoader();
+		const result = await verifyRequestDetailed(await signRfc9421Many([
+			missing(1),
+			missing(1),
+			missing(1)
+		], currentTime), {
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			currentTime
+		});
+		assertFalse(result.verified);
+		assertEquals(result.reason.type, "keyFetchError");
+		assertEquals(documentLoader.loaded, [missing(1)]);
+	});
+	await t.step("separate requests", async () => {
+		const request = await signRfc9421Many([valid], currentTime);
+		const documentLoader = createCountingKeyLoader();
+		const options = {
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			currentTime
+		};
+		assertEquals(await verifyRequest(request, options), rsaPublicKey2);
+		assertEquals(await verifyRequest(request, options), rsaPublicKey2);
+		assertEquals(documentLoader.loaded, [valid, valid]);
+	});
+	const createStaleKeyCache = () => {
+		const gets = [];
+		return {
+			keyCache: {
+				get(keyId) {
+					gets.push(keyId.href);
+					return Promise.resolve(keyId.href === valid ? rsaPublicKey1 : keyId.href === missing(1) ? null : void 0);
+				},
+				set: () => Promise.resolve(),
+				getFetchError: (keyId) => Promise.resolve(keyId.href === missing(1) ? { error: new FetchError(keyId, "Cached failure") } : void 0),
+				setFetchError: () => Promise.resolve()
+			},
+			gets
+		};
+	};
+	await t.step("refreshes a stale cached key once, only for its signature", async () => {
+		const { keyCache, gets } = createStaleKeyCache();
+		const documentLoader = createCountingKeyLoader();
+		const result = await verifyRequestDetailed(await signRfc9421Many([
+			missing(1),
+			missing(2),
+			forged,
+			valid
+		], currentTime), {
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			currentTime,
+			keyCache,
+			maxSignatures: 4
+		});
+		assert(result.verified);
+		assertEquals(result.key, rsaPublicKey2);
+		assertEquals(result.signatureLabel, "sig4");
+		assertEquals(documentLoader.loaded, [missing(2), valid]);
+		assertEquals(gets, [
+			missing(1),
+			missing(2),
+			valid
+		]);
+	});
+	await t.step("refreshes each stale cached key at most once", async () => {
+		const stale = (n) => `https://example.com/stale-${n}`;
+		const gets = [];
+		const keyCache = {
+			get(keyId) {
+				gets.push(keyId.href);
+				return Promise.resolve(rsaPublicKey1);
+			},
+			set: () => Promise.resolve()
+		};
+		const documentLoader = createCountingKeyLoader();
+		const result = await verifyRequestDetailed(await signRfc9421Many([
+			stale(1),
+			stale(2),
+			stale(1),
+			stale(4)
+		], currentTime), {
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			currentTime,
+			keyCache
+		});
+		assertFalse(result.verified);
+		assertEquals(result.reason.type, "keyFetchError");
+		assertEquals("keyId" in result.reason ? result.reason.keyId?.href : void 0, stale(1));
+		assertEquals(documentLoader.loaded, [stale(1), stale(2)]);
+		assertEquals(gets, [stale(1), stale(2)]);
+	});
+	await t.step("does not refresh a cached key for other failures", async () => {
+		const [input] = Object.values(splitRfc9421Header((await signRfc9421Many([valid], currentTime)).headers.get("Signature-Input")));
+		const withAlg = (alg) => /;alg="[^"]*"/.test(input) ? input.replace(/;alg="[^"]*"/, `;alg="${alg}"`) : `${input};alg="${alg}"`;
+		for (const signatureInput of [withAlg("unknown"), input.replace(/^sig1=\([^)]*\)/, "sig1=(\"@unsupported\")")]) {
+			const request = await signRfc9421Many([valid], currentTime);
+			request.headers.set("Signature-Input", signatureInput);
+			const { keyCache } = createStaleKeyCache();
+			const documentLoader = createCountingKeyLoader();
+			assertEquals(await verifyRequest(request, {
+				documentLoader,
+				contextLoader: mockDocumentLoader,
+				currentTime,
+				keyCache
+			}), null, signatureInput);
+			assertEquals(documentLoader.loaded, [], signatureInput);
+		}
+	});
+	await t.step("refreshes a cached key of another algorithm family", async () => {
+		const keyId = ed25519PublicKey.id.href;
+		const request = await signRfc9421Many([keyId], currentTime);
+		const input = request.headers.get("Signature-Input");
+		request.headers.set("Signature-Input", /;alg="[^"]*"/.test(input) ? input.replace(/;alg="[^"]*"/, ";alg=\"ed25519\"") : `${input};alg="ed25519"`);
+		const { sig1 } = parseRfc9421SignatureInput(request.headers.get("Signature-Input"));
+		const signature = await crypto.subtle.sign("Ed25519", ed25519PrivateKey, new TextEncoder().encode(createRfc9421SignatureBase(request, sig1.components, sig1.parameters)));
+		request.headers.set("Signature", `sig1=:${encodeBase64(new Uint8Array(signature))}:`);
+		const loaded = [];
+		const result = await verifyRequestDetailed(request, {
+			documentLoader: (url, options) => {
+				loaded.push(url);
+				return mockDocumentLoader(url, options);
+			},
+			contextLoader: mockDocumentLoader,
+			currentTime,
+			keyCache: {
+				get: (id) => Promise.resolve(id.href === keyId ? rsaPublicKey1 : void 0),
+				set: () => Promise.resolve()
+			}
+		});
+		assert(result.verified);
+		assertEquals(result.key.id?.href, keyId);
+		assertEquals(loaded.length, 1);
+	});
+});
 test("verifyRequest() [rfc9421] manual POST verification", async () => {
 	const currentTimestamp = 1709626184;
 	const currentTime = Temporal.Instant.from("2024-03-05T08:09:44Z");
@@ -737,7 +1250,7 @@ test("verifyRequest() [rfc9421] error cases and edge cases", async () => {
 		contextLoader: mockDocumentLoader,
 		documentLoader: mockDocumentLoader,
 		spec: "rfc9421",
-		currentTime: Temporal.Instant.from(`${(/* @__PURE__ */ new Date((currentTimestamp + 2592e3) * 1e3)).toISOString()}`),
+		currentTime: Temporal.Instant.from(`${(/* @__PURE__ */ new Date(1712218184 * 1e3)).toISOString()}`),
 		timeWindow: { hours: 1 }
 	}), null, "Should fail verification when signature timestamp is too old");
 	assertEquals(await verifyRequest(new Request("https://example.com/api/resource", {
@@ -769,7 +1282,7 @@ test("verifyRequest() [rfc9421] error cases and edge cases", async () => {
 		contextLoader: mockDocumentLoader,
 		documentLoader: mockDocumentLoader,
 		spec: "rfc9421",
-		currentTime: Temporal.Instant.from(`${(/* @__PURE__ */ new Date((currentTimestamp + 31536e3) * 1e3)).toISOString()}`),
+		currentTime: Temporal.Instant.from(`${(/* @__PURE__ */ new Date(1741162184 * 1e3)).toISOString()}`),
 		timeWindow: false
 	}), rsaPublicKey2, "Should verify signature when time checking is disabled");
 	const freshSignedPostRequest = await signRequest(new Request("https://example.com/api/resource", {
@@ -1001,6 +1514,7 @@ test("doubleKnock() function with redirect handling", async () => {
 	esm_default.spyGlobal();
 	const requestedUrls = [];
 	const responseCodes = [];
+	const validatedRedirects = [];
 	esm_default.post("https://example.com/redirect-endpoint", (cl) => {
 		requestedUrls.push(cl.url);
 		responseCodes.push(302);
@@ -1018,11 +1532,41 @@ test("doubleKnock() function with redirect handling", async () => {
 	}), {
 		keyId: rsaPublicKey2.id,
 		privateKey: rsaPrivateKey2
-	})).status, 202, "Final response status should be 202 Accepted");
+	}, { validateRedirect(url) {
+		validatedRedirects.push(url);
+	} })).status, 202, "Final response status should be 202 Accepted");
 	assertEquals(requestedUrls.length, 2, "Two URLs should have been requested");
 	assertEquals(requestedUrls[0], "https://example.com/redirect-endpoint", "First request should be to redirect-endpoint");
 	assertEquals(requestedUrls[1], "https://example.com/final-endpoint", "Second request should be to final-endpoint");
 	assertEquals(responseCodes, [302, 202], "Response status codes should match expected sequence");
+	assertEquals(validatedRedirects, ["https://example.com/final-endpoint"]);
+	esm_default.hardReset();
+});
+test("doubleKnock() validates redirects after signature fallback", async () => {
+	esm_default.spyGlobal();
+	let requestCount = 0;
+	let privateRequestCount = 0;
+	esm_default.post("https://example.com/redirect-after-fallback", (cl) => {
+		requestCount++;
+		if (cl.request.headers.has("Signature-Input")) return new Response("Unauthorized", { status: 401 });
+		return Response.redirect("http://localhost/private", 302);
+	});
+	esm_default.post("http://localhost/private", () => {
+		privateRequestCount++;
+		return new Response("", { status: 202 });
+	});
+	const request = new Request("https://example.com/redirect-after-fallback", {
+		method: "POST",
+		body: "Test message"
+	});
+	await assertRejects(() => doubleKnock(request, {
+		keyId: rsaPublicKey2.id,
+		privateKey: rsaPrivateKey2
+	}, { validateRedirect(url) {
+		throw new Error(`Disallowed redirect: ${url}`);
+	} }), Error, "Disallowed redirect: http://localhost/private");
+	assertEquals(requestCount, 2);
+	assertEquals(privateRequestCount, 0);
 	esm_default.hardReset();
 });
 test("doubleKnock() function with both specs rejected", async () => {
@@ -1813,6 +2357,37 @@ test("doubleKnock(): Accept-Signature challenge retry succeeds", async () => {
 	assertEquals(requestCount, 2);
 	esm_default.hardReset();
 });
+test("doubleKnock(): validates redirects after Accept-Signature challenge retry", async () => {
+	esm_default.spyGlobal();
+	let requestCount = 0;
+	let privateRequestCount = 0;
+	esm_default.post("https://example.com/inbox-challenge-redirect", () => {
+		requestCount++;
+		if (requestCount === 1) return new Response("Not Authorized", {
+			status: 401,
+			headers: { "Accept-Signature": "sig1=(\"@method\" \"@target-uri\" \"@authority\" \"content-digest\");created;nonce=\"challenge-nonce-redirect\"" }
+		});
+		return Response.redirect("http://localhost/private", 302);
+	});
+	esm_default.post("http://localhost/private", () => {
+		privateRequestCount++;
+		return new Response("", { status: 202 });
+	});
+	const request = new Request("https://example.com/inbox-challenge-redirect", {
+		method: "POST",
+		body: "Test message",
+		headers: { "Content-Type": "text/plain" }
+	});
+	await assertRejects(() => doubleKnock(request, {
+		keyId: rsaPublicKey2.id,
+		privateKey: rsaPrivateKey2
+	}, { validateRedirect(url) {
+		throw new Error(`Disallowed redirect: ${url}`);
+	} }), Error, "Disallowed redirect: http://localhost/private");
+	assertEquals(requestCount, 2);
+	assertEquals(privateRequestCount, 0);
+	esm_default.hardReset();
+});
 test("doubleKnock(): unfulfillable Accept-Signature falls to legacy fallback", async () => {
 	esm_default.spyGlobal();
 	let requestCount = 0;
@@ -2009,5 +2584,158 @@ test("doubleKnock(): Accept-Signature with multiple compatible entries fulfills
 	assertEquals(requestCount, 2);
 	esm_default.hardReset();
 });
+test("listRequestSignatures()", async (t) => {
+	const request = () => new Request("https://example.com/inbox", {
+		method: "POST",
+		body: "Test message"
+	});
+	await t.step("draft-cavage", async () => {
+		const signed = await signRequest(request(), rsaPrivateKey2, rsaPublicKey2.id);
+		const signatures = listRequestSignatures(signed);
+		assertEquals(signatures.map((s) => [s.keyId.href, s.label]), [[rsaPublicKey2.id.href, null]]);
+		const components = signatures[0].components;
+		assertEquals(components.map((c) => c.value), signed.headers.get("Signature").match(/headers="([^"]*)"/)[1].split(" "));
+		assert(components.every((c) => Object.keys(c.params).length < 1));
+	});
+	await t.step("RFC 9421", async () => {
+		const signatures = listRequestSignatures(await signRequest(request(), rsaPrivateKey2, rsaPublicKey2.id, {
+			spec: "rfc9421",
+			rfc9421: { label: "a" }
+		}));
+		assertEquals(signatures.map((s) => [s.keyId.href, s.label]), [[rsaPublicKey2.id.href, "a"]]);
+		assertEquals(signatures[0].components.map((c) => c.value), [
+			"@method",
+			"@target-uri",
+			"@authority",
+			"host",
+			"date",
+			"content-digest"
+		]);
+	});
+	await t.step("RFC 9421 beyond the limit", async () => {
+		const currentTime = Temporal.Instant.from("2024-03-05T08:09:44Z");
+		const signed = await signRfc9421Many([
+			1,
+			2,
+			3,
+			4
+		].map((n) => `https://example.com/key-${n}`), currentTime);
+		const headers = new Headers(signed.headers);
+		headers.set("Signature-Input", headers.get("Signature-Input").replace("https://example.com/key-1", "not a URL"));
+		const request = new Request(signed.url, {
+			method: "POST",
+			headers
+		});
+		const keyIds = (maxSignatures) => listRequestSignatures(request, maxSignatures).map((s) => s.keyId.href);
+		assertEquals(keyIds(), ["https://example.com/key-2", "https://example.com/key-3"]);
+		assertEquals(keyIds(1), []);
+		assertEquals(keyIds(Infinity), [
+			"https://example.com/key-2",
+			"https://example.com/key-3",
+			"https://example.com/key-4"
+		]);
+	});
+	await t.step("unsigned or malformed", () => {
+		assertEquals(listRequestSignatures(request()), []);
+		const malformed = request();
+		malformed.headers.set("Signature", "keyId=\"not a URL\",signature=\"AA==\"");
+		assertEquals(listRequestSignatures(malformed), []);
+		const garbage = request();
+		garbage.headers.set("Signature-Input", "((");
+		garbage.headers.set("Signature", "((");
+		assertEquals(listRequestSignatures(garbage), []);
+	});
+});
+test("selectRequestSignature()", async () => {
+	const body = "Test message";
+	const sign = (label, keyId) => signRequest(new Request("https://example.com/inbox", {
+		method: "POST",
+		body
+	}), rsaPrivateKey2, keyId, {
+		spec: "rfc9421",
+		rfc9421: { label }
+	});
+	const first = await sign("a", new URL("https://example.com/other#key"));
+	const second = await sign("b", rsaPublicKey2.id);
+	const headers = new Headers(second.headers);
+	for (const name of ["Signature-Input", "Signature"]) headers.set(name, `${first.headers.get(name)}, ${second.headers.get(name)}`);
+	const request = new Request(second.url, {
+		method: "POST",
+		headers,
+		body
+	});
+	const signatures = listRequestSignatures(request);
+	assertEquals(signatures.map((s) => s.label), ["a", "b"]);
+	const selected = selectRequestSignature(request, signatures[1]);
+	assertEquals(listRequestSignatures(selected).map((s) => [s.label, s.keyId.href]), [["b", rsaPublicKey2.id.href]]);
+	const result = await verifyRequestDetailed(selected, {
+		documentLoader: mockDocumentLoader,
+		contextLoader: mockDocumentLoader
+	});
+	assert(result.verified);
+	assertEquals(result.key.id, rsaPublicKey2.id);
+	assertEquals(await selected.text(), body);
+	assertEquals(await request.text(), body);
+});
+test("verifyRequestDetailed() reports a timed-out key fetch", async (t) => {
+	for (const stall of ["headers", "body"]) await t.step(`stalled ${stall}`, async () => {
+		esm_default.mockGlobal();
+		const keyId = new URL(`https://slow.example/actors/alice#${stall}`);
+		let requests = 0;
+		esm_default.get(`begin:https://slow.example/actors/alice`, () => {
+			requests++;
+			if (stall === "headers") return new Promise(() => {});
+			return new Response(new ReadableStream({ pull: () => new Promise(() => {}) }), { status: 404 });
+		});
+		const loader = getDocumentLoader({
+			allowPrivateAddress: true,
+			timeout: 100
+		});
+		const documentLoader = (url, options) => url.startsWith("https://slow.example/") ? loader(url, options) : mockDocumentLoader(url);
+		const kv = new MemoryKvStore();
+		try {
+			const sign = () => signRequest(new Request("https://example.com/inbox", {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/activity+json",
+					accept: "application/ld+json"
+				},
+				body: JSON.stringify({
+					"@context": "https://www.w3.org/ns/activitystreams",
+					type: "Create",
+					actor: "https://slow.example/actors/alice"
+				})
+			}), rsaPrivateKey2, keyId);
+			const result = await verifyRequestDetailed(await sign(), {
+				contextLoader: mockDocumentLoader,
+				documentLoader,
+				keyCache: new KvKeyCache(kv, ["pk"])
+			});
+			assertFalse(result.verified);
+			assert(result.reason.type === "keyFetchError");
+			assertEquals(result.reason.keyId, keyId);
+			assert("error" in result.reason.result);
+			const error = result.reason.result.error;
+			assert(error instanceof FetchError);
+			assertEquals(error.response, void 0);
+			assert(error.cause instanceof DOMException);
+			assertEquals(error.cause.name, "TimeoutError");
+			assertEquals(requests, 1);
+			const cached = await verifyRequestDetailed(await sign(), {
+				contextLoader: mockDocumentLoader,
+				documentLoader,
+				keyCache: new KvKeyCache(kv, ["pk"])
+			});
+			assertFalse(cached.verified);
+			assert(cached.reason.type === "keyFetchError");
+			assert("error" in cached.reason.result);
+			assertEquals(cached.reason.result.error.name, "FetchError");
+			assertStringIncludes(cached.reason.result.error.message, "Timed out after 100 ms");
+			assertEquals(requests, 1);
+		} finally {
+			esm_default.hardReset();
+		}
+	});
+});
 //#endregion
 export {};