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

package/dist/{http-CPVMUgsW.mjs → http-siciWkmx.mjs}

@@ -1,10 +1,14 @@
 import { Temporal } from "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as version, t as name } from "./deno-BHzKn9Ig.mjs";
-import { n as getDurationMs, r as getFederationMetrics, s as measureSignatureKeyFetch } from "./metrics-DMk-nTxI.mjs";
-import { i as validateAcceptSignature, n as fulfillAcceptSignature, r as parseAcceptSignature } from "./accept-8PiolDP7.mjs";
-import { o as validateCryptoKey, r as fetchKeyDetailed } from "./key-DfPsX8hv.mjs";
+import { m as parseKeyIdString } from "./portable-key-id-Ca30-hOa.mjs";
+import { a as verificationObservation, i as triedKey, n as observeCheck, t as observeAttempt } from "./verification-Dpfcw8ml.mjs";
+import { n as version, t as name } from "./deno-oR5aJKpU.mjs";
+import { n as getDurationMs, r as getFederationMetrics, s as measureSignatureKeyFetch } from "./metrics-CYg9yxBL.mjs";
+import { i as validateAcceptSignature, n as fulfillAcceptSignature, r as parseAcceptSignature } from "./accept-CPVqki78.mjs";
+import { a as promoteKeyOwnerEvidence } from "./key-owner-evidence-APB6NpSk.mjs";
+import { a as fetchKeyDetailed, c as validateCryptoKey, t as bypassKeyCacheReads } from "./key-BspPiXqn.mjs";
+import { n as resolvePortableActorKey, r as verifyPortableGatewayKeyDocument } from "./portable-key-BIMLrAP4.mjs";
 import { getLogger } from "@logtape/logtape";
 import { CryptographicKey } from "@fedify/vocab";
 import { SpanStatusCode, trace } from "@opentelemetry/api";
@@ -12,7 +16,7 @@ import { FetchError } from "@fedify/vocab-runtime";
 import { ATTR_HTTP_REQUEST_HEADER, ATTR_HTTP_REQUEST_METHOD, ATTR_URL_FULL } from "@opentelemetry/semantic-conventions";
 import { decodeBase64, encodeBase64 } from "byte-encodings/base64";
 import { encodeHex } from "byte-encodings/hex";
-import { Item, decodeDict, encodeItem } from "structured-field-values";
+import { Item, decodeDict, encodeDict, encodeItem } from "structured-field-values";
 //#region src/sig/http.ts
 const DEFAULT_MAX_REDIRECTION = 20;
 const DOUBLE_KNOCK_TRANSPORT_RETRY_DELAY_MS = 100;
@@ -201,6 +205,84 @@ function parseRfc9421Signature(signature) {
 	for (const [key, value] of Object.entries(dict)) if (value.value instanceof Uint8Array) result[key] = value.value;
 	return result;
 }
