@fedify/fedify 2.4.0-pr.936.41 → 2.5.0-dev.2271

package/dist/sig/portable-key.test.mjs

@@ -0,0 +1,1439 @@
+import { Temporal } from "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
+import { a as fetchKeyDetailed, i as fetchKey } from "../key-BspPiXqn.mjs";
+import { h as verifyJsonLd, p as signJsonLd } from "../ld-CzaP-hJl.mjs";
+import { d as verifyProof, r as createProof } from "../proof-Dxy6ByqI.mjs";
+import { n as resolvePortableActorKey } from "../portable-key-BIMLrAP4.mjs";
+import { f as verifyRequest, l as signRequest, p as verifyRequestDetailed } from "../http-siciWkmx.mjs";
+import { a as rsaPrivateKey3, c as rsaPublicKey3, i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
+import { n as getKeyOwner, t as doesActorOwnKey } from "../owner-DYgfTFHy.mjs";
+import { t as KvKeyCache } from "../keycache-Da8A8mZa.mjs";
+import { Create, CryptographicKey, Multikey, Note, Person } from "@fedify/vocab";
+import { FetchError, encodeMultibase, exportDidKey, exportSpki, parseIri, preloadedContexts } from "@fedify/vocab-runtime";
+import { test } from "@fedify/fixture";
+import { deepStrictEqual, ok, strictEqual } from "node:assert/strict";
+import serialize from "json-canon";
+//#region src/sig/portable-key.test.ts
+const did = await exportDidKey(ed25519PublicKey.publicKey);
+const didKeyId = `${did}#${did.slice(8)}`;
+const otherKeyPair = await crypto.subtle.generateKey("Ed25519", true, ["sign", "verify"]);
+const otherDid = await exportDidKey(otherKeyPair.publicKey);
+const actorId = `ap+ef61://${did}/actor`;
+const gw1 = "https://gw1.example";
+const gw2 = "https://gw2.example";
+function compatibleId(gateway, id = actorId) {
+	return `${gateway}/.well-known/apgateway/${id.replace(/^ap\+ef61:\/\//, "")}`;
+}
+const keyId = new URL(`${compatibleId(gw1)}#main-key`);
+const gatewayPublicKey = rsaPublicKey2.publicKey;
+const contextLoader = (url) => {
+	const document = preloadedContexts[url];
+	if (document == null) return Promise.reject(/* @__PURE__ */ new Error(`No context: ${url}`));
+	return Promise.resolve({
+		contextUrl: null,
+		documentUrl: url,
+		document
+	});
+};
+function createLoader(responses) {
+	const fetched = [];
+	const loader = (url) => {
+		fetched.push(url);
+		const document = responses[url.replace(/#.*$/, "")];
+		if (document == null) return Promise.reject(new FetchError(url, "HTTP 404", new Response(null, { status: 404 })));
+		return Promise.resolve({
+			contextUrl: null,
+			documentUrl: url,
+			document: structuredClone(document)
+		});
+	};
+	return Object.assign(loader, { fetched });
+}
+async function sign(document, privateKey = ed25519PrivateKey, verificationMethod = didKeyId, proofOptions = {}) {
+	const proofConfig = {
+		"@context": document["@context"],
+		type: "DataIntegrityProof",
+		cryptosuite: "eddsa-jcs-2022",
+		verificationMethod,
+		proofPurpose: "assertionMethod",
+		created: "2023-02-24T23:36:38Z",
+		...proofOptions
+	};
+	const encoder = new TextEncoder();
+	const proofDigest = await crypto.subtle.digest("SHA-256", encoder.encode(serialize(proofConfig)));
+	const messageDigest = await crypto.subtle.digest("SHA-256", encoder.encode(serialize(document)));
+	const digest = /* @__PURE__ */ new Uint8Array(64);
+	digest.set(new Uint8Array(proofDigest), 0);
+	digest.set(new Uint8Array(messageDigest), 32);
+	const signature = await crypto.subtle.sign("Ed25519", privateKey, digest);
+	return {
+		...document,
+		proof: {
+			...proofConfig,
+			proofValue: new TextDecoder().decode(encodeMultibase("base58btc", new Uint8Array(signature)))
+		}
+	};
+}
+async function actorJson(options = {}) {
+	const id = parseIri(options.id ?? actorId);
+	const key = options.key ?? keyId;
+	const json = await new Person({
+		id,
+		preferredUsername: "alice",
+		inbox: parseIri(`${options.id ?? actorId}/inbox`),
+		gateways: (options.gateways ?? [gw1, gw2]).map((g) => new URL(g)),
+		assertionMethods: options.assertionMethod === false ? [] : [new Multikey({
+			id: key,
+			controller: id,
+			publicKey: gatewayPublicKey
+		})],
+		publicKeys: options.publicKey === null ? [] : [new CryptographicKey({
+			id: key,
+			owner: id,
+			publicKey: options.publicKey ?? gatewayPublicKey
+		})]
+	}).toJsonLd({
+		format: "compact",
+		contextLoader
+	});
+	const context = json["@context"];
+	if (!context.includes("https://w3id.org/security/data-integrity/v1")) json["@context"] = [...context, "https://w3id.org/security/data-integrity/v1"];
+	return json;
+}
+async function signedRequest(spec, key = keyId) {
+	return await signRequest(new Request("https://recipient.example/inbox", {
+		method: "POST",
+		body: "{}",
+		headers: { "Content-Type": "application/activity+json" }
+	}), rsaPrivateKey2, key, { spec });
+}
+test("verifyRequest() accepts gateway keys vouched for by portable actors", async () => {
+	const documentLoader = createLoader({ [compatibleId(gw1)]: await sign(await actorJson()) });
+	for (const spec of ["draft-cavage-http-signatures-12", "rfc9421"]) {
+		const key = await verifyRequest(await signedRequest(spec), {
+			documentLoader,
+			contextLoader,
+			spec
+		});
+		ok(key != null, spec);
+		strictEqual(key.id?.href, keyId.href);
+		strictEqual(key.ownerId?.href, parseIri(actorId).href);
+	}
+});
+test("verifyRequest() accepts gateway keys only in assertionMethod", async () => {
+	const documentLoader = createLoader({ [compatibleId(gw1)]: await sign(await actorJson({ publicKey: null })) });
+	strictEqual((await verifyRequest(await signedRequest(), {
+		documentLoader,
+		contextLoader
+	}))?.id?.href, keyId.href);
+});
+test("verifyRequest() rejects gateway keys that portable actors do not vouch for", async () => {
+	const unsigned = await actorJson();
+	const cases = {
+		"an unsigned actor document": unsigned,
+		"an actor document signed by another DID": await sign(unsigned, otherKeyPair.privateKey, `${otherDid}#${otherDid.slice(8)}`),
+		"an unlisted gateway": await sign(await actorJson({ gateways: [gw2] })),
+		"a key missing from both assertionMethod and publicKey": await sign(await actorJson({
+			assertionMethod: false,
+			publicKey: null
+		})),
+		"a key referred to by URL in assertionMethod, embedded in publicKey": await sign({
+			...await actorJson({ assertionMethod: false }),
+			assertionMethod: [keyId.href]
+		}),
+		"a key only in publicKey without an owner": await sign(withoutPublicKeyOwner(await actorJson({ assertionMethod: false }))),
+		"two keys with the same ID in publicKey": await sign(await duplicatePublicKey(await actorJson({ assertionMethod: false }))),
+		"a key referred to by URL": await sign({
+			...await actorJson({
+				publicKey: null,
+				assertionMethod: false
+			}),
+			assertionMethod: [keyId.href]
+		}),
+		"a publicKey entry with other key material": await sign(await actorJson({ publicKey: rsaPublicKey3.publicKey })),
+		"a key ID for another actor": await sign(await actorJson({ key: new URL(`${compatibleId(gw1, `${actorId}/other`)}#main-key`) }))
+	};
+	for (const [name, document] of Object.entries(cases)) {
+		const documentLoader = createLoader({ [compatibleId(gw1)]: document });
+		strictEqual(await verifyRequest(await signedRequest(), {
+			documentLoader,
+			contextLoader
+		}), null, name);
+	}
+	const otherActorKey = new URL(`${compatibleId(gw1, `${actorId}/other`)}#main-key`);
+	const documentLoader = createLoader({ [compatibleId(gw1, `${actorId}/other`)]: await sign(await actorJson()) });
+	strictEqual(await verifyRequest(await signedRequest(void 0, otherActorKey), {
+		documentLoader,
+		contextLoader
+	}), null);
+});
+function withoutPublicKeyOwner(json) {
+	const { owner: _, ...publicKey } = json.publicKey;
+	return {
+		...json,
+		publicKey
+	};
+}
+async function duplicatePublicKey(json) {
+	const publicKey = json.publicKey;
+	return {
+		...json,
+		publicKey: [publicKey, {
+			...publicKey,
+			publicKeyPem: await exportSpki(rsaPublicKey3.publicKey)
+		}]
+	};
+}
+test("verifyRequest() accepts gateway keys referred to by URL in publicKey", async () => {
+	const documentLoader = createLoader({ [compatibleId(gw1)]: await sign({
+		...await actorJson({ publicKey: null }),
+		publicKey: keyId.href
+	}) });
+	strictEqual((await verifyRequest(await signedRequest(), {
+		documentLoader,
+		contextLoader
+	}))?.id?.href, keyId.href);
+});
+test("verifyRequest() accepts gateway keys only in publicKey", async () => {
+	const documentLoader = createLoader({ [compatibleId(gw1)]: await sign(await actorJson({ assertionMethod: false })) });
+	const key = await verifyRequest(await signedRequest(), {
+		documentLoader,
+		contextLoader
+	});
+	strictEqual(key?.id?.href, keyId.href);
+	strictEqual(key?.ownerId?.href, parseIri(actorId).href);
+});
+test("verifyRequest() resolves gateway keys of compatible-ID actors", async () => {
+	const id = compatibleId(gw1);
+	const signed = await sign(await actorJson({
+		id,
+		gateways: [gw1]
+	}));
+	let key = await verifyRequest(await signedRequest(), {
+		documentLoader: createLoader({ [id]: signed }),
+		contextLoader
+	});
+	strictEqual(key?.id?.href, keyId.href);
+	strictEqual(key?.ownerId?.href, id);
+	key = await verifyRequest(await signedRequest(), {
+		documentLoader: createLoader({ [id]: await sign(await actorJson({
+			id,
+			gateways: [gw1],
+			assertionMethod: false
+		})) }),
+		contextLoader
+	});
+	strictEqual(key?.id?.href, keyId.href);
+	const evil = "https://evil.example";
+	const evilId = compatibleId(evil);
+	const evilKeyId = new URL(`${evilId}#main-key`);
+	const unsigned = await actorJson({
+		id: evilId,
+		gateways: [evil],
+		key: evilKeyId
+	});
+	const documentLoader = createLoader({ [evilId]: unsigned });
+	strictEqual(await verifyRequest(await signedRequest(void 0, evilKeyId), {
+		documentLoader,
+		contextLoader
+	}), null);
+	strictEqual(await getKeyOwner(evilKeyId, {
+		documentLoader,
+		contextLoader
+	}), null);
+	strictEqual(await verifyRequest(await signedRequest(), {
+		documentLoader: createLoader({ [id]: await sign(await actorJson({
+			id,
+			gateways: [gw1]
+		}), otherKeyPair.privateKey, `${otherDid}#${otherDid.slice(8)}`) }),
+		contextLoader
+	}), null);
+});
+test("keys at ordinary URLs cannot belong to portable actors", async () => {
+	const evil = "https://evil.example";
+	const evilActorId = compatibleId(evil);
+	const evilKeyId = new URL(`${evil}/keys/1`);
+	const options = {
+		documentLoader: createLoader({
+			[evilKeyId.href]: {
+				"@context": "https://w3id.org/security/v1",
+				id: evilKeyId.href,
+				type: "Key",
+				owner: evilActorId,
+				publicKeyPem: await exportSpki(gatewayPublicKey)
+			},
+			[evilActorId]: await actorJson({
+				id: evilActorId,
+				gateways: [evil],
+				key: evilKeyId,
+				assertionMethod: false
+			})
+		}),
+		contextLoader
+	};
+	strictEqual(await verifyRequest(await signedRequest(void 0, evilKeyId), options), null);
+	strictEqual((await fetchKey(evilKeyId, CryptographicKey, options)).key, null);
+	strictEqual(await getKeyOwner(evilKeyId, options), null);
+	const key = new CryptographicKey({
+		id: evilKeyId,
+		owner: new URL(evilActorId),
+		publicKey: gatewayPublicKey
+	});
+	strictEqual(await getKeyOwner(key, options), null);
+	ok(!await doesActorOwnKey(new Create({
+		id: new URL(`${evil}/activities/1`),
+		actor: new URL(evilActorId)
+	}), key, options));
+	const actorKeyId = new URL(`${evil}/users/alice#main-key`);
+	for (const document of [await actorJson({
+		id: evilActorId,
+		gateways: [evil],
+		key: actorKeyId
+	}), withoutPublicKeyOwner(await actorJson({
+		id: evilActorId,
+		gateways: [evil],
+		key: actorKeyId,
+		assertionMethod: false
+	}))]) {
+		const actorOptions = {
+			documentLoader: createLoader({ [`${evil}/users/alice`]: document }),
+			contextLoader
+		};
+		strictEqual(await verifyRequest(await signedRequest(void 0, actorKeyId), actorOptions), null);
+		strictEqual((await fetchKey(actorKeyId, CryptographicKey, actorOptions)).key, null);
+		strictEqual(await getKeyOwner(actorKeyId, actorOptions), null);
+	}
+	const ownerKeyId = new URL(`${evil}/keys/2`);
+	const ownerOptions = {
+		documentLoader: createLoader({
+			[ownerKeyId.href]: {
+				"@context": "https://w3id.org/security/v1",
+				id: ownerKeyId.href,
+				type: "Key",
+				owner: `${evil}/users/bob`,
+				publicKeyPem: await exportSpki(gatewayPublicKey)
+			},
+			[`${evil}/users/bob`]: await actorJson({
+				id: evilActorId,
+				gateways: [evil],
+				key: ownerKeyId,
+				assertionMethod: false
+			})
+		}),
+		contextLoader
+	};
+	strictEqual(await getKeyOwner(ownerKeyId, ownerOptions), null);
+	strictEqual(await getKeyOwner(new CryptographicKey({
+		id: ownerKeyId,
+		owner: new URL(`${evil}/users/bob`),
+		publicKey: gatewayPublicKey
+	}), ownerOptions), null);
+	const keyCache = {
+		get: () => Promise.resolve(key),
+		set: () => Promise.resolve()
+	};
+	strictEqual((await fetchKey(evilKeyId, CryptographicKey, {
+		...options,
+		keyCache
+	})).key, null);
+});
+const specs = ["draft-cavage-http-signatures-12", "rfc9421"];
+function fetchKeyOf(cls, options) {
+	return cls === CryptographicKey ? fetchKey(keyId, CryptographicKey, options) : fetchKey(keyId, Multikey, options);
+}
+function fetchCount(loader, url = keyId) {
+	const document = url.href.replace(/#.*$/, "");
+	return loader.fetched.filter((u) => u.replace(/#.*$/, "") === document).length;
+}
+test("verifyRequest() caches failures to fetch compatible key IDs", async () => {
+	const unreachable = {
+		"404 Not Found": createLoader({}),
+		"a network error": (url) => Promise.reject(/* @__PURE__ */ new TypeError(`${url}`))
+	};
+	for (const spec of specs) for (const [name, inner] of Object.entries(unreachable)) {
+		const fetched = [];
+		const documentLoader = Object.assign((url) => {
+			fetched.push(url);
+			return inner(url);
+		}, { fetched });
+		const keyCache = new KvKeyCache(new MemoryKvStore(), ["pk"]);
+		const options = {
+			documentLoader,
+			contextLoader,
+			keyCache,
+			spec
+		};
+		for (let i = 0; i < 3; i++) {
+			const result = await verifyRequestDetailed(await signedRequest(spec), options);
+			ok(!result.verified, `${spec}, ${name}`);
+			strictEqual(result.reason.type, "keyFetchError", `${spec}, ${name}`);
+		}
+		strictEqual(fetchCount(documentLoader), 1, `${spec}, ${name}`);
+		for (const cls of [CryptographicKey, Multikey]) {
+			const result = await fetchKeyOf(cls, options);
+			strictEqual(result.key, null);
+			ok(result.cached, `${spec}, ${name}, ${cls.name}`);
+		}
+		strictEqual(fetchCount(documentLoader), 1, `${spec}, ${name}`);
+	}
+});
+test("verifyRequest() caches gateway keys only for HTTP Signatures", async () => {
+	for (const spec of specs) {
+		const documentLoader = createLoader({ [compatibleId(gw1)]: await sign(await actorJson()) });
+		const keyCache = new KvKeyCache(new MemoryKvStore(), ["pk"]);
+		const options = {
+			documentLoader,
+			contextLoader,
+			keyCache,
+			spec
+		};
+		for (let i = 0; i < 3; i++) strictEqual((await verifyRequest(await signedRequest(spec), options))?.ownerId?.href, parseIri(actorId).href, spec);
+		strictEqual(fetchCount(documentLoader), 1, spec);
+		const document = {
+			"@context": "https://www.w3.org/ns/activitystreams",
+			type: "Create",
+			id: "https://gw1.example/activities/1",
+			actor: compatibleId(gw1)
+		};
+		const { signature } = await signJsonLd(document, rsaPrivateKey2, keyId, { contextLoader });
+		ok(!await verifyJsonLd({
+			...document,
+			signature
+		}, options), spec);
+		const note = new Note({
+			id: new URL("https://gw1.example/notes/1"),
+			attribution: new URL(compatibleId(gw1)),
+			content: "Hello"
+		});
+		const proof = await createProof(note, ed25519PrivateKey, keyId, { contextLoader });
+		strictEqual(await verifyProof(await note.toJsonLd({
+			format: "compact",
+			contextLoader
+		}), proof, options), null, spec);
+		for (const cls of [CryptographicKey, Multikey]) strictEqual((await fetchKeyOf(cls, options)).key, null, spec);
+		const fetched = fetchCount(documentLoader);
+		ok(await verifyRequest(await signedRequest(spec), options) != null, spec);
+		strictEqual(fetchCount(documentLoader), fetched, spec);
+	}
+});
+test("verifyRequest() is not rejected by other purposes' negative entries", async () => {
+	const documentLoader = createLoader({ [compatibleId(gw1)]: await sign(await actorJson()) });
+	const keyCache = new KvKeyCache(new MemoryKvStore(), ["pk"]);
+	const options = {
+		documentLoader,
+		contextLoader,
+		keyCache
+	};
+	for (const cls of [CryptographicKey, Multikey]) strictEqual((await fetchKeyOf(cls, options)).key, null);
+	ok(await verifyRequest(await signedRequest(), options) != null);
+	const fetched = fetchCount(documentLoader);
+	for (const cls of [CryptographicKey, Multikey]) {
+		const result = await fetchKeyOf(cls, options);
+		strictEqual(result.key, null);
+		ok(result.cached);
+	}
+	strictEqual(fetchCount(documentLoader), fetched);
+});
+test("fetchKey() does not share negative entries of compatible key IDs across key classes", async () => {
+	const ownerId = new URL("https://gw1.example/users/bob");
+	const multikey = new Multikey({
+		id: keyId,
+		controller: ownerId,
+		publicKey: ed25519PublicKey.publicKey
+	});
+	const documentLoader = createLoader({
+		[compatibleId(gw1)]: await multikey.toJsonLd({ contextLoader }),
+		[ownerId.href]: await new Person({
+			id: ownerId,
+			assertionMethods: [multikey]
+		}).toJsonLd({ contextLoader })
+	});
+	const keyCache = new KvKeyCache(new MemoryKvStore(), ["pk"]);
+	const options = {
+		documentLoader,
+		contextLoader,
+		keyCache
+	};
+	strictEqual((await fetchKey(keyId, CryptographicKey, options)).key, null);
+	strictEqual(await verifyRequest(await signedRequest(), options), null);
+	const result = await fetchKey(keyId, Multikey, options);
+	strictEqual(result.key?.id?.href, keyId.href);
+	ok(!result.cached);
+	const cached = await fetchKey(keyId, Multikey, options);
+	strictEqual(cached.key?.id?.href, keyId.href);
+	ok(cached.cached);
+	const other = await fetchKey(keyId, CryptographicKey, options);
+	strictEqual(other.key, null);
+	ok(other.cached);
+});
+test("verifyRequest() caches rejected portable actor documents", async () => {
+	for (const spec of specs) {
+		const documentLoader = createLoader({ [compatibleId(gw1)]: await actorJson() });
+		const keyCache = new KvKeyCache(new MemoryKvStore(), ["pk"]);
+		const options = {
+			documentLoader,
+			contextLoader,
+			keyCache,
+			spec
+		};
+		for (let i = 0; i < 3; i++) {
+			const result = await verifyRequestDetailed(await signedRequest(spec), options);
+			ok(!result.verified, spec);
+			strictEqual(result.reason.type, "invalidSignature", spec);
+		}
+		strictEqual(fetchCount(documentLoader), 1, spec);
+	}
+});
+test("verifyRequest() refetches a cached gateway key that fails to verify", async () => {
+	for (const spec of specs) {
+		const responses = { [compatibleId(gw1)]: await sign(await actorJson()) };
+		const documentLoader = createLoader(responses);
+		const keyCache = new KvKeyCache(new MemoryKvStore(), ["pk"]);
+		const options = {
+			documentLoader,
+			contextLoader,
+			keyCache,
+			spec
+		};
+		ok(await verifyRequest(await signedRequest(spec), options) != null);
+		responses[compatibleId(gw1)] = await sign(await actorJson({
+			publicKey: rsaPublicKey3.publicKey,
+			assertionMethod: false
+		}));
+		const rotated = async () => await signRequest(new Request("https://recipient.example/inbox", {
+			method: "POST",
+			body: "{}",
+			headers: { "Content-Type": "application/activity+json" }
+		}), rsaPrivateKey3, keyId, { spec });
+		ok(await verifyRequest(await rotated(), options) != null, spec);
+		strictEqual(fetchCount(documentLoader), 2, spec);
+		ok(await verifyRequest(await rotated(), options) != null, spec);
+		strictEqual(fetchCount(documentLoader), 2, spec);
+	}
+});
+test("verifyRequest() drops a cached gateway key when its refetch fails", async () => {
+	for (const spec of specs) {
+		const responses = { [compatibleId(gw1)]: await sign(await actorJson()) };
+		const documentLoader = createLoader(responses);
+		const keyCache = new KvKeyCache(new MemoryKvStore(), ["pk"]);
+		const options = {
+			documentLoader,
+			contextLoader,
+			keyCache,
+			spec
+		};
+		ok(await verifyRequest(await signedRequest(spec), options) != null);
+		delete responses[compatibleId(gw1)];
+		const result = await verifyRequestDetailed(await signRequest(new Request("https://recipient.example/inbox", {
+			method: "POST",
+			body: "{}",
+			headers: { "Content-Type": "application/activity+json" }
+		}), rsaPrivateKey3, keyId, { spec }), options);
+		ok(!result.verified, spec);
+		strictEqual(result.reason.type, "keyFetchError", spec);
+		strictEqual(fetchCount(documentLoader), 2, spec);
+		const next = await verifyRequestDetailed(await signedRequest(spec), options);
+		ok(!next.verified, spec);
+		strictEqual(next.reason.type, "keyFetchError", spec);
+		strictEqual(fetchCount(documentLoader), 2, spec);
+	}
+});
+test("verifyRequest() does not trust a cached gateway key for longer than its proof", async () => {
+	let now = Temporal.Now.instant();
+	const keyCache = new KvKeyCache(new MemoryKvStore(), ["pk"], { now: () => now });
+	const expires = now.add({ minutes: 30 });
+	const documentLoader = createLoader({ [compatibleId(gw1)]: await sign(await actorJson(), ed25519PrivateKey, didKeyId, { expires: expires.toString() }) });
+	const options = {
+		documentLoader,
+		contextLoader,
+		keyCache
+	};
+	ok(await verifyRequest(await signedRequest(), options) != null);
+	now = expires.subtract({ seconds: 1 });
+	ok(await verifyRequest(await signedRequest(), options) != null);
+	strictEqual(fetchCount(documentLoader), 1);
+	now = expires;
+	ok(await verifyRequest(await signedRequest(), options) != null);
+	strictEqual(fetchCount(documentLoader), 2);
+});
+test("verifyRequest() looks up a cached gateway key again after an hour", async () => {
+	let now = Temporal.Now.instant();
+	const keyCache = new KvKeyCache(new MemoryKvStore(), ["pk"], { now: () => now });
+	const responses = { [compatibleId(gw1)]: await sign(await actorJson()) };
+	const documentLoader = createLoader(responses);
+	const options = {
+		documentLoader,
+		contextLoader,
+		keyCache
+	};
+	const start = now;
+	ok(await verifyRequest(await signedRequest(), options) != null);
+	now = start.add({ minutes: 59 });
+	ok(await verifyRequest(await signedRequest(), options) != null);
+	strictEqual(fetchCount(documentLoader), 1);
+	responses[compatibleId(gw1)] = await sign(await actorJson({ gateways: [gw2] }));
+	now = start.add({ hours: 1 });
+	strictEqual(await verifyRequest(await signedRequest(), options), null);
+	strictEqual(fetchCount(documentLoader), 2);
+});
+test("verifyRequest() rejects and caches gateway keys of expired documents", async () => {
+	const documentLoader = createLoader({ [compatibleId(gw1)]: await sign(await actorJson(), ed25519PrivateKey, didKeyId, { expires: "2000-01-01T00:00:00Z" }) });
+	const keyCache = new KvKeyCache(new MemoryKvStore(), ["pk"]);
+	const options = {
+		documentLoader,
+		contextLoader,
+		keyCache
+	};
+	strictEqual(await verifyRequest(await signedRequest(), options), null);
+	strictEqual(await verifyRequest(await signedRequest(), options), null);
+	strictEqual(fetchCount(documentLoader), 1);
+});
+test("verifyRequest() takes the expiration of a proof whatever its context", async () => {
+	let now = Temporal.Now.instant();
+	const keyCache = new KvKeyCache(new MemoryKvStore(), ["pk"], { now: () => now });
+	const expires = now.add({ minutes: 30 });
+	const actor = await actorJson();
+	const documentLoader = createLoader({ [compatibleId(gw1)]: await sign({
+		...actor,
+		"@context": [...actor["@context"], { expires: "https://example.com/ns#notExpiration" }]
+	}, ed25519PrivateKey, didKeyId, { expires: expires.toString() }) });
+	const options = {
+		documentLoader,
+		contextLoader,
+		keyCache
+	};
+	ok(await verifyRequest(await signedRequest(), options) != null);
+	now = expires.subtract({ seconds: 1 });
+	ok(await verifyRequest(await signedRequest(), options) != null);
+	strictEqual(fetchCount(documentLoader), 1);
+	now = expires;
+	ok(await verifyRequest(await signedRequest(), options) != null);
+	strictEqual(fetchCount(documentLoader), 2);
+});
+test("a key cache without namespaces caches only fetch failures of compatible key IDs", async () => {
+	const calls = [];
+	const entries = /* @__PURE__ */ new Map();
+	const keyCache = {
+		get(id) {
+			calls.push(`get ${id.href}`);
+			return Promise.resolve(entries.get(id.href));
+		},
+		set(id, key) {
+			calls.push(`set ${id.href} ${key == null ? "null" : "key"}`);
+			entries.set(id.href, key);
+			return Promise.resolve();
+		}
+	};
+	const options = {
+		documentLoader: createLoader({ [compatibleId(gw1)]: await sign(await actorJson()) }),
+		contextLoader,
+		keyCache
+	};
+	ok(await verifyRequest(await signedRequest(), options) != null);
+	for (const cls of [CryptographicKey, Multikey]) strictEqual((await fetchKeyOf(cls, options)).key, null);
+	ok(await verifyRequest(await signedRequest(), options) != null);
+	deepStrictEqual(calls.filter((c) => c.startsWith("set ") && c.includes(keyId.origin)), []);
+	const unreachable = new URL(`${compatibleId(gw2)}#main-key`);
+	strictEqual((await fetchKey(unreachable, CryptographicKey, options)).key, null);
+	deepStrictEqual(calls.filter((c) => c.startsWith("set ") && c.includes(gw2)), [`set ${unreachable.href} null`]);
+});
+test("doesActorOwnKey() and getKeyOwner() resolve gateway keys to portable actors", async () => {
+	const options = {
+		documentLoader: createLoader({ [compatibleId(gw1)]: await sign(await actorJson()) }),
+		contextLoader
+	};
+	const key = await verifyRequest(await signedRequest(), options);
+	ok(key != null);
+	const activity = (actor) => new Create({
+		id: parseIri(`ap+ef61://${did}/activities/1`),
+		actor: parseIri(actor)
+	});
+	ok(await doesActorOwnKey(activity(actorId), key, options));
+	ok(await doesActorOwnKey(activity(compatibleId(gw2)), key, options));
+	ok(!await doesActorOwnKey(activity(`${actorId}/other`), key, options));
+	strictEqual((await getKeyOwner(keyId, options))?.id?.href, parseIri(actorId).href);
+	strictEqual((await getKeyOwner(key, options))?.id?.href, key.ownerId?.href);
+	const forged = key.clone({ publicKey: rsaPublicKey3.publicKey });
+	strictEqual(await getKeyOwner(forged, options), null);
+	ok(!await doesActorOwnKey(activity(actorId), forged, options));
+});
+test("doesActorOwnKey() and getKeyOwner() do not fall back for rejected gateway keys", async () => {
+	const options = {
+		documentLoader: createLoader({ [compatibleId(gw1)]: await actorJson() }),
+		contextLoader
+	};
+	const key = new CryptographicKey({
+		id: keyId,
+		owner: parseIri(actorId),
+		publicKey: gatewayPublicKey
+	});
+	ok(!await doesActorOwnKey(new Create({
+		id: parseIri(`ap+ef61://${did}/activities/1`),
+		actor: parseIri(actorId)
+	}), key, options));
+	strictEqual(await getKeyOwner(keyId, options), null);
+	strictEqual(await getKeyOwner(key, options), null);
+});
+test("verifyRequest() binds gateway keys to the actor whose document is signed", async () => {
+	const attackerDid = otherDid;
+	const attackerActorId = `ap+ef61://${attackerDid}/actor`;
+	const shiftingContext = "https://attacker.example/context";
+	let loads = 0;
+	const shiftingContextLoader = (url) => {
+		if (url !== shiftingContext) return contextLoader(url);
+		loads++;
+		const document = { "@context": loads <= 2 ? {
+			victimId: "@id",
+			attackerId: "https://attacker.example/ns#a"
+		} : {
+			victimId: "https://attacker.example/ns#v",
+			attackerId: "@id"
+		} };
+		return Promise.resolve({
+			contextUrl: null,
+			documentUrl: url,
+			document
+		});
+	};
+	const { id: _, ...victim } = await actorJson({ gateways: [gw1] });
+	const document = await sign({
+		...victim,
+		"@context": [...victim["@context"], shiftingContext],
+		victimId: actorId,
+		attackerId: attackerActorId
+	}, otherKeyPair.privateKey, `${attackerDid}#${attackerDid.slice(8)}`);
+	const documentLoader = createLoader({ [compatibleId(gw1)]: document });
+	strictEqual(await verifyRequest(await signedRequest(), {
+		documentLoader,
+		contextLoader: shiftingContextLoader
+	}), null);
+	ok(loads > 2, "the shifting context was loaded for the proof");
+	loads = 0;
+	strictEqual(await getKeyOwner(keyId, {
+		documentLoader,
+		contextLoader: shiftingContextLoader
+	}), null);
+});
+test("verifyRequest() matches gateway keys listed under ap: URIs", async () => {
+	const portableKeyId = parseIri(`${actorId}#main-key`);
+	const cases = {
+		"both properties": await actorJson({ key: portableKeyId }),
+		"assertionMethod only": await actorJson({
+			key: portableKeyId,
+			publicKey: null
+		}),
+		"publicKey only": await actorJson({
+			key: portableKeyId,
+			assertionMethod: false
+		})
+	};
+	for (const [name, document] of Object.entries(cases)) {
+		const documentLoader = createLoader({ [compatibleId(gw1)]: await sign(document) });
+		for (const spec of specs) {
+			const key = await verifyRequest(await signedRequest(spec), {
+				documentLoader,
+				contextLoader,
+				spec
+			});
+			strictEqual(key?.id?.href, keyId.href, `${name}, ${spec}`);
+			strictEqual(key?.ownerId?.href, parseIri(actorId).href, name);
+		}
+	}
+});
+test("verifyRequest() rejects ambiguous or foreign aliases of gateway keys", async () => {
+	const portableKeyId = `${actorId}#main-key`;
+	const base = await actorJson();
+	const assertionMethod = base.assertionMethod;
+	const publicKey = base.publicKey;
+	const cases = {
+		"an exact entry and an ap: alias in assertionMethod": {
+			...base,
+			assertionMethod: [assertionMethod, {
+				...assertionMethod,
+				id: portableKeyId
+			}]
+		},
+		"a reference and an embedded ap: alias in assertionMethod": {
+			...base,
+			assertionMethod: [keyId.href, {
+				...assertionMethod,
+				id: portableKeyId
+			}]
+		},
+		"an exact entry and an ap: alias in publicKey": {
+			...base,
+			publicKey: [publicKey, {
+				...publicKey,
+				id: portableKeyId
+			}]
+		},
+		"a key of another gateway": await actorJson({ key: new URL(`${compatibleId(gw2)}#main-key`) }),
+		"an ap: key ID with dot segments": {
+			...base,
+			assertionMethod: {
+				...assertionMethod,
+				id: portableKeyId.replace("/actor#", "/x/../actor#")
+			},
+			publicKey: {
+				...publicKey,
+				id: portableKeyId.replace("/actor#", "/x/../actor#")
+			}
+		},
+		"a compatible key ID with dot segments": {
+			...base,
+			assertionMethod: {
+				...assertionMethod,
+				id: keyId.href.replace("/actor#", "/x/../actor#")
+			},
+			publicKey: {
+				...publicKey,
+				id: keyId.href.replace("/actor#", "/x/../actor#")
+			}
+		}
+	};
+	for (const [name, document] of Object.entries(cases)) {
+		const documentLoader = createLoader({ [compatibleId(gw1)]: await sign(document) });
+		strictEqual(await verifyRequest(await signedRequest(), {
+			documentLoader,
+			contextLoader
+		}), null, name);
+	}
+});
+test("verifyRequest() refuses key IDs whose identity URL parsing changes", async () => {
+	const documentLoader = createLoader({ [compatibleId(gw1)]: await sign(await actorJson()) });
+	const request = await signedRequest("draft-cavage-http-signatures-12");
+	const dotted = keyId.href.replace("/actor#", "/x/../actor#");
+	const headers = new Headers(request.headers);
+	headers.set("Signature", headers.get("Signature").replace(keyId.href, dotted));
+	strictEqual(await verifyRequest(new Request(request, { headers }), {
+		documentLoader,
+		contextLoader
+	}), null);
+	strictEqual(documentLoader.fetched.length, 0);
+	const dottedPortable = `${actorId.replace("/actor", "/x/../actor")}#main-key`;
+	for (const id of [
+		dotted,
+		dottedPortable,
+		` ${dotted}`,
+		` ${dottedPortable}`,
+		` ${parseIri(actorId).href}#main-key`,
+		dottedPortable.replace("ap+ef61:", "ap+	ef61:"),
+		dotted.replace("did:key:", "did:ke	y:"),
+		`${gw1}/.well-known/apgateway/${did}/../../../users/alice#main-key`,
+		` ap://not-a-did/actor#main-key`
+	]) {
+		let error;
+		try {
+			await fetchKey(id, CryptographicKey, {
+				documentLoader,
+				contextLoader
+			});
+		} catch (e) {
+			error = e;
+		}
+		ok(error instanceof TypeError, id);
+	}
+});
+const apKeyId = parseIri(`${actorId}#main-key`);
+function hinted(...gateways) {
+	const query = gateways.map((g) => `@gateway=${encodeURIComponent(g)}`).join("&");
+	return parseIri(`${actorId}${query === "" ? "" : `?${query}`}#main-key`);
+}
+async function apActorJson(options = {}) {
+	return await actorJson({
+		key: apKeyId,
+		...options
+	});
+}
+test("verifyRequest() accepts keys of portable actors at ap: key IDs", async () => {
+	const documentLoader = createLoader({ [compatibleId(gw1)]: await sign(await apActorJson()) });
+	const hintedKeyId = hinted(gw1);
+	for (const spec of specs) {
+		const key = await verifyRequest(await signedRequest(spec, hintedKeyId), {
+			documentLoader,
+			contextLoader,
+			spec
+		});
+		ok(key != null, spec);
+		strictEqual(key.id?.href, hintedKeyId.href, spec);
+		strictEqual(key.ownerId?.href, parseIri(actorId).href, spec);
+	}
+	const raw = `ap://${did}/actor?@gateway=${encodeURIComponent(gw1)}#main-key`;
+	for (const written of [raw, raw.replace(/^ap:/, "ap+ef61:")]) {
+		const request = await signedRequest("draft-cavage-http-signatures-12", hintedKeyId);
+		const headers = new Headers(request.headers);
+		headers.set("Signature", headers.get("Signature").replace(hintedKeyId.href, written));
+		strictEqual((await verifyRequest(new Request(request, { headers }), {
+			documentLoader,
+			contextLoader
+		}))?.ownerId?.href, parseIri(actorId).href, written);
+	}
+	deepStrictEqual([...new Set(documentLoader.fetched)], [compatibleId(gw1)]);
+});
+test("verifyRequest() asks the document loader for ap: key IDs without hints", async () => {
+	const documentLoader = createLoader({ [actorId]: await sign(await apActorJson()) });
+	strictEqual((await verifyRequest(await signedRequest(void 0, apKeyId), {
+		documentLoader,
+		contextLoader
+	}))?.ownerId?.href, parseIri(actorId).href);
+	deepStrictEqual(documentLoader.fetched, [actorId]);
+	const result = await verifyRequestDetailed(await signedRequest(void 0, apKeyId), {
+		documentLoader: createLoader({}),
+		contextLoader
+	});
+	ok(!result.verified);
+	strictEqual(result.reason.type, "keyFetchError");
+});
+test("verifyRequest() rejects keys at ap: key IDs that portable actors do not vouch for", async () => {
+	const unsigned = await apActorJson();
+	const ordinaryActorId = "https://gw1.example/users/alice";
+	const cases = {
+		"an unsigned actor document": unsigned,
+		"an actor document signed by another DID": await sign(unsigned, otherKeyPair.privateKey, `${otherDid}#${otherDid.slice(8)}`),
+		"a key missing from both assertionMethod and publicKey": await sign(await apActorJson({
+			assertionMethod: false,
+			publicKey: null
+		})),
+		"a key referred to by URL": await sign({
+			...await apActorJson({
+				publicKey: null,
+				assertionMethod: false
+			}),
+			assertionMethod: [apKeyId.href]
+		}),
+		"a key only in publicKey without an owner": await sign(withoutPublicKeyOwner(await apActorJson({ assertionMethod: false }))),
+		"a publicKey entry with other key material": await sign(await apActorJson({ publicKey: rsaPublicKey3.publicKey })),
+		"a key only at a compatible identifier": await sign(await actorJson()),
+		"an actor without gateways": await sign(await apActorJson({ gateways: [] })),
+		"the document of another actor": await sign(await apActorJson({ id: `${actorId}/other` })),
+		"an ordinary actor": await actorJson({
+			id: ordinaryActorId,
+			key: apKeyId
+		}),
+		"a standalone key": {
+			"@context": "https://w3id.org/security/v1",
+			id: apKeyId.href,
+			type: "Key",
+			owner: actorId,
+			publicKeyPem: await exportSpki(gatewayPublicKey)
+		}
+	};
+	for (const [name, document] of Object.entries(cases)) {
+		const documentLoader = createLoader({ [compatibleId(gw1)]: document });
+		strictEqual(await verifyRequest(await signedRequest(void 0, hinted(gw1)), {
+			documentLoader,
+			contextLoader
+		}), null, name);
+	}
+	const documentLoader = createLoader({ [compatibleId(gw1)]: await sign(await apActorJson()) });
+	strictEqual(await verifyRequest(await signedRequest(void 0, parseIri(`${actorId}?@gateway=${encodeURIComponent(gw1)}`)), {
+		documentLoader,
+		contextLoader
+	}), null);
+	strictEqual(documentLoader.fetched.length, 0);
+});
+test("verifyRequest() tries the gateways of ap: key IDs in order", async () => {
+	const signed = await sign(await apActorJson());
+	const cases = {
+		"an invalid document at the first gateway": {
+			[compatibleId(gw1)]: await apActorJson(),
+			[compatibleId(gw2)]: signed
+		},
+		"an unreachable first gateway": { [compatibleId(gw2)]: signed }
+	};
+	for (const [name, responses] of Object.entries(cases)) {
+		const documentLoader = createLoader(responses);
+		strictEqual((await verifyRequest(await signedRequest(void 0, hinted(gw1, gw2)), {
+			documentLoader,
+			contextLoader
+		}))?.ownerId?.href, parseIri(actorId).href, name);
+		deepStrictEqual(documentLoader.fetched, [compatibleId(gw1), compatibleId(gw2)], name);
+	}
+	const documentLoader = createLoader({
+		[compatibleId(gw1)]: signed,
+		[compatibleId(gw2)]: signed
+	});
+	ok(await verifyRequest(await signedRequest(void 0, hinted(gw1, gw2)), {
+		documentLoader,
+		contextLoader
+	}) != null);
+	deepStrictEqual(documentLoader.fetched, [compatibleId(gw1)]);
+	const gateways = Array.from({ length: 7 }, (_, i) => `https://gw${i + 10}.example`);
+	const many = createLoader({});
+	ok(!(await verifyRequestDetailed(await signedRequest(void 0, hinted(...gateways)), {
+		documentLoader: many,
+		contextLoader
+	})).verified);
+	deepStrictEqual(many.fetched, gateways.slice(0, 3).map((g) => compatibleId(g)));
+	for (const [index, expected] of [[2, true], [3, false]]) {
+		const documentLoader = createLoader({ [compatibleId(gateways[index])]: signed });
+		strictEqual(await verifyRequest(await signedRequest(void 0, hinted(...gateways)), {
+			documentLoader,
+			contextLoader
+		}) != null, expected, `gateway ${index + 1}`);
+		deepStrictEqual(documentLoader.fetched, gateways.slice(0, 3).map((g) => compatibleId(g)), `gateway ${index + 1}`);
+	}
+	const sparse = createLoader({ [compatibleId(gateways[2])]: signed });
+	ok(await verifyRequest(await signedRequest(void 0, hinted("not a gateway", gateways[0], gateways[0].toUpperCase(), "https://gw.example/path", gateways[1], gateways[2])), {
+		documentLoader: sparse,
+		contextLoader
+	}) != null);
+	deepStrictEqual(sparse.fetched, gateways.slice(0, 3).map((g) => compatibleId(g)));
+});
+function failingLoader(responses) {
+	const fetched = [];
+	const loader = (url) => {
+		fetched.push(url);
+		const response = responses[url.replace(/#.*$/, "")] ?? 404;
+		if (typeof response === "number") return Promise.reject(new FetchError(url, `HTTP ${response}`, new Response(null, { status: response })));
+		return Promise.resolve({
+			contextUrl: null,
+			documentUrl: url,
+			document: structuredClone(response)
+		});
+	};
+	return Object.assign(loader, { fetched });
+}
+test("verifyRequest() reports why keys at ap: key IDs could not be looked up", async () => {
+	const hintedKeyId = hinted(gw1, gw2);
+	const invalid = await apActorJson();
+	const cases = [
+		{
+			name: "every gateway serves an invalid document",
+			responses: {
+				[compatibleId(gw1)]: invalid,
+				[compatibleId(gw2)]: invalid
+			},
+			reason: "invalidSignature",
+			cached: true
+		},
+		{
+			name: "every gateway responds with 410 Gone",
+			responses: {
+				[compatibleId(gw1)]: 410,
+				[compatibleId(gw2)]: 410
+			},
+			reason: "keyFetchError",
+			status: 410,
+			cached: true
+		},
+		{
+			name: "the gateways respond with different statuses",
+			responses: {
+				[compatibleId(gw1)]: 404,
+				[compatibleId(gw2)]: 503
+			},
+			reason: "keyFetchError",
+			cached: true
+		},
+		{
+			name: "one gateway serves an invalid document, the other is gone",
+			responses: {
+				[compatibleId(gw1)]: invalid,
+				[compatibleId(gw2)]: 410
+			},
+			reason: "keyFetchError",
+			cached: false
+		}
+	];
+	for (const { name, responses, reason, status, cached } of cases) for (const spec of specs) {
+		const documentLoader = failingLoader(responses);
+		const keyCache = new KvKeyCache(new MemoryKvStore(), ["pk"]);
+		const options = {
+			documentLoader,
+			contextLoader,
+			keyCache,
+			spec
+		};
+		for (let i = 0; i < 2; i++) {
+			const result = await verifyRequestDetailed(await signedRequest(spec, hintedKeyId), options);
+			ok(!result.verified, `${name}, ${spec}`);
+			strictEqual(result.reason.type, reason, `${name}, ${spec}`);
+			if (result.reason.type === "keyFetchError") strictEqual("status" in result.reason.result ? result.reason.result.status : void 0, status, `${name}, ${spec}`);
+		}
+		strictEqual(documentLoader.fetched.length, cached ? 2 : 4, `${name}, ${spec}`);
+	}
+});
+test("verifyRequest() accepts keys at ap: key IDs only for HTTP Signatures", async () => {
+	const documentLoader = createLoader({ [compatibleId(gw1)]: await sign(await apActorJson()) });
+	const hintedKeyId = hinted(gw1);
+	const keyCache = new KvKeyCache(new MemoryKvStore(), ["pk"]);
+	const options = {
+		documentLoader,
+		contextLoader,
+		keyCache
+	};
+	for (const cls of [CryptographicKey, Multikey]) strictEqual((cls === CryptographicKey ? await fetchKey(hintedKeyId, CryptographicKey, options) : await fetchKey(hintedKeyId, Multikey, options)).key, null);
+	strictEqual(documentLoader.fetched.length, 0);
+	for (let i = 0; i < 3; i++) {
+		const key = await verifyRequest(await signedRequest(void 0, hintedKeyId), options);
+		strictEqual(key?.id?.href, hintedKeyId.href);
+		strictEqual(key?.ownerId?.href, parseIri(actorId).href);
+	}
+	strictEqual(documentLoader.fetched.length, 1);
+	for (const cls of [CryptographicKey, Multikey]) strictEqual((cls === CryptographicKey ? await fetchKey(hintedKeyId, CryptographicKey, options) : await fetchKey(hintedKeyId, Multikey, options)).key, null);
+	const document = {
+		"@context": "https://www.w3.org/ns/activitystreams",
+		type: "Create",
+		id: "https://gw1.example/activities/1",
+		actor: compatibleId(gw1)
+	};
+	const { signature } = await signJsonLd(document, rsaPrivateKey2, hintedKeyId, { contextLoader });
+	ok(!await verifyJsonLd({
+		...document,
+		signature
+	}, options));
+	strictEqual(documentLoader.fetched.length, 1);
+	const legacyCache = {
+		get: () => Promise.resolve(new CryptographicKey({
+			id: hintedKeyId,
+			owner: parseIri(actorId),
+			publicKey: gatewayPublicKey
+		})),
+		set: () => Promise.resolve()
+	};
+	const empty = createLoader({});
+	strictEqual(await verifyRequest(await signedRequest(void 0, hintedKeyId), {
+		documentLoader: empty,
+		contextLoader,
+		keyCache: legacyCache
+	}), null);
+	strictEqual(empty.fetched.length, 1);
+});
+test("verifyRequest() refreshes a cached key at an ap: key ID that fails to verify", async () => {
+	for (const spec of specs) {
+		const responses = { [compatibleId(gw1)]: await sign(await apActorJson()) };
+		const documentLoader = failingLoader(responses);
+		const hintedKeyId = hinted(gw1, gw2);
+		const keyCache = new KvKeyCache(new MemoryKvStore(), ["pk"]);
+		const options = {
+			documentLoader,
+			contextLoader,
+			keyCache,
+			spec
+		};
+		ok(await verifyRequest(await signedRequest(spec, hintedKeyId), options) != null);
+		strictEqual(documentLoader.fetched.length, 1, spec);
+		responses[compatibleId(gw1)] = await apActorJson();
+		responses[compatibleId(gw2)] = 503;
+		ok(!(await verifyRequestDetailed(await signRequest(new Request("https://recipient.example/inbox", {
+			method: "POST",
+			body: "{}",
+			headers: { "Content-Type": "application/activity+json" }
+		}), rsaPrivateKey3, hintedKeyId, { spec }), options)).verified, spec);
+		strictEqual(documentLoader.fetched.length, 3, spec);
+		const next = await verifyRequestDetailed(await signedRequest(spec, hintedKeyId), options);
+		ok(!next.verified, spec);
+		strictEqual(next.reason.type, "keyFetchError", spec);
+		strictEqual(documentLoader.fetched.length, 5, spec);
+	}
+});
+test("doesActorOwnKey() and getKeyOwner() resolve keys at ap: key IDs to portable actors", async () => {
+	const options = {
+		documentLoader: createLoader({ [compatibleId(gw1)]: await sign(await apActorJson()) }),
+		contextLoader
+	};
+	const hintedKeyId = hinted(gw1);
+	const key = new CryptographicKey({
+		id: hintedKeyId,
+		owner: parseIri(actorId),
+		publicKey: gatewayPublicKey
+	});
+	const activity = new Create({
+		id: parseIri(`${actorId.replace("/actor", "")}/activities/1`),
+		actor: parseIri(`ap://${did}/actor`)
+	});
+	ok(await doesActorOwnKey(activity, key, options));
+	strictEqual((await getKeyOwner(hintedKeyId, options))?.id?.href, parseIri(actorId).href);
+	strictEqual((await getKeyOwner(key, options))?.id?.href, parseIri(actorId).href);
+	ok(!await doesActorOwnKey(new Create({
+		id: parseIri(`ap+ef61://${otherDid}/activities/1`),
+		actor: parseIri(`ap+ef61://${otherDid}/actor`)
+	}), key, options));
+	const other = key.clone({ publicKey: rsaPublicKey3.publicKey });
+	ok(!await doesActorOwnKey(activity, other, options));
+	strictEqual(await getKeyOwner(other, options), null);
+	const unsigned = {
+		documentLoader: createLoader({ [compatibleId(gw1)]: await apActorJson() }),
+		contextLoader
+	};
+	ok(!await doesActorOwnKey(activity, key, unsigned));
+	strictEqual(await getKeyOwner(hintedKeyId, unsigned), null);
+});
+test("verifyRequest() does not trust a cached key at an ap: key ID for longer than its proof", async () => {
+	let now = Temporal.Now.instant();
+	const keyCache = new KvKeyCache(new MemoryKvStore(), ["pk"], { now: () => now });
+	const expires = now.add({ minutes: 30 });
+	const documentLoader = createLoader({ [compatibleId(gw1)]: await sign(await apActorJson(), ed25519PrivateKey, didKeyId, { expires: expires.toString() }) });
+	const options = {
+		documentLoader,
+		contextLoader,
+		keyCache
+	};
+	const hintedKeyId = hinted(gw1);
+	ok(await verifyRequest(await signedRequest(void 0, hintedKeyId), options) != null);
+	now = expires.subtract({ seconds: 1 });
+	ok(await verifyRequest(await signedRequest(void 0, hintedKeyId), options) != null);
+	strictEqual(documentLoader.fetched.length, 1);
+	now = expires;
+	ok(await verifyRequest(await signedRequest(void 0, hintedKeyId), options) != null);
+	strictEqual(documentLoader.fetched.length, 2);
+});
+test("verifyRequest() does not cache keys at ap: key IDs it could not process", async () => {
+	let failures = 1;
+	const flakyContextLoader = (url, options) => {
+		if (failures > 0) {
+			failures--;
+			return Promise.reject(/* @__PURE__ */ new Error(`Temporarily failed to load ${url}`));
+		}
+		return contextLoader(url, options);
+	};
+	const documentLoader = createLoader({ [compatibleId(gw1)]: await sign(await apActorJson()) });
+	const options = {
+		documentLoader,
+		contextLoader: flakyContextLoader,
+		keyCache: new KvKeyCache(new MemoryKvStore(), ["pk"])
+	};
+	const hintedKeyId = hinted(gw1);
+	const result = await verifyRequestDetailed(await signedRequest(void 0, hintedKeyId), options);
+	ok(!result.verified);
+	strictEqual(result.reason.type, "keyFetchError");
+	if (result.reason.type === "keyFetchError") ok(!("status" in result.reason.result));
+	strictEqual((await verifyRequest(await signedRequest(void 0, hintedKeyId), options))?.ownerId?.href, parseIri(actorId).href);
+	strictEqual(documentLoader.fetched.length, 2);
+});
+/**
+* A loader that serves the given responses, and never responds for the URLs
+* in `hanging`.  A hanging response is given up when its signal aborts,
+* unless `ignoreSignal` is set.
+*/
+function controlledLoader(responses, hanging, { ignoreSignal = false, delays = {} } = {}) {
+	const fetched = [];
+	const signals = [];
+	const respond = failingLoader(responses);
+	const loader = async (url, options) => {
+		fetched.push(url);
+		signals.push(options?.signal);
+		const signal = ignoreSignal ? void 0 : options?.signal;
+		const delay = delays[url];
+		if (delay != null) await new Promise((resolve) => setTimeout(resolve, delay));
+		if (hanging.includes(url)) return await new Promise((_, reject) => {
+			signal?.addEventListener("abort", () => reject(signal.reason));
+		});
+		return await respond(url);
+	};
+	return Object.assign(loader, {
+		fetched,
+		signals
+	});
+}
+function isTimeoutError(error) {
+	return error instanceof DOMException && error.name === "TimeoutError";
+}
+test("resolvePortableActorKey() gives up gateways that do not respond in time", async () => {
+	const signed = await sign(await apActorJson());
+	for (const ignoreSignal of [false, true]) {
+		const documentLoader = controlledLoader({ [compatibleId(gw2)]: signed }, [compatibleId(gw1)], { ignoreSignal });
+		const resolution = await resolvePortableActorKey(hinted(gw1, gw2), {
+			documentLoader,
+			contextLoader,
+			lookupTimeout: 50
+		});
+		strictEqual(resolution.type, "unavailable", `ignoreSignal: ${ignoreSignal}`);
+		if (resolution.type === "unavailable") strictEqual(resolution.cacheable, false);
+		deepStrictEqual(documentLoader.fetched, [compatibleId(gw1)]);
+		const [signal] = documentLoader.signals;
+		ok(signal?.aborted);
+		ok(isTimeoutError(signal.reason));
+	}
+});
+test("resolvePortableActorKey() caches timeouts only as failures to fetch", async () => {
+	const invalid = await apActorJson();
+	const cases = [
+		{
+			name: "the only gateway times out",
+			responses: {},
+			hanging: [compatibleId(gw1)],
+			hints: [gw1],
+			cacheable: true
+		},
+		{
+			name: "a gateway responds with 404, and the last one times out",
+			responses: { [compatibleId(gw1)]: 404 },
+			hanging: [compatibleId(gw2)],
+			hints: [gw1, gw2],
+			cacheable: true
+		},
+		{
+			name: "a gateway serves an invalid document, and the last one times out",
+			responses: { [compatibleId(gw1)]: invalid },
+			hanging: [compatibleId(gw2)],
+			hints: [gw1, gw2],
+			cacheable: false
+		},
+		{
+			name: "the document loader cannot resolve the ap: URI in time",
+			responses: {},
+			hanging: [actorId],
+			hints: [],
+			cacheable: true
+		}
+	];
+	for (const { name, responses, hanging, hints, cacheable } of cases) {
+		const documentLoader = controlledLoader(responses, hanging);
+		const resolution = await resolvePortableActorKey(hinted(...hints), {
+			documentLoader,
+			contextLoader,
+			lookupTimeout: 50
+		});
+		strictEqual(resolution.type, "unavailable", name);
+		if (resolution.type !== "unavailable") continue;
+		strictEqual(resolution.cacheable, cacheable, name);
+		ok(!(resolution.error instanceof FetchError), name);
+		if (hanging.length === 1 && hints.length < 2) ok(isTimeoutError(resolution.error), name);
+	}
+});
+test("resolvePortableActorKey() shares one timeout among all gateways", async () => {
+	const documentLoader = controlledLoader({ [compatibleId(gw1)]: 404 }, [compatibleId(gw2)], { delays: { [compatibleId(gw1)]: 250 } });
+	const started = Date.now();
+	const resolution = await resolvePortableActorKey(hinted(gw1, gw2), {
+		documentLoader,
+		contextLoader,
+		lookupTimeout: 300
+	});
+	const elapsed = Date.now() - started;
+	ok(elapsed < 500, `took ${elapsed} ms`);
+	strictEqual(resolution.type, "unavailable");
+	deepStrictEqual(documentLoader.fetched, [compatibleId(gw1), compatibleId(gw2)]);
+	ok(documentLoader.signals[1]?.aborted);
+});
+test("resolvePortableActorKey() bounds loading the contexts of actor documents", async () => {
+	const documentLoader = controlledLoader({ [compatibleId(gw1)]: await sign(await apActorJson()) }, []);
+	const hangingContextLoader = (_url, options) => new Promise((_, reject) => {
+		options?.signal?.addEventListener("abort", () => reject(options.signal.reason));
+	});
+	const resolution = await resolvePortableActorKey(hinted(gw1, gw2), {
+		documentLoader,
+		contextLoader: hangingContextLoader,
+		lookupTimeout: 50
+	});
+	strictEqual(resolution.type, "unavailable");
+	if (resolution.type === "unavailable") strictEqual(resolution.cacheable, false);
+	deepStrictEqual(documentLoader.fetched, [compatibleId(gw1)]);
+});
+test("resolvePortableActorKey() ignores what is resolved after the timeout", async () => {
+	let verifiedLate = () => {};
+	const late = new Promise((resolve) => verifiedLate = resolve);
+	let lookupDone = () => {};
+	const done = new Promise((resolve) => lookupDone = resolve);
+	const slowKeyCache = {
+		async get() {
+			await done;
+		},
+		set() {
+			verifiedLate();
+			return Promise.resolve();
+		}
+	};
+	const documentLoader = controlledLoader({ [compatibleId(gw1)]: await sign(await apActorJson()) }, []);
+	const resolution = await resolvePortableActorKey(hinted(gw1), {
+		documentLoader,
+		contextLoader,
+		keyCache: slowKeyCache,
+		lookupTimeout: 300
+	});
+	lookupDone();
+	strictEqual(resolution.type, "unavailable");
+	if (resolution.type === "unavailable") strictEqual(resolution.cacheable, false);
+	await late;
+	const lateRejection = controlledLoader({}, [], { delays: { [compatibleId(gw1)]: 60 } });
+	strictEqual((await resolvePortableActorKey(hinted(gw1), {
+		documentLoader: lateRejection,
+		contextLoader,
+		lookupTimeout: 20
+	})).type, "unavailable");
+	await new Promise((resolve) => setTimeout(resolve, 80));
+});
+test("resolvePortableActorKey() validates the lookup timeout", async () => {
+	const documentLoader = controlledLoader({}, []);
+	for (const lookupTimeout of [
+		-1,
+		NaN,
+		Infinity,
+		2 ** 31
+	]) {
+		let error;
+		try {
+			await resolvePortableActorKey(hinted(gw1), {
+				documentLoader,
+				contextLoader,
+				lookupTimeout
+			});
+		} catch (e) {
+			error = e;
+		}
+		ok(error instanceof RangeError, String(lookupTimeout));
+	}
+	const resolution = await resolvePortableActorKey(hinted(gw1), {
+		documentLoader,
+		contextLoader,
+		lookupTimeout: 0
+	});
+	strictEqual(resolution.type, "unavailable");
+	if (resolution.type === "unavailable") strictEqual(resolution.cacheable, false);
+	deepStrictEqual(documentLoader.fetched, []);
+});
+test("fetchKeyDetailed() caches keys at ap: key IDs that time out as fetch failures", async () => {
+	const cases = [{
+		responses: { [compatibleId(gw1)]: 404 },
+		hanging: [compatibleId(gw2)],
+		cached: true
+	}, {
+		responses: {},
+		hanging: [compatibleId(gw1)],
+		cached: false
+	}];
+	for (const { responses, hanging, cached } of cases) {
+		const documentLoader = controlledLoader(responses, hanging);
+		const keyCache = new KvKeyCache(new MemoryKvStore(), ["pk"]);
+		const options = {
+			documentLoader,
+			contextLoader,
+			keyCache,
+			portableKeyResolvers: {
+				gatewayKey: () => Promise.resolve({ type: "legacy" }),
+				actorKey: (keyId) => resolvePortableActorKey(keyId, {
+					documentLoader,
+					contextLoader,
+					lookupTimeout: 50
+				})
+			}
+		};
+		const hintedKeyId = hinted(gw1, gw2);
+		for (let i = 0; i < 2; i++) {
+			const result = await fetchKeyDetailed(hintedKeyId, CryptographicKey, options);
+			strictEqual(result.key, null);
+			strictEqual(result.cached, cached && i > 0, `${cached}, ${i}`);
+			ok(result.fetchError == null || !("status" in result.fetchError), "a timeout has no HTTP status");
+		}
+		strictEqual(documentLoader.fetched.filter((url) => url === compatibleId(gw1)).length, cached ? 1 : 2);
+	}
+});
+test("verifyRequestDetailed() reports keys at ap: key IDs that time out as fetch errors", async () => {
+	const timeout = new DOMException("Timed out", "TimeoutError");
+	const documentLoader = () => Promise.reject(timeout);
+	for (const spec of specs) {
+		const result = await verifyRequestDetailed(await signedRequest(spec, hinted(gw1)), {
+			documentLoader,
+			contextLoader,
+			spec
+		});
+		ok(!result.verified, spec);
+		strictEqual(result.reason.type, "keyFetchError", spec);
+		if (result.reason.type === "keyFetchError") ok(!("status" in result.reason.result), spec);
+	}
+});
+//#endregion
+export {};