@fedify/fedify 2.5.0-dev.2446 → 2.5.0-dev.2492

package/dist/{kv-cache-kkBB0vbI.cjs → kv-cache-Ddh5sMxH.cjs}

@@ -1,8 +1,9 @@
 const { URLPattern } = require("urlpattern-polyfill");
-const require_http = require("./http-BfW3wyQ4.cjs");
+const require_http = require("./http-kv1LZw-r.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 let _fedify_vocab_runtime = require("@fedify/vocab-runtime");
 let es_toolkit = require("es-toolkit");
+let _fedify_vocab_runtime_internal = require("@fedify/vocab-runtime/internal");
 //#region src/utils/docloader.ts
 const logger$1 = (0, _logtape_logtape.getLogger)([
 	"fedify",
@@ -26,13 +27,35 @@ const DEFAULT_MAX_REDIRECTION = 20;
 * @throws {RangeError} If the `timeout` option is invalid.
 * @since 0.4.0
 */
-function getAuthenticatedDocumentLoader(identity, { allowPrivateAddress, maxRedirection, userAgent, specDeterminer, timeout, tracerProvider } = {}) {
+function getAuthenticatedDocumentLoader(identity, options = {}) {
+	return createAuthenticatedDocumentLoader(identity, options);
+}
+/**
+* The placeholder that the alternate document callback of
+* `getRemoteDocument()` returns, so that the alternate document is loaded
+* after the current hop is closed.
+*/
+const ALTERNATE_PLACEHOLDER = Object.freeze({
+	contextUrl: null,
+	document: null,
+	documentUrl: "about:blank"
+});
+/**
+* The implementation of {@link getAuthenticatedDocumentLoader}.  This is not
+* exported from any entry point.
+* @param identity The identity to get the document loader for.
+* @param options The options for the document loader.
+* @param deps The dependencies, for tests.
+* @returns The authenticated document loader.
+* @throws {TypeError} If the key is invalid or unsupported.
+*/
+function createAuthenticatedDocumentLoader(identity, { allowPrivateAddress, maxRedirection, userAgent, specDeterminer, timeout, tracerProvider } = {}, deps = {}) {
 	require_http.validateCryptoKey(identity.privateKey);
 	const resolvedTimeout = (0, _fedify_vocab_runtime.resolveDocumentLoaderTimeout)(timeout);
 	async function load(url, options, redirected = 0, visited = /* @__PURE__ */ new Set()) {
 		options?.signal?.throwIfAborted();
 		let currentUrl = new URL(url).href;
-		await validateUrl(currentUrl, options);
+		validateUrl(currentUrl);
 		visited.add(currentUrl);
 		const originalRequest = (0, _fedify_vocab_runtime.createActivityPubRequest)(currentUrl, { userAgent });
 		function follow(nextUrl) {
@@ -41,46 +64,68 @@ function getAuthenticatedDocumentLoader(identity, { allowPrivateAddress, maxRedi
 			if (visited.has(nextUrl)) throw new _fedify_vocab_runtime.FetchError(currentUrl, `Redirect loop detected: ${nextUrl}`);
 			redirected++;
 		}
-		const response = await require_http.doubleKnock(originalRequest, identity, {
+		const result = await require_http.doubleKnockScoped(originalRequest, identity, {
 			maxRedirection,
 			specDeterminer,
 			log: (0, es_toolkit.curry)(_fedify_vocab_runtime.logRequest)(logger$1),
 			tracerProvider,
 			signal: options?.signal,
-			validateRedirect: async (nextUrl) => {
+			validateRedirect: (nextUrl) => {
 				follow(nextUrl);
-				await validateUrl(nextUrl, options);
+				validateUrl(nextUrl);
 				visited.add(nextUrl);
 				currentUrl = nextUrl;
 			}
+		}, (hopUrl) => openHop(hopUrl, options), async (response) => {
+			options?.signal?.throwIfAborted();
+			let alternateUrl;
+			const document = await (0, _fedify_vocab_runtime.getRemoteDocument)(currentUrl, response, (url) => {
+				alternateUrl = url;
+				return Promise.resolve(ALTERNATE_PLACEHOLDER);
+			}, options);
+			if (alternateUrl == null) return { document };
+			if (!response.bodyUsed && response.body?.locked !== true) response.body?.cancel().catch((error) => {
+				logger$1.debug("Failed to cancel the response body from {url}: {error}", {
+					url: currentUrl,
+					error
+				});
+			});
+			return { alternateUrl };
 		});
 		options?.signal?.throwIfAborted();
-		return (0, _fedify_vocab_runtime.getRemoteDocument)(currentUrl, response, (alternateUrl) => {
-			follow(alternateUrl);
-			return load(alternateUrl, options, redirected, visited);
-		}, options);
+		if ("document" in result) return result.document;
+		follow(result.alternateUrl);
+		return load(result.alternateUrl, options, redirected, visited);
+	}
+	function openUnvalidatedHop(url, signal) {
+		if (deps.openHop != null) return deps.openHop(url);
+		return allowPrivateAddress ? (0, _fedify_vocab_runtime_internal.openDirectFetch)(url) : (0, _fedify_vocab_runtime_internal.openPublicFetch)(url, { signal });
 	}
-	async function validateUrl(url, options) {
+	async function openHop(url, options) {
+		try {
+			const session = await openUnvalidatedHop(url, options?.signal);
+			if (options?.signal?.aborted) {
+				await session.close();
+				options.signal.throwIfAborted();
+			}
+			return session;
+		} catch (error) {
+			if (error instanceof _fedify_vocab_runtime.UrlError) if (error.reason === "dns") logger$1.debug("DNS lookup failed for {url}", {
+				url,
+				error
+			});
+			else logger$1[options?.suppressError ? "warn" : "error"]("Disallowed private URL: {url}", {
+				url,
+				error
+			});
+			throw error;
+		}
+	}
+	function validateUrl(url) {
 		const parsedUrl = new URL(url);
 		const protocol = parsedUrl.protocol;
 		if (protocol !== "http:" && protocol !== "https:") throw new _fedify_vocab_runtime.UrlError(`Unsupported protocol: ${protocol}`);
 		if (parsedUrl.username !== "" || parsedUrl.password !== "") throw new _fedify_vocab_runtime.UrlError("URLs with credentials are not allowed");
-		if (!allowPrivateAddress) {
-			try {
-				await (0, _fedify_vocab_runtime.validatePublicUrl)(url);
-			} catch (error) {
-				if (error instanceof _fedify_vocab_runtime.UrlError) if (error.reason === "dns") logger$1.debug("DNS lookup failed for {url}", {
-					url,
-					error
-				});
-				else logger$1[options?.suppressError ? "warn" : "error"]("Disallowed private URL: {url}", {
-					url,
-					error
-				});
-				throw error;
-			}
-			options?.signal?.throwIfAborted();
-		}
 	}
 	return (0, _fedify_vocab_runtime.withDocumentLoaderTimeout)((url, options) => load(url, options), resolvedTimeout);
 }

package/dist/ld-CWVpo_NM.d.cts

@@ -0,0 +1,250 @@
+/// <reference lib="esnext.temporal" />
+import { a as KeyCache, v as VerificationObservationOptions } from "./key-DlHT4R6k.cjs";
+import { Activity, Actor, CryptographicKey } from "@fedify/vocab";
+import { DocumentLoader } from "@fedify/vocab-runtime";
+import { MeterProvider, TracerProvider } from "@opentelemetry/api";
+
+//#region src/sig/owner.d.ts
+/**
+* Options for {@link doesActorOwnKey}.
+* @since 0.8.0
+*/
+interface DoesActorOwnKeyOptions {
+  /**
+  * The document loader to use for fetching the actor.
+  */
+  documentLoader?: DocumentLoader;
+  /**
+  * The context loader to use for JSON-LD context retrieval.
+  */
+  contextLoader?: DocumentLoader;
+  /**
+  * The OpenTelemetry tracer provider to use for tracing.  If omitted,
+  * the global tracer provider is used.
+  * @since 1.3.0
+  */
+  tracerProvider?: TracerProvider;
+}
+/**
+* Checks if the actor of the given activity owns the specified key.
+*
+* Ownership is never taken from what the activity or the key say about
+* themselves, as both are written by whoever sent the activity.  It is
+* established from a document that the owner itself serves: either the key's
+* claimed owner links back to the key, or the actor the activity claims lists
+* the key as its own.
+*
+* @param activity The activity to check.
+* @param key The public key to check.
+* @param options Options for checking the key ownership.
+* @returns Whether the actor is the owner of the key.
+*/
+declare function doesActorOwnKey(activity: Activity, key: CryptographicKey, options: DoesActorOwnKeyOptions): Promise<boolean>;
+/**
+* Options for {@link getKeyOwner}.
+* @since 0.8.0
+*/
+interface GetKeyOwnerOptions {
+  /**
+  * The document loader to use for fetching the key and its owner.
+  */
+  documentLoader?: DocumentLoader;
+  /**
+  * The context loader to use for JSON-LD context retrieval.
+  */
+  contextLoader?: DocumentLoader;
+  /**
+  * The OpenTelemetry tracer provider to use for tracing.  If omitted,
+  * the global tracer provider is used.
+  * @since 1.3.0
+  */
+  tracerProvider?: TracerProvider;
+}
+/**
+* Gets the actor that owns the specified key.  Returns `null` if the key has no
+* known owner.
+*
+* The owner is only returned when the key and the owner link to each other:
+* a document that merely claims to own a key is not enough, as the claim and
+* the key can come from the same host.
+*
+* @param keyId The ID of the key to check, or the key itself.
+* @param options Options for getting the key owner.
+* @returns The actor that owns the key, or `null` if the key has no known
+*          owner.
+* @since 0.7.0
+*/
+declare function getKeyOwner(keyId: URL | CryptographicKey, options: GetKeyOwnerOptions): Promise<Actor | null>;
+//#endregion
+//#region src/sig/ld.d.ts
+/**
+* How a context loader marked by {@link markEffectiveContextLoader} already
+* resolves contexts.
+* @internal
+*/
+type EffectiveContextLoaderPolicy = "standard" | "normalization";
+/**
+* A signature of a JSON-LD document.
+* @since 1.0.0
+*/
+interface Signature {
+  "@context"?: "https://w3id.org/identity/v1";
+  type: "RsaSignature2017";
+  id?: string;
+  creator: string;
+  created: string;
+  signatureValue: string;
+}
+/**
+* Attaches a LD signature to the given JSON-LD document.
+* @param jsonLd The JSON-LD document to attach the signature to.  It is not
+*               modified.
+* @param signature The signature to attach.
+* @returns The JSON-LD document with the attached signature.
+* @throws {TypeError} If the input document is not a valid JSON-LD document.
+* @since 1.0.0
+*/
+declare function attachSignature(jsonLd: unknown, signature: Signature): {
+  signature: Signature;
+};
+/**
+* Options for creating Linked Data Signatures.
+* @since 1.0.0
+*/
+interface CreateSignatureOptions {
+  /**
+  * The context loader for loading remote JSON-LD contexts.
+  */
+  contextLoader?: DocumentLoader;
+  /**
+  * The time when the signature was created.  If not specified, the current
+  * time will be used.
+  */
+  created?: Temporal.Instant;
+}
+/**
+* Creates a LD signature for the given JSON-LD document.
+* @param jsonLd The JSON-LD document to sign.
+* @param privateKey The private key to sign the document.
+* @param keyId The ID of the public key that corresponds to the private key.
+* @param options Additional options for creating the signature.
+*                See also {@link CreateSignatureOptions}.
+* @return The created signature.
+* @throws {TypeError} If the private key is invalid or unsupported.
+* @since 1.0.0
+*/
+declare function createSignature(jsonLd: unknown, privateKey: CryptoKey, keyId: URL, {
+  contextLoader,
+  created
+}?: CreateSignatureOptions): Promise<Signature>;
+/**
+* Options for signing JSON-LD documents.
+* @since 1.0.0
+*/
+interface SignJsonLdOptions extends CreateSignatureOptions {
+  /**
+  * The OpenTelemetry tracer provider for tracing the signing process.
+  * If omitted, the global tracer provider is used.
+  * @since 1.3.0
+  */
+  tracerProvider?: TracerProvider;
+}
+/**
+* Signs the given JSON-LD document with the private key and returns the signed
+* JSON-LD document.
+* @param jsonLd The JSON-LD document to sign.
+* @param privateKey The private key to sign the document.
+* @param keyId The key ID to use in the signature.  It will be used by the
+*              verifier to fetch the corresponding public key.
+* @param options Additional options for signing the document.
+*                See also {@link SignJsonLdOptions}.
+* @returns The signed JSON-LD document.
+* @throws {TypeError} If the private key is invalid or unsupported.
+* @since 1.0.0
+*/
+declare function signJsonLd(jsonLd: unknown, privateKey: CryptoKey, keyId: URL, options: SignJsonLdOptions): Promise<{
+  signature: Signature;
+}>;
+/**
+* Checks if the given JSON-LD document has a Linked Data Signature-like
+* object, without restricting it to a single suite-specific shape.
+* @param jsonLd The JSON-LD document to check.
+* @returns `true` if the document has a signature-like object; `false`
+*          otherwise.
+* @since 2.2.0
+*/
+declare function hasSignatureLike(jsonLd: unknown): boolean;
+/**
+* Detaches Linked Data Signatures from the given JSON-LD document.
+* @param jsonLd The JSON-LD document to modify.
+* @returns The modified JSON-LD document.  If the input document does not
+*          contain a signature, the original document is returned.
+* @since 1.0.0
+*/
+declare function detachSignature(jsonLd: unknown): unknown;
+/**
+* Options for verifying Linked Data Signatures.
+* @since 1.0.0
+*/
+interface VerifySignatureOptions extends VerificationObservationOptions {
+  /**
+  * The document loader to use for fetching the public key.
+  */
+  documentLoader?: DocumentLoader;
+  /**
+  * The context loader to use for JSON-LD context retrieval.
+  */
+  contextLoader?: DocumentLoader;
+  /**
+  * The key cache to use for caching public keys.
+  */
+  keyCache?: KeyCache;
+  /**
+  * The OpenTelemetry tracer provider for tracing the verification process.
+  * If omitted, the global tracer provider is used.
+  * @since 1.3.0
+  */
+  tracerProvider?: TracerProvider;
+  /**
+  * The OpenTelemetry meter provider.  If omitted, the global meter provider
+  * is used.
+  * @since 2.3.0
+  */
+  meterProvider?: MeterProvider;
+}
+/**
+* Verifies Linked Data Signatures of the given JSON-LD document.
+*
+* This is a low-level utility that only checks the cryptographic signature
+* and (optionally) the cached key.  It does not run the JSON-LD parsing,
+* attribution, and owner checks that a complete inbound LD verification
+* needs.  For incoming activities, prefer {@link verifyJsonLd}, which is
+* the public verification entry point and the one that emits the
+* `activitypub.signature.verification.duration` metric for the LD path.
+* `verifySignature` itself only emits
+* `activitypub.signature.key_fetch.duration`, since the rest of the work
+* that the verification-duration metric is meant to cover happens in
+* `verifyJsonLd`.
+* @param jsonLd The JSON-LD document to verify.
+* @param options Options for verifying the signature.
+* @returns The public key that signed the document or `null` if the signature
+*          is invalid or the key is not found.
+* @since 1.0.0
+*/
+declare function verifySignature(jsonLd: unknown, options?: VerifySignatureOptions): Promise<CryptographicKey | null>;
+/**
+* Options for verifying JSON-LD documents.
+*/
+interface VerifyJsonLdOptions extends VerifySignatureOptions {}
+/**
+* Verify the authenticity of the given JSON-LD document using Linked Data
+* Signatures.  If the document is signed, this function verifies the signature
+* and checks if the document is attributed to the owner of the public key.
+* If the document is not signed, this function returns `false`.
+* @param jsonLd The JSON-LD document to verify.
+* @param options Options for verifying the document.
+* @returns `true` if the document is authentic; `false` otherwise.
+*/
+declare function verifyJsonLd(jsonLd: unknown, options?: VerifyJsonLdOptions): Promise<boolean>;
+//#endregion
+export { VerifySignatureOptions as a, detachSignature as c, verifyJsonLd as d, verifySignature as f, getKeyOwner as g, doesActorOwnKey as h, VerifyJsonLdOptions as i, hasSignatureLike as l, GetKeyOwnerOptions as m, EffectiveContextLoaderPolicy as n, attachSignature as o, DoesActorOwnKeyOptions as p, SignJsonLdOptions as r, createSignature as s, CreateSignatureOptions as t, signJsonLd as u };

package/dist/{ld-CD2CsPxq.mjs → ld-CdvcOEXQ.mjs}

@@ -3,8 +3,8 @@ import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import { c as isPortableActorDocument, d as isPortableUri, l as isPortableId, m as parseKeyIdString, s as isCompatibleKeyId } 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-eNpfj4oR.mjs";
-import { _ as recordKeyLookup, n as getDurationMs, r as getFederationMetrics, s as measureSignatureKeyFetch, t as classifyFetchError } from "./metrics-D3LHk6Z4.mjs";
+import { n as version, t as name } from "./deno-iOAA7iRN.mjs";
+import { _ as recordKeyLookup, n as getDurationMs, r as getFederationMetrics, s as measureSignatureKeyFetch, t as classifyFetchError } from "./metrics-CpxvUrBz.mjs";
 import { n as attachKeyOwnerEvidence, t as MAX_PORTABLE_KEY_TTL } from "./key-owner-evidence-APB6NpSk.mjs";
 import { getLogger } from "@logtape/logtape";
 import { Activity, CryptographicKey, Multikey, Object as Object$1, getTypeId, isActor } from "@fedify/vocab";
@@ -200,6 +200,7 @@ async function fetchActorDocumentInternal(actorId, options, propagateContextFetc
 			actorId: actorId.href,
 			error
 		});
+		if (propagateContextFetchErrors) throw new KeyContextFetchError(error);
 		return null;
 	}
 	let object;
@@ -1146,8 +1147,26 @@ function createMemoizedDocumentLoader(documentLoader) {
 		return cloneRemoteDocument(await remoteDocument);
 	};
 }
+const effectiveContextLoaderPolicies = /* @__PURE__ */ new WeakMap();
+/**
+* Marks a context loader as the *effective* loader of a policy, i.e., one
+* that already applies what {@link wrapContextLoaderForJsonLd} (`"standard"`)
+* or {@link getNormalizationContextLoader} (`"normalization"`) would add.
+* Those functions return a marked loader as is instead of wrapping it again,
+* so that a caller can observe every response a parse actually uses,
+* including Fedify's own baseline contexts.
+* @param loader The effective context loader.
+* @param policy The policy the loader already applies.
+* @returns The given loader.
+* @internal
+*/
+function markEffectiveContextLoader(loader, policy) {
+	effectiveContextLoaderPolicies.set(loader, policy);
+	return loader;
+}
 /** @internal */
 function wrapContextLoaderForJsonLd(contextLoader) {
+	if (contextLoader != null && effectiveContextLoaderPolicies.has(contextLoader)) return contextLoader;
 	const loader = contextLoader ?? builtInContextLoader;
 	return async (url, options) => {
 		try {
@@ -1161,6 +1180,7 @@ function wrapContextLoaderForJsonLd(contextLoader) {
 }
 /** @internal */
 function getNormalizationContextLoader(contextLoader) {
+	if (contextLoader != null && effectiveContextLoaderPolicies.get(contextLoader) === "normalization") return contextLoader;
 	const loader = wrapContextLoaderForJsonLd(contextLoader);
 	return createMemoizedDocumentLoader(async (url, options) => {
 		if (URL.canParse(url)) {
@@ -1613,10 +1633,21 @@ function getLdSignatureObject(jsonLd) {
 * @returns `true` if the document is authentic; `false` otherwise.
 */
 async function verifyJsonLd(jsonLd, options = {}) {
-	return await verifyJsonLdInternal(jsonLd, options, true);
+	return (await verifyJsonLdInternal(jsonLd, options, true)).verified;
 }
 /** @internal */
 async function verifyCompactJsonLd(jsonLd, options = {}) {
+	return (await verifyJsonLdInternal(jsonLd, options, false)).verified;
+}
+/**
+* Same as {@link verifyCompactJsonLd}, but also returns the key that verified
+* the signature, whose `owner` {@link fetchKey} has confirmed.
+* @param jsonLd The compacted JSON-LD document to verify.
+* @param options Options for verifying the JSON-LD document.
+* @returns The result.
+* @internal
+*/
+async function verifyCompactJsonLdDetailed(jsonLd, options = {}) {
 	return await verifyJsonLdInternal(jsonLd, options, false);
 }
 async function verifyJsonLdInternal(jsonLd, options, compact) {
@@ -1626,7 +1657,7 @@ async function verifyJsonLdInternal(jsonLd, options, compact) {
 	}, "linkedData", (observation) => verifyJsonLdInternal(jsonLd, {
 		...options,
 		[verificationObservation]: observation
-	}, compact), (value) => value);
+	}, compact), (value) => value.verified);
 	const observation = options[verificationObservation];
 	return await (options.tracerProvider ?? trace.getTracerProvider()).getTracer(name, version).startActiveSpan("ld_signatures.verify", async (span) => {
 		const start = performance.now();
@@ -1658,12 +1689,18 @@ async function verifyJsonLdInternal(jsonLd, options, compact) {
 			const key = await verifySignature(compacted, verificationOptions);
 			if (key == null) {
 				if (observation?.attempt != null && !hasLdSignatureProperty(jsonLd)) observation.attempt.reason = { type: "noSignature" };
-				return false;
+				return {
+					verified: false,
+					key: null
+				};
 			}
 			if (key.ownerId == null) {
 				if (observation?.attempt != null) observation.attempt.reason = { type: "missingOwner" };
 				logger.debug("Key {keyId} has no owner.", { keyId: key.id?.href });
-				return false;
+				return {
+					verified: false,
+					key: null
+				};
 			}
 			attributions.delete(key.ownerId.href);
 			if (attributions.size > 0) {
@@ -1672,10 +1709,16 @@ async function verifyJsonLdInternal(jsonLd, options, compact) {
 					attributionIds: [...attributions].map((id) => new URL(id))
 				};
 				logger.debug("Some attributions are not authenticated by the Linked Data Signatures: {attributions}.", { attributions: [...attributions] });
-				return false;
+				return {
+					verified: false,
+					key: null
+				};
 			}
 			verified = true;
-			return true;
+			return {
+				verified: true,
+				key
+			};
 		} catch (error) {
 			threw = true;
 			span.setStatus({
@@ -1706,4 +1749,4 @@ async function hashJsonLd(jsonLd, contextLoader) {
 	return encodeHex(await crypto.subtle.digest("SHA-256", encoder.encode(canon)));
 }
 //#endregion
-export { generateCryptoKeyPair as C, verifyKeyOwnership as E, fetchKeyDetailed as S, validateCryptoKey as T, wrapContextLoaderForJsonLd as _, compactJsonLd as a, fetchActorDocument as b, getNormalizationContextLoader as c, isClearlyMalformedContextReference as d, isInvalidUrlTypeError as f, verifySignature as g, verifyJsonLd as h, attachSignature as i, hasSignature as l, verifyCompactJsonLd as m, UnsafeJsonLdError as n, createSignature as o, signJsonLd as p, assertSafeJsonLd as r, detachSignature as s, InvalidContextReferenceError as t, hasSignatureLike as u, bypassKeyCacheReads as v, importJwk as w, fetchKey as x, exportJwk as y };
+export { fetchKey as C, validateCryptoKey as D, importJwk as E, verifyKeyOwnership as O, fetchActorDocument as S, generateCryptoKeyPair as T, verifyJsonLd as _, compactJsonLd as a, bypassKeyCacheReads as b, getNormalizationContextLoader as c, isClearlyMalformedContextReference as d, isInvalidUrlTypeError as f, verifyCompactJsonLdDetailed as g, verifyCompactJsonLd as h, attachSignature as i, hasSignature as l, signJsonLd as m, UnsafeJsonLdError as n, createSignature as o, markEffectiveContextLoader as p, assertSafeJsonLd as r, detachSignature as s, InvalidContextReferenceError as t, hasSignatureLike as u, verifySignature as v, fetchKeyDetailed as w, exportJwk as x, wrapContextLoaderForJsonLd as y };