+/**
+* Parses the `Signature` header of draft-cavage HTTP Signatures into its
+* fields, e.g., `keyId` and `headers`.
+*/
+function parseDraftSignature(signature) {
+	return Object.fromEntries(signature.split(",").map((pair) => pair.match(/^\s*([A-Za-z]+)=(?:"([^"]*)"|(\d+))\s*$/)).filter((m) => m != null).map((m) => [m[1], m[2] ?? m[3]]));
+}
+/**
+* Lists the HTTP Signatures that a request claims to carry, without verifying
+* any of them.  Signatures whose key IDs are not URLs are left out.
+* @param request The request.
+* @param maxSignatures The maximum number of RFC 9421 signatures to consider,
+*                      counted the same way as by {@link verifyRequest}, so
+*                      that the signatures it ignores are not listed either.
+* @returns The signatures; RFC 9421 ones if the request has
+*          a `Signature-Input` header, or a draft-cavage one otherwise.
+* @internal
+*/
+function listRequestSignatures(request, maxSignatures = 3) {
+	const signatureInput = request.headers.get("Signature-Input");
+	if (signatureInput != null) {
+		const signatures = [];
+		const inputs = Object.entries(parseRfc9421SignatureInput(signatureInput));
+		for (const [label, input] of inputs.slice(0, maxSignatures)) {
+			const keyId = parseKeyId(input.keyId);
+			if (keyId == null) continue;
+			signatures.push({
+				keyId,
+				label,
+				components: input.components
+			});
+		}
+		return signatures;
+	}
+	const signature = request.headers.get("Signature");
+	if (signature == null) return [];
+	const values = parseDraftSignature(signature);
+	const keyId = parseKeyId(values.keyId);
+	if (keyId == null) return [];
+	return [{
+		keyId,
+		label: null,
+		components: (values.headers ?? "").split(/\s+/g).filter((name) => name !== "").map((name) => ({
+			value: name,
+			params: {}
+		}))
+	}];
+}
+/**
+* Makes a copy of a request that carries only one of its RFC 9421 signatures,
+* so that verifying the copy verifies that signature and no other.
+* A draft-cavage signature is the only one in its request, so the request is
+* just copied.
+* @param request The request, whose body must not be consumed.
+* @param signature One of the signatures that {@link listRequestSignatures}
+*                  lists for the request.
+* @returns The copy of the request.
+* @internal
+*/
+function selectRequestSignature(request, signature) {
+	const copy = request.clone();
+	if (signature.label == null) return copy;
+	const { label } = signature;
+	const pick = (header) => {
+		if (header == null) return "";
+		let dict;
+		try {
+			dict = decodeDict(header);
+		} catch {
+			return "";
+		}
+		return Object.hasOwn(dict, label) ? encodeDict({ [label]: dict[label] }) : "";
+	};
+	const headers = new Headers(copy.headers);
+	headers.set("Signature-Input", pick(headers.get("Signature-Input")));
+	headers.set("Signature", pick(headers.get("Signature")));
+	return new Request(copy, { headers });
+}
 async function signRequestRfc9421(request, privateKey, keyId, span, currentTime, bodyBuffer, rfc9421Options) {
 	if (privateKey.algorithm.name !== "RSASSA-PKCS1-v1_5") throw new TypeError("Unsupported algorithm: " + privateKey.algorithm.name);
 	const url = new URL(request.url);
@@ -274,6 +356,18 @@ async function signRequestRfc9421(request, privateKey, keyId, span, currentTime,
 		body
 	});
 }
+/**
+* Checks that a maximum number of signatures to verify is a positive safe
+* integer or `Infinity`.
+* @param value The value to check.
+* @param name The name of the option, used in the error message.
+* @throws {RangeError} Thrown if the value is not valid.
+* @internal
+*/
+function validateMaxSignatures(value, name) {
+	if (value === Infinity || Number.isSafeInteger(value) && value >= 1) return;
+	throw new RangeError(`${name} must be a positive integer or Infinity.`);
+}
 const supportedHashAlgorithms = {
 	"sha": "SHA-1",
 	"sha-256": "SHA-256",
@@ -307,13 +401,18 @@ function keyFetchErrorResult(keyId, result) {
 		}
 	};
 }
+/**
+* Creates the resolvers of keys of FEP-ef61 portable actors, which HTTP
+* Signature verification alone passes to key lookups.
+*/
+function createPortableKeyResolvers(options) {
+	return {
+		gatewayKey: (document, actor, keyId) => verifyPortableGatewayKeyDocument(document, actor, keyId, options),
+		actorKey: (keyId) => resolvePortableActorKey(keyId, options)
+	};
+}
 function parseKeyId(value) {
-	if (value == null) return null;
-	try {
-		return new URL(value);
-	} catch {
-		return null;
-	}
+	return value == null ? null : parseKeyIdString(value);
 }
 function getKeyFetchErrorName(error) {
 	return error.name || error.constructor.name || "Error";
@@ -325,7 +424,7 @@ function getKeyFetchErrorName(error) {
 * algorithm, so unknown values are dropped from the metric to prevent
 * cardinality blow-up.
 */
-const DRAFT_KNOWN_ALGORITHMS = new Set([
+const DRAFT_KNOWN_ALGORITHMS = /* @__PURE__ */ new Set([
 	"ecdsa-sha256",
 	"ecdsa-sha384",
 	"ecdsa-sha512",
@@ -361,6 +460,8 @@ function recordVerificationResult(span, result) {
 * @param options Options for verifying the request.
 * @returns The public key of the verified signature, or `null` if the signature
 *          could not be verified.
+* @throws {RangeError} Thrown if {@link VerifyRequestOptions.maxSignatures}
+*         is not a positive integer or `Infinity`.
 */
 async function verifyRequest(request, options = {}) {
 	const result = await verifyRequestDetailed(request, options);
@@ -373,9 +474,20 @@ async function verifyRequest(request, options = {}) {
 * @param request The request to verify.
 * @param options Options for verifying the request.
 * @returns The verified public key, or a structured verification failure.
+* @throws {RangeError} Thrown if {@link VerifyRequestOptions.maxSignatures}
+*         is not a positive integer or `Infinity`.
 * @since 2.1.0
 */
 async function verifyRequestDetailed(request, options = {}) {
+	if (options[verificationObservation] != null && options[verificationObservation]?.attempt == null) return await observeAttempt(options, "http", async (observation) => {
+		const result = await verifyRequestDetailed(request, {
+			...options,
+			[verificationObservation]: observation
+		});
+		if (!result.verified) observation.attempt.reason = result.reason.type === "noSignature" ? { type: "noSignature" } : { type: "signatureVerificationFailed" };
+		return result;
+	}, (result) => result.verified);
+	if (options.maxSignatures !== void 0) validateMaxSignatures(options.maxSignatures, "maxSignatures");
 	return await (options.tracerProvider ?? trace.getTracerProvider()).getTracer(name, version).startActiveSpan("http_signatures.verify", async (span) => {
 		if (span.isRecording()) {
 			span.setAttribute(ATTR_HTTP_REQUEST_METHOD, request.method);
@@ -392,7 +504,8 @@ async function verifyRequestDetailed(request, options = {}) {
 			if (spec === "rfc9421") result = await verifyRequestRfc9421(request, span, metricsContext, options);
 			else result = await verifyRequestDraft(request, span, metricsContext, options);
 			recordVerificationResult(span, result);
-			if (!result.verified) span.setStatus({ code: SpanStatusCode.ERROR });
+			if (result.verified) promoteKeyOwnerEvidence(result.key);
+			else span.setStatus({ code: SpanStatusCode.ERROR });
 			return result;
 		} catch (error) {
 			threw = true;
@@ -412,7 +525,27 @@ async function verifyRequestDetailed(request, options = {}) {
 		}
 	});
 }
-async function verifyRequestDraft(request, span, metricsContext, { documentLoader, contextLoader, timeWindow, currentTime, keyCache, meterProvider, tracerProvider } = {}) {
+async function verifyRequestDraft(request, span, metricsContext, options = {}) {
+	if (options[verificationObservation]?.check != null) return await verifyRequestDraftInternal(request, span, metricsContext, options);
+	let result = noSignatureResult();
+	const raw = request.headers.get("Signature");
+	const declared = raw == null ? null : parseDraftSignature(raw)?.keyId ?? null;
+	if (raw == null) return result;
+	await observeCheck(options, {
+		mechanism: "http",
+		spec: "draft-cavage-http-signatures-12",
+		label: null
+	}, declared, async (observation) => {
+		result = await verifyRequestDraftInternal(request, span, metricsContext, {
+			...options,
+			[verificationObservation]: observation
+		});
+		if (!result.verified && result.reason.type === "keyFetchError" && observation.check != null) observation.check.reason = result.reason;
+		return result.verified ? result.key : null;
+	});
+	return result;
+}
+async function verifyRequestDraftInternal(request, span, metricsContext, { documentLoader, contextLoader, timeWindow, currentTime, keyCache, meterProvider, tracerProvider, [verificationObservation]: observation } = {}) {
 	const logger = getLogger([
 		"fedify",
 		"sig",
@@ -432,7 +565,7 @@ async function verifyRequestDraft(request, span, metricsContext, { documentLoade
 		logger.debug("Failed to verify; no Signature header found.", { headers: Object.fromEntries(request.headers.entries()) });
 		return noSignatureResult();
 	}
-	const sigValues = Object.fromEntries(sigHeader.split(",").map((pair) => pair.match(/^\s*([A-Za-z]+)=(?:"([^"]*)"|(\d+))\s*$/)).filter((m) => m != null).map((m) => [m[1], m[2] ?? m[3]]));
+	const sigValues = parseDraftSignature(sigHeader);
 	const parsedKeyId = parseKeyId(sigValues.keyId);
 	const dateHeader = request.headers.get("Date");
 	if (dateHeader == null) {
@@ -570,7 +703,14 @@ async function verifyRequestDraft(request, span, metricsContext, { documentLoade
 		contextLoader,
 		keyCache,
 		tracerProvider,
-		meterProvider
+		meterProvider,
+		portableKeyResolvers: createPortableKeyResolvers({
+			documentLoader,
+			contextLoader,
+			keyCache,
+			tracerProvider,
+			meterProvider
+		})
 	}));
 	if (fetchError != null) return keyFetchErrorResult(keyIdUrl, fetchError);
 	if (key == null) return invalidSignatureResult(keyIdUrl);
@@ -586,6 +726,7 @@ async function verifyRequestDraft(request, span, metricsContext, { documentLoade
 	const message = headerNames.map((name) => `${name}: ` + (name === "(request-target)" ? `${request.method.toLowerCase()} ${new URL(request.url).pathname}` : name === "(created)" ? sigValues.created ?? "" : name === "(expires)" ? sigValues.expires ?? "" : name === "host" ? request.headers.get("host") ?? new URL(request.url).host : request.headers.get(name))).join("\n");
 	const sig = decodeBase64(signature);
 	span?.setAttribute("http_signatures.signature", encodeHex(sig));
+	triedKey({ [verificationObservation]: observation }, key);
 	if (!await crypto.subtle.verify("RSASSA-PKCS1-v1_5", key.publicKey, sig, new TextEncoder().encode(message))) {
 		if (cached) {
 			logger.debug("Failed to verify with the cached key {keyId}; signature {signature} is invalid.  Retrying with the freshly fetched key...", {
@@ -598,12 +739,10 @@ async function verifyRequestDraft(request, span, metricsContext, { documentLoade
 				contextLoader,
 				timeWindow,
 				currentTime,
-				keyCache: {
-					get: () => Promise.resolve(void 0),
-					set: async (keyId, key) => await keyCache?.set(keyId, key)
-				},
+				keyCache: bypassKeyCacheReads(keyCache),
 				meterProvider,
-				tracerProvider
+				tracerProvider,
+				[verificationObservation]: observation
 			});
 		}
 		logger.debug("Failed to verify with the fetched key {keyId}; signature {signature} is invalid.  Check if the key is correct or if the signed message is correct.  The message to sign is:\n{message}", {
@@ -679,7 +818,101 @@ async function verifyRfc9421ContentDigest(digestHeader, body) {
 	}
 	return false;
 }
-async function verifyRequestRfc9421(request, span, metricsContext, { documentLoader, contextLoader, timeWindow, currentTime, keyCache, meterProvider, tracerProvider } = {}) {
+/**
+* Verifies one RFC 9421 signature of a request with a key.
+* @param request The request, whose body may be consumed already.
+* @param sigInput The parsed `Signature-Input` member of the signature.
+* @param sigBytes The bytes of the signature.
+* @param key The public key named by the signature.
+* @param span The span to record the algorithm and the signature on.
+* @returns Whether the signature is verified, and the algorithm of the
+*          signature if it is supported.
+*/
+async function verifyRfc9421SignatureWithKey(request, sigInput, sigBytes, key, span, observationOptions = {}) {
+	const logger = getLogger([
+		"fedify",
+		"sig",
+		"http"
+	]);
+	let alg = sigInput.alg?.toLowerCase();
+	if (alg == null) {
+		if (key.publicKey.algorithm.name === "RSASSA-PKCS1-v1_5") alg = "hash" in key.publicKey.algorithm ? key.publicKey.algorithm.hash === "SHA-512" ? "rsa-v1_5-sha512" : "rsa-v1_5-sha256" : "rsa-v1_5-sha256";
+		else if (key.publicKey.algorithm.name === "RSA-PSS") alg = "rsa-pss-sha512";
+		else if (key.publicKey.algorithm.name === "ECDSA") alg = "namedCurve" in key.publicKey.algorithm && key.publicKey.algorithm.namedCurve === "P-256" ? "ecdsa-p256-sha256" : "ecdsa-p384-sha384";
+		else if (key.publicKey.algorithm.name === "Ed25519") alg = "ed25519";
+	}
+	if (alg) span?.setAttribute("http_signatures.algorithm", alg);
+	const algorithm = alg && rfc9421AlgorithmMap[alg];
+	if (!algorithm) {
+		logger.debug("Failed to verify; unsupported algorithm: {algorithm}", {
+			algorithm: sigInput.alg,
+			supported: Object.keys(rfc9421AlgorithmMap)
+		});
+		return {
+			verified: false,
+			mismatched: false
+		};
+	}
+	const metricAlgorithm = alg;
+	let signatureBase;
+	try {
+		signatureBase = createRfc9421SignatureBase(request, sigInput.components, sigInput.parameters);
+	} catch (error) {
+		logger.debug("Failed to create signature base for verification: {error}", {
+			error,
+			signatureInput: sigInput
+		});
+		return {
+			verified: false,
+			algorithm: metricAlgorithm,
+			mismatched: false
+		};
+	}
+	const signatureBaseBytes = new TextEncoder().encode(signatureBase);
+	span?.setAttribute("http_signatures.signature", encodeHex(sigBytes));
+	const algorithmName = typeof algorithm === "string" ? algorithm : algorithm.name;
+	if (key.publicKey.algorithm.name !== algorithmName) {
+		logger.debug("Failed to verify; key {keyId} is not a key for algorithm {algorithm}.", {
+			keyId: sigInput.keyId,
+			algorithm: alg
+		});
+		return {
+			verified: false,
+			algorithm: metricAlgorithm,
+			mismatched: true
+		};
+	}
+	let verified;
+	try {
+		triedKey(observationOptions, key);
+		verified = await crypto.subtle.verify(algorithm, key.publicKey, sigBytes.slice(), signatureBaseBytes);
+	} catch (error) {
+		logger.debug("Error during signature verification: {error}", {
+			error,
+			keyId: sigInput.keyId,
+			algorithm: sigInput.alg
+		});
+		return {
+			verified: false,
+			algorithm: metricAlgorithm,
+			mismatched: false
+		};
+	}
+	if (verified) return {
+		verified: true,
+		algorithm: metricAlgorithm
+	};
+	logger.debug("Failed to verify signature with key {keyId}; signature invalid.", {
+		keyId: sigInput.keyId,
+		signatureBase
+	});
+	return {
+		verified: false,
+		algorithm: metricAlgorithm,
+		mismatched: true
+	};
+}
+async function verifyRequestRfc9421(request, span, metricsContext, { documentLoader, contextLoader, timeWindow, currentTime, keyCache, maxSignatures = 3, [verificationObservation]: observation, meterProvider, tracerProvider } = {}) {
 	const logger = getLogger([
 		"fedify",
 		"sig",
@@ -692,7 +925,6 @@ async function verifyRequestRfc9421(request, span, metricsContext, { documentLoa
 		logger.error("Failed to verify; the request body is locked.", { url: request.url });
 		return noSignatureResult();
 	}
-	const originalRequest = request;
 	request = request.clone();
 	const signatureInputHeader = request.headers.get("Signature-Input");
 	if (!signatureInputHeader) {
@@ -712,160 +944,148 @@ async function verifyRequestRfc9421(request, span, metricsContext, { documentLoa
 		logger.debug("Failed to verify; no valid signatures found in Signature-Input header.", { header: signatureInputHeader });
 		return invalidSignatureResult(null);
 	}
+	if (signatureNames.length > maxSignatures) {
+		logger.debug("Verifying only the first {maxSignatures} of the {count} signatures in the Signature-Input header; the rest are ignored.", {
+			maxSignatures,
+			count: signatureNames.length
+		});
+		signatureNames.splice(maxSignatures);
+	}
+	const keyLookups = /* @__PURE__ */ new Map();
+	const refreshedKeyIds = /* @__PURE__ */ new Set();
+	const lookUpKey = (keyId, keyCache) => measureSignatureKeyFetch(meterProvider, "http", () => fetchKeyDetailed(keyId, CryptographicKey, {
+		documentLoader,
+		contextLoader,
+		keyCache,
+		tracerProvider,
+		meterProvider,
+		portableKeyResolvers: createPortableKeyResolvers({
+			documentLoader,
+			contextLoader,
+			keyCache,
+			tracerProvider,
+			meterProvider
+		})
+	}));
 	let failure = noSignatureResult();
 	let failureAlgorithm;
 	const setFailure = (result, algorithm) => {
 		failure = result;
 		failureAlgorithm = algorithm;
 	};
+	let body = null;
+	let digestValid = null;
 	for (const sigName of signatureNames) {
-		if (!signatures[sigName]) {
-			setFailure(invalidSignatureResult(parseKeyId(signatureInputs[sigName]?.keyId)));
-			continue;
-		}
-		const sigInput = signatureInputs[sigName];
-		const sigBytes = signatures[sigName];
-		const keyId = parseKeyId(sigInput.keyId);
-		if (!sigInput.keyId) {
-			logger.debug("Failed to verify; missing keyId in signature {signatureName}.", {
-				signatureName: sigName,
-				signatureInput: signatureInputHeader
-			});
-			setFailure(invalidSignatureResult(null));
-			continue;
-		}
-		if (!sigInput.created) {
-			logger.debug("Failed to verify; missing created timestamp in signature {signatureName}.", {
-				signatureName: sigName,
-				signatureInput: signatureInputHeader
-			});
-			setFailure(invalidSignatureResult(keyId));
-			continue;
-		}
-		const signatureCreated = Temporal.Instant.fromEpochMilliseconds(sigInput.created * 1e3);
-		const now = currentTime ?? Temporal.Now.instant();
-		if (timeWindow !== false) {
-			const tw = timeWindow ?? { hours: 1 };
-			if (Temporal.Instant.compare(signatureCreated, now.add(tw)) > 0) {
-				logger.debug("Failed to verify; signature created time is too far in the future.", {
-					created: signatureCreated.toString(),
-					now: now.toString()
+		let winning;
+		await observeCheck({ [verificationObservation]: observation }, {
+			mechanism: "http",
+			spec: "rfc9421",
+			label: sigName
+		}, signatureInputs[sigName]?.keyId ?? null, async (candidateObservation) => {
+			if (!signatures[sigName]) {
+				setFailure(invalidSignatureResult(parseKeyId(signatureInputs[sigName]?.keyId)));
+				return null;
+			}
+			const sigInput = signatureInputs[sigName];
+			const sigBytes = signatures[sigName];
+			const keyId = parseKeyId(sigInput.keyId);
+			if (!sigInput.keyId) {
+				logger.debug("Failed to verify; missing keyId in signature {signatureName}.", {
+					signatureName: sigName,
+					signatureInput: signatureInputHeader
 				});
-				setFailure(invalidSignatureResult(keyId));
-				continue;
-			} else if (Temporal.Instant.compare(signatureCreated, now.subtract(tw)) < 0) {
-				logger.debug("Failed to verify; signature created time is too far in the past.", {
-					created: signatureCreated.toString(),
-					now: now.toString()
+				setFailure(invalidSignatureResult(null));
+				return null;
+			}
+			if (!sigInput.created) {
+				logger.debug("Failed to verify; missing created timestamp in signature {signatureName}.", {
+					signatureName: sigName,
+					signatureInput: signatureInputHeader
 				});
 				setFailure(invalidSignatureResult(keyId));
-				continue;
+				return null;
 			}
-		}
-		if (request.method !== "GET" && request.method !== "HEAD" && sigInput.components.some((c) => c.value === "content-digest")) {
-			const contentDigestHeader = request.headers.get("Content-Digest");
-			if (!contentDigestHeader) {
-				logger.debug("Failed to verify; Content-Digest header required but not found.", { components: sigInput.components });
-				setFailure(invalidSignatureResult(keyId));
-				continue;
+			const signatureCreated = Temporal.Instant.fromEpochMilliseconds(sigInput.created * 1e3);
+			const now = currentTime ?? Temporal.Now.instant();
+			if (timeWindow !== false) {
+				const tw = timeWindow ?? { hours: 1 };
+				if (Temporal.Instant.compare(signatureCreated, now.add(tw)) > 0) {
+					logger.debug("Failed to verify; signature created time is too far in the future.", {
+						created: signatureCreated.toString(),
+						now: now.toString()
+					});
+					setFailure(invalidSignatureResult(keyId));
+					return null;
+				} else if (Temporal.Instant.compare(signatureCreated, now.subtract(tw)) < 0) {
+					logger.debug("Failed to verify; signature created time is too far in the past.", {
+						created: signatureCreated.toString(),
+						now: now.toString()
+					});
+					setFailure(invalidSignatureResult(keyId));
+					return null;
+				}
 			}
-			if (!await verifyRfc9421ContentDigest(contentDigestHeader, await request.arrayBuffer())) {
-				logger.debug("Failed to verify; Content-Digest verification failed.", { contentDigest: contentDigestHeader });
-				setFailure(invalidSignatureResult(keyId));
-				continue;
+			if (request.method !== "GET" && request.method !== "HEAD" && sigInput.components.some((c) => c.value === "content-digest")) {
+				const contentDigestHeader = request.headers.get("Content-Digest");
+				if (!contentDigestHeader) {
+					logger.debug("Failed to verify; Content-Digest header required but not found.", { components: sigInput.components });
+					setFailure(invalidSignatureResult(keyId));
+					return null;
+				}
+				body ??= await request.arrayBuffer();
+				digestValid ??= await verifyRfc9421ContentDigest(contentDigestHeader, body);
+				if (!digestValid) {
+					logger.debug("Failed to verify; Content-Digest verification failed.", { contentDigest: contentDigestHeader });
+					setFailure(invalidSignatureResult(keyId));
+					return null;
+				}
 			}
-		}
-		span?.setAttribute("http_signatures.key_id", sigInput.keyId);
-		span?.setAttribute("http_signatures.created", sigInput.created.toString());
-		if (keyId == null) {
-			setFailure(invalidSignatureResult(null));
-			continue;
-		}
-		const { key, cached, fetchError } = await measureSignatureKeyFetch(meterProvider, "http", () => fetchKeyDetailed(keyId, CryptographicKey, {
-			documentLoader,
-			contextLoader,
-			keyCache,
-			tracerProvider,
-			meterProvider
-		}));
-		if (fetchError != null) {
-			setFailure(keyFetchErrorResult(keyId, fetchError));
-			continue;
-		}
-		if (!key) {
-			logger.debug("Failed to fetch key: {keyId}", { keyId: sigInput.keyId });
-			setFailure(invalidSignatureResult(keyId));
-			continue;
-		}
-		let alg = sigInput.alg?.toLowerCase();
-		if (alg == null) {
-			if (key.publicKey.algorithm.name === "RSASSA-PKCS1-v1_5") alg = "hash" in key.publicKey.algorithm ? key.publicKey.algorithm.hash === "SHA-512" ? "rsa-v1_5-sha512" : "rsa-v1_5-sha256" : "rsa-v1_5-sha256";
-			else if (key.publicKey.algorithm.name === "RSA-PSS") alg = "rsa-pss-sha512";
-			else if (key.publicKey.algorithm.name === "ECDSA") alg = "namedCurve" in key.publicKey.algorithm && key.publicKey.algorithm.namedCurve === "P-256" ? "ecdsa-p256-sha256" : "ecdsa-p384-sha384";
-			else if (key.publicKey.algorithm.name === "Ed25519") alg = "ed25519";
-		}
-		if (alg) span?.setAttribute("http_signatures.algorithm", alg);
-		const algorithm = alg && rfc9421AlgorithmMap[alg];
-		const candidateAlgorithm = algorithm ? alg : void 0;
-		if (!algorithm) {
-			logger.debug("Failed to verify; unsupported algorithm: {algorithm}", {
-				algorithm: sigInput.alg,
-				supported: Object.keys(rfc9421AlgorithmMap)
-			});
-			setFailure(invalidSignatureResult(keyId));
-			continue;
-		}
-		let signatureBase;
-		try {
-			signatureBase = createRfc9421SignatureBase(request, sigInput.components, sigInput.parameters);
-		} catch (error) {
-			logger.debug("Failed to create signature base for verification: {error}", {
-				error,
-				signatureInput: sigInput
-			});
-			setFailure(invalidSignatureResult(keyId), candidateAlgorithm);
-			continue;
-		}
-		const signatureBaseBytes = new TextEncoder().encode(signatureBase);
-		span?.setAttribute("http_signatures.signature", encodeHex(sigBytes));
-		try {
-			if (await crypto.subtle.verify(algorithm, key.publicKey, sigBytes.slice(), signatureBaseBytes)) {
-				metricsContext.algorithm = candidateAlgorithm;
-				return {
-					verified: true,
-					key,
-					signatureLabel: sigName
-				};
-			} else if (cached) {
-				logger.debug("Failed to verify with cached key {keyId}; retrying with fresh key...", { keyId: sigInput.keyId });
-				return await verifyRequestRfc9421(originalRequest, span, metricsContext, {
-					documentLoader,
-					contextLoader,
-					timeWindow,
-					currentTime,
-					keyCache: {
-						get: () => Promise.resolve(void 0),
-						set: async (keyId, key) => await keyCache?.set(keyId, key)
-					},
-					spec: "rfc9421",
-					meterProvider,
-					tracerProvider
-				});
-			} else {
-				logger.debug("Failed to verify signature with fetched key {keyId}; signature invalid.", {
-					keyId: sigInput.keyId,
-					signatureBase
-				});
-				setFailure(invalidSignatureResult(keyId), candidateAlgorithm);
+			span?.setAttribute("http_signatures.key_id", sigInput.keyId);
+			span?.setAttribute("http_signatures.created", sigInput.created.toString());
+			if (keyId == null) {
+				setFailure(invalidSignatureResult(null));
+				return null;
 			}
-		} catch (error) {
-			logger.debug("Error during signature verification: {error}", {
-				error,
-				keyId: sigInput.keyId,
-				algorithm: sigInput.alg
-			});
-			setFailure(invalidSignatureResult(keyId), candidateAlgorithm);
-		}
+			let lookup = keyLookups.get(keyId.href);
+			if (lookup == null) {
+				lookup = await lookUpKey(keyId, keyCache);
+				keyLookups.set(keyId.href, lookup);
+			}
+			while (true) {
+				const { key, cached, fetchError } = lookup;
+				if (fetchError != null) {
+					setFailure(keyFetchErrorResult(keyId, fetchError));
+					break;
+				}
+				if (!key) {
+					logger.debug("Failed to fetch key: {keyId}", { keyId: sigInput.keyId });
+					setFailure(invalidSignatureResult(keyId));
+					break;
+				}
+				const result = await verifyRfc9421SignatureWithKey(request, sigInput, sigBytes, key, span, { [verificationObservation]: candidateObservation });
+				if (result.verified) {
+					metricsContext.algorithm = result.algorithm;
+					winning = {
+						verified: true,
+						key,
+						signatureLabel: sigName
+					};
+					return key;
+				}
+				if (result.mismatched && cached && !refreshedKeyIds.has(keyId.href)) {
+					logger.debug("Failed to verify with cached key {keyId}; retrying with fresh key...", { keyId: sigInput.keyId });
+					refreshedKeyIds.add(keyId.href);
+					lookup = await lookUpKey(keyId, bypassKeyCacheReads(keyCache));
+					keyLookups.set(keyId.href, lookup);
+					continue;
+				}
+				setFailure(invalidSignatureResult(keyId), result.algorithm);
+				break;
+			}
+			if (!failure.verified && failure.reason.type === "keyFetchError" && candidateObservation.check != null) candidateObservation.check.reason = failure.reason;
+			return null;
+		});
+		if (winning != null) return winning;
 	}
 	metricsContext.algorithm = failureAlgorithm;
 	return failure;
@@ -875,10 +1095,12 @@ async function verifyRequestRfc9421(request, span, metricsContext, { documentLoa
 * @param request The original request.
 * @param location The redirect location.
 * @param body The request body as ArrayBuffer or null.
+* @param validateRedirect The function to validate the redirect URL.
 * @returns A new Request object for the redirect.
 */
-function createRedirectRequest(request, location, body) {
+async function createRedirectRequest(request, location, body, validateRedirect) {
 	const url = new URL(location, request.url);
+	await validateRedirect?.(url.href);
 	return new Request(url, {
 		method: request.method,
 		headers: request.headers,
@@ -962,21 +1184,24 @@ async function doubleKnock(request, identity, options = {}) {
 }
 async function doubleKnockInternal(request, identity, options, redirected = 0, visited = /* @__PURE__ */ new Set()) {
 	const { specDeterminer, log, tracerProvider, signal } = options;
+	signal?.throwIfAborted();
 	const maximumRedirection = options.maxRedirection ?? DEFAULT_MAX_REDIRECTION;
 	visited.add(request.url);
 	const origin = new URL(request.url).origin;
 	const firstTrySpec = specDeterminer == null ? "rfc9421" : await specDeterminer.determineSpec(origin);
+	signal?.throwIfAborted();
 	const body = options.body !== void 0 ? options.body : request.method !== "GET" && request.method !== "HEAD" ? await request.clone().arrayBuffer() : null;
 	let signedRequest = await signRequest(request, identity.privateKey, identity.keyId, {
 		spec: firstTrySpec,
 		tracerProvider,
 		body
 	});
+	signal?.throwIfAborted();
 	log?.(signedRequest);
 	let response = await fetchDoubleKnockRequest(request, signedRequest, signal);
 	if (response.status >= 300 && response.status < 400 && response.headers.has("Location")) {
 		if (redirected >= maximumRedirection) throw new FetchError(request.url, `Too many redirections (${redirected + 1})`);
-		const redirectRequest = createRedirectRequest(request, response.headers.get("Location"), body);
+		const redirectRequest = await createRedirectRequest(request, response.headers.get("Location"), body, options.validateRedirect);
 		if (visited.has(redirectRequest.url)) throw new FetchError(request.url, `Redirect loop detected: ${redirectRequest.url}`);
 		return doubleKnockInternal(redirectRequest, identity, {
 			...options,
@@ -996,6 +1221,7 @@ async function doubleKnockInternal(request, identity, options, redirected = 0, v
 			let fulfilled = false;
 			let challengeRequest;
 			for (const entry of entries) {
+				signal?.throwIfAborted();
 				const rfc9421 = fulfillAcceptSignature(entry, localKeyId, localAlg);
 				if (rfc9421 == null) continue;
 				logger.debug("Received Accept-Signature challenge; accumulating label {label} and components {components}.", {
@@ -1018,13 +1244,14 @@ async function doubleKnockInternal(request, identity, options, redirected = 0, v
 				}
 			}
 			if (fulfilled && challengeRequest != null) {
+				signal?.throwIfAborted();
 				signedRequest = challengeRequest;
 				log?.(signedRequest);
 				response = await fetch(signedRequest, {
 					redirect: "manual",
 					signal
 				});
-				if (response.status >= 300 && response.status < 400 && response.headers.has("Location")) return doubleKnock(createRedirectRequest(request, response.headers.get("Location"), body), identity, {
+				if (response.status >= 300 && response.status < 400 && response.headers.has("Location")) return doubleKnock(await createRedirectRequest(request, response.headers.get("Location"), body, options.validateRedirect), identity, {
 					...options,
 					body
 				});
@@ -1042,16 +1269,18 @@ async function doubleKnockInternal(request, identity, options, redirected = 0, v
 			status: response.status,
 			statusText: response.statusText
 		});
+		signal?.throwIfAborted();
 		signedRequest = await signRequest(request, identity.privateKey, identity.keyId, {
 			spec,
 			tracerProvider,
 			body
 		});
+		signal?.throwIfAborted();
 		log?.(signedRequest);
 		response = await fetchDoubleKnockRequest(request, signedRequest, signal);
 		if (response.status >= 300 && response.status < 400 && response.headers.has("Location")) {
 			if (redirected >= maximumRedirection) throw new FetchError(request.url, `Too many redirections (${redirected + 1})`);
-			const redirectRequest = createRedirectRequest(request, response.headers.get("Location"), body);
+			const redirectRequest = await createRedirectRequest(request, response.headers.get("Location"), body, options.validateRedirect);
 			if (visited.has(redirectRequest.url)) throw new FetchError(request.url, `Redirect loop detected: ${redirectRequest.url}`);
 			return doubleKnockInternal(redirectRequest, identity, {
 				...options,
@@ -1089,4 +1318,4 @@ function timingSafeEqual(a, b) {
 	return result === 0;
 }
 //#endregion
-export { parseRfc9421Signature as a, timingSafeEqual as c, formatRfc9421SignatureParameters as i, verifyRequest as l, doubleKnock as n, parseRfc9421SignatureInput as o, formatRfc9421Signature as r, signRequest as s, createRfc9421SignatureBase as t, verifyRequestDetailed as u };
+export { listRequestSignatures as a, selectRequestSignature as c, validateMaxSignatures as d, verifyRequest as f, formatRfc9421SignatureParameters as i, signRequest as l, doubleKnock as n, parseRfc9421Signature as o, verifyRequestDetailed as p, formatRfc9421Signature as r, parseRfc9421SignatureInput as s, createRfc9421SignatureBase as t, timingSafeEqual as u };