@fedify/fedify 2.4.0-dev.2169 → 2.4.0-dev.2193

package/dist/{http-5CJBdU8n.cjs → http-BEivI0TS.cjs}

@@ -16,7 +16,7 @@ json_canon = require_rolldown_runtime.__toESM(json_canon, 1);
 let _opentelemetry_semantic_conventions = require("@opentelemetry/semantic-conventions");
 //#region deno.json
 var name = "@fedify/fedify";
-var version = "2.4.0-dev.2169+0a45df07";
+var version = "2.4.0-dev.2193+402149b5";
 //#endregion
 //#region src/sig/portable-key-id.ts
 const COMPATIBLE_KEY_ID_PATH_PATTERN = /^\/\.well-known\/apgateway\/did(?::|%3A)/i;
@@ -117,6 +117,50 @@ function getCanonicalPortableId(id) {
 	}
 }
 /**
+* Gets the [FEP-fe34] origin of an ID for same-origin checks.  The origin of
+* an `ap:` or `ap+ef61:` URI, or of a compatible identifier on any gateway,
+* is the DID of its canonical portable ID, as FEP-ef61 treats a compatible
+* identifier as the portable ID it stands for; unlike `getFe34Origin()`,
+* which gives a compatible identifier the web origin of its gateway.  The
+* origin of any other HTTP(S) URL is its web origin, and that of a DID URL
+* is its DID.
+*
+* Only the parsed `URL` is validated, so dot segments that URL parsing has
+* already resolved cannot be detected here.
+*
+* [FEP-fe34]: https://w3id.org/fep/fe34
+* @returns The origin, or `null` if the ID has none that is supported, or is
+*          a malformed portable ID or compatible identifier.
+* @internal
+*/
+function getAuthenticationOrigin(id) {
+	try {
+		if (isPortableId(id)) {
+			const canonical = getCanonicalPortableId(id);
+			return canonical == null ? null : (0, _fedify_vocab_runtime.getFe34Origin)(canonical);
+		}
+		return (0, _fedify_vocab_runtime.getFe34Origin)(id);
+	} catch (error) {
+		if (error instanceof TypeError) return null;
+		throw error;
+	}
+}
+/**
+* Checks whether two IDs identify the same object.  Two portable IDs, i.e.,
+* `ap:` or `ap+ef61:` URIs or compatible identifiers, are compared by their
+* canonical portable IDs, so that the same object on different gateways and
+* with different location hints matches.  Other IDs have to be equal as
+* they are.
+* @internal
+*/
+function isSameObjectId(a, b) {
+	const aPortable = isPortableId(a);
+	if (aPortable !== isPortableId(b)) return false;
+	if (!aPortable) return a.href === b.href;
+	const canonical = getCanonicalPortableId(a);
+	return canonical != null && canonical === getCanonicalPortableId(b);
+}
+/**
 * Gets the canonical portable ID of an `ap:` or `ap+ef61:` URI or
 * a compatible identifier as it is written, before any URL parsing.
 * Parsing an ID into a `URL` resolves dot segments in its path, which would
@@ -7429,6 +7473,7 @@ const FEP_2277_COLLECTION_PROPERTIES = [
 	"prev",
 	"current"
 ].map((property) => AS_NAMESPACE + property);
+const FEP_EF61_GATEWAYS = "https://w3id.org/fep/ef61/gateways";
 const PORTABLE_OBJECT_ID_PATTERN = /^ap(?:\+ef61)?:\/\//i;
 const FUNCTIONAL_PROOF_PROPERTIES = [
 	`${SECURITY_NAMESPACE}cryptosuite`,
@@ -7455,6 +7500,35 @@ function hasValidPortableProofShape(proofValue) {
 	});
 }
 /**
+* Checks whether an expanded portable actor node has the `gateways` that
+* FEP-ef61 requires: a non-empty list whose items are all HTTP(S) URIs with
+* an empty path, query, and fragment.  Like the generated vocabulary decoder,
+* this also tolerates a plain set of values instead of a `@list`, and gateway
+* strings given as `@value`s instead of `@id`s.
+*/
+function hasValidPortableActorGateways(node) {
+	const values = node[FEP_EF61_GATEWAYS];
+	if (!Array.isArray(values)) return false;
+	let items = values;
+	if (values.some((value) => isJsonLdNode(value) && "@list" in value)) {
+		if (values.length !== 1) return false;
+		items = values[0]["@list"];
+	}
+	if (!Array.isArray(items) || items.length < 1) return false;
+	return items.every((item) => {
+		if (!isJsonLdNode(item)) return false;
+		const gateway = typeof item["@id"] === "string" ? item["@id"] : item["@value"];
+		if (typeof gateway !== "string") return false;
+		try {
+			(0, _fedify_vocab_runtime.parseGatewayUrl)(gateway);
+		} catch (error) {
+			if (error instanceof TypeError) return false;
+			throw error;
+		}
+		return true;
+	});
+}
+/**
 * Classifies an expanded JSON-LD node into an FEP-2277 core type by the
 * properties it has.
 * @internal
@@ -7658,6 +7732,15 @@ async function preparePortableObjectProof(jsonLd, options) {
 			}
 		};
 	}
+	if (objectType === "actor" && !hasValidPortableActorGateways(root)) return {
+		prepared: false,
+		root,
+		objectType,
+		result: {
+			verified: false,
+			reason: { type: "invalidGateways" }
+		}
+	};
 	return {
 		prepared: true,
 		root,
@@ -7711,7 +7794,10 @@ async function verifyPortableObjectProofPolicy(jsonLd, key, options = {}) {
 *
 * Every proof must use a DID URL whose DID matches the portable object's
 * authority, i.e., the DID of its canonical portable ID, and every proof must
-* pass {@link verifyProof}.  The proofs are verified over the document as
+* pass {@link verifyProof}.  A portable actor must also have a non-empty
+* `gateways` list whose items are all HTTP(S) URIs with an empty path, query,
+* and fragment; otherwise, it is rejected with the `invalidGateways` reason
+* before its proofs are verified.  The proofs are verified over the document as
 * given; a compatible identifier is never rewritten into a portable ID.
 *
 * [FEP-ef61]: https://w3id.org/fep/ef61
@@ -8626,16 +8712,19 @@ function parseDraftSignature(signature) {
 * 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) {
+function listRequestSignatures(request, maxSignatures = 3) {
 	const signatureInput = request.headers.get("Signature-Input");
 	if (signatureInput != null) {
 		const signatures = [];
-		const inputs = parseRfc9421SignatureInput(signatureInput);
-		for (const [label, input] of Object.entries(inputs)) {
+		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({
@@ -8763,6 +8852,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",
@@ -8855,6 +8956,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);
@@ -8867,9 +8970,12 @@ 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.maxSignatures !== void 0) validateMaxSignatures(options.maxSignatures, "maxSignatures");
 	return await (options.tracerProvider ?? _opentelemetry_api.trace.getTracerProvider()).getTracer(name, version).startActiveSpan("http_signatures.verify", async (span) => {
 		if (span.isRecording()) {
 			span.setAttribute(_opentelemetry_semantic_conventions.ATTR_HTTP_REQUEST_METHOD, request.method);
@@ -9178,7 +9284,100 @@ 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) {
+	const logger = (0, _logtape_logtape.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", (0, byte_encodings_hex.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 {
+		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, meterProvider, tracerProvider } = {}) {
 	const logger = (0, _logtape_logtape.getLogger)([
 		"fedify",
 		"sig",
@@ -9191,7 +9390,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) {
@@ -9211,6 +9409,29 @@ 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, _fedify_vocab.CryptographicKey, {
+		documentLoader,
+		contextLoader,
+		keyCache,
+		tracerProvider,
+		meterProvider,
+		portableKeyResolvers: createPortableKeyResolvers({
+			documentLoader,
+			contextLoader,
+			keyCache,
+			tracerProvider,
+			meterProvider
+		})
+	}));
 	let failure = noSignatureResult();
 	let failureAlgorithm;
 	const setFailure = (result, algorithm) => {
@@ -9284,94 +9505,40 @@ async function verifyRequestRfc9421(request, span, metricsContext, { documentLoa
 			setFailure(invalidSignatureResult(null));
 			continue;
 		}
-		const { key, cached, fetchError } = await measureSignatureKeyFetch(meterProvider, "http", () => fetchKeyDetailed(keyId, _fedify_vocab.CryptographicKey, {
-			documentLoader,
-			contextLoader,
-			keyCache,
-			tracerProvider,
-			meterProvider,
-			portableKeyResolvers: createPortableKeyResolvers({
-				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";
+		let lookup = keyLookups.get(keyId.href);
+		if (lookup == null) {
+			lookup = await lookUpKey(keyId, keyCache);
+			keyLookups.set(keyId.href, lookup);
 		}
-		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", (0, byte_encodings_hex.encodeHex)(sigBytes));
-		try {
-			if (await crypto.subtle.verify(algorithm, key.publicKey, sigBytes.slice(), signatureBaseBytes)) {
-				metricsContext.algorithm = candidateAlgorithm;
+		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);
+			if (result.verified) {
+				metricsContext.algorithm = result.algorithm;
 				return {
 					verified: true,
 					key,
 					signatureLabel: sigName
 				};
-			} else if (cached) {
+			}
+			if (result.mismatched && cached && !refreshedKeyIds.has(keyId.href)) {
 				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: bypassKeyCacheReads(keyCache),
-					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);
+				refreshedKeyIds.add(keyId.href);
+				lookup = await lookUpKey(keyId, bypassKeyCacheReads(keyCache));
+				keyLookups.set(keyId.href, lookup);
+				continue;
 			}
-		} catch (error) {
-			logger.debug("Error during signature verification: {error}", {
-				error,
-				keyId: sigInput.keyId,
-				algorithm: sigInput.alg
-			});
-			setFailure(invalidSignatureResult(keyId), candidateAlgorithm);
+			setFailure(invalidSignatureResult(keyId), result.algorithm);
+			break;
 		}
 	}
 	metricsContext.algorithm = failureAlgorithm;
@@ -9471,16 +9638,19 @@ 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")) {
@@ -9505,6 +9675,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}.", {
@@ -9527,6 +9698,7 @@ async function doubleKnockInternal(request, identity, options, redirected = 0, v
 				}
 			}
 			if (fulfilled && challengeRequest != null) {
+				signal?.throwIfAborted();
 				signedRequest = challengeRequest;
 				log?.(signedRequest);
 				response = await fetch(signedRequest, {
@@ -9551,11 +9723,13 @@ 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")) {
@@ -9718,6 +9892,12 @@ Object.defineProperty(exports, "generateCryptoKeyPair", {
 		return generateCryptoKeyPair;
 	}
 });
+Object.defineProperty(exports, "getAuthenticationOrigin", {
+	enumerable: true,
+	get: function() {
+		return getAuthenticationOrigin;
+	}
+});
 Object.defineProperty(exports, "getCanonicalPortableId", {
 	enumerable: true,
 	get: function() {
@@ -9850,6 +10030,12 @@ Object.defineProperty(exports, "isPortableUri", {
 		return isPortableUri;
 	}
 });
+Object.defineProperty(exports, "isSameObjectId", {
+	enumerable: true,
+	get: function() {
+		return isSameObjectId;
+	}
+});
 Object.defineProperty(exports, "isSamePublicKey", {
 	enumerable: true,
 	get: function() {
@@ -10012,6 +10198,12 @@ Object.defineProperty(exports, "validateCryptoKey", {
 		return validateCryptoKey;
 	}
 });
+Object.defineProperty(exports, "validateMaxSignatures", {
+	enumerable: true,
+	get: function() {
+		return validateMaxSignatures;
+	}
+});
 Object.defineProperty(exports, "verifyCompactJsonLd", {
 	enumerable: true,
 	get: function() {