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

package/dist/portable-collection-C74P1vtC.mjs

@@ -0,0 +1,418 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { n as version, t as name } from "./deno-oR5aJKpU.mjs";
+import { c as verifyPortableObjectProof, u as verifyPortableObjectProofWithRoot } from "./proof-Dxy6ByqI.mjs";
+import { getLogger } from "@logtape/logtape";
+import { CollectionPage, Object as Object$1, isActor } from "@fedify/vocab";
+import { trace } from "@opentelemetry/api";
+import { canonicalizePortableUri, formatIri, fromCompatibleEf61Id, getDocumentLoader, getFe34Origin, parseIri } from "@fedify/vocab-runtime";
+import { dereferencePortableIri, getPortableGatewayCandidates } from "@fedify/vocab-runtime/internal/portable-dereference";
+//#region src/sig/portable-collection.ts
+const logger = getLogger([
+	"fedify",
+	"sig",
+	"proof"
+]);
+const AS_NAMESPACE = "https://www.w3.org/ns/activitystreams#";
+const AS_ATTRIBUTED_TO = `${AS_NAMESPACE}attributedTo`;
+const AS_PART_OF = `${AS_NAMESPACE}partOf`;
+/**
+* The properties through which a collection refers to its pages, and a page
+* to other pages of the same collection.
+*/
+const PAGING_PROPERTIES = new Set([
+	"first",
+	"last",
+	"current",
+	"next",
+	"prev"
+].map((p) => AS_NAMESPACE + p));
+/**
+* The properties through which an actor refers to its own collections.
+*/
+const ACTOR_COLLECTION_PROPERTIES = /* @__PURE__ */ new Set([
+	"http://www.w3.org/ns/ldp#inbox",
+	`${AS_NAMESPACE}outbox`,
+	`${AS_NAMESPACE}followers`,
+	`${AS_NAMESPACE}following`,
+	`${AS_NAMESPACE}liked`
+]);
+const contextStates = /* @__PURE__ */ new WeakMap();
+function createContext(state) {
+	const token = Object.freeze(Object.create(null));
+	contextStates.set(token, state);
+	return token;
+}
+function getContextState(context) {
+	if (context == null || typeof context !== "object") return void 0;
+	return contextStates.get(context);
+}
+function canonicalize(id) {
+	try {
+		const portable = fromCompatibleEf61Id(id);
+		if (portable != null) return canonicalizePortableUri(formatIri(portable));
+		return canonicalizePortableUri(typeof id === "string" ? id : formatIri(id));
+	} catch (error) {
+		if (error instanceof TypeError) return null;
+		throw error;
+	}
+}
+function toUrl(canonicalId) {
+	return parseIri(canonicalId);
+}
+function canonicalizeAll(ids) {
+	const result = [];
+	for (const id of ids) {
+		const canonical = canonicalize(id);
+		if (canonical == null) return null;
+		result.push(canonical);
+	}
+	return result;
+}
+function getExpandedIds(node, property) {
+	const values = node[property];
+	if (values == null) return [];
+	if (!Array.isArray(values)) return null;
+	const ids = [];
+	for (const value of values) {
+		if (value == null || typeof value !== "object" || Array.isArray(value) || typeof value["@id"] !== "string") return null;
+		ids.push(value["@id"]);
+	}
+	return ids;
+}
+function parseAll(ids) {
+	const result = [];
+	for (const id of ids) try {
+		result.push(parseIri(id));
+	} catch (error) {
+		if (error instanceof TypeError) return null;
+		throw error;
+	}
+	return result;
+}
+function describeRoot(root) {
+	const rawId = root["@id"];
+	if (typeof rawId !== "string") return null;
+	const id = canonicalize(rawId);
+	if (id == null) return null;
+	const partOf = getExpandedIds(root, AS_PART_OF);
+	const attributedTo = getExpandedIds(root, AS_ATTRIBUTED_TO);
+	return {
+		id,
+		url: toUrl(id),
+		origin: getFe34Origin(id),
+		partOf: partOf == null ? null : canonicalizeAll(partOf),
+		attributedTo: attributedTo == null ? null : canonicalizeAll(attributedTo),
+		attributedToUrls: attributedTo == null ? null : parseAll(attributedTo)
+	};
+}
+function describeObject(object) {
+	if (!(object instanceof Object$1) || object.id == null) return null;
+	const id = canonicalize(object.id);
+	if (id == null) return null;
+	const partOfId = object instanceof CollectionPage ? object.partOfId : null;
+	return {
+		id,
+		url: toUrl(id),
+		origin: getFe34Origin(id),
+		partOf: canonicalizeAll(partOfId == null ? [] : [partOfId]),
+		attributedTo: canonicalizeAll(object.attributionIds),
+		attributedToUrls: object.attributionIds
+	};
+}
+function fail(reason) {
+	return {
+		verified: false,
+		reason
+	};
+}
+/**
+* Walks the referrer chain of a collection or page to find the root
+* collection and its owner candidate, checking every page on the way.
+*/
+function resolveChain(node, referrer) {
+	const pages = [];
+	let top = node;
+	let link = referrer;
+	let state;
+	while (link != null && PAGING_PROPERTIES.has(link.property)) {
+		pages.push(top);
+		state = getContextState(link.collectionContext);
+		if (state != null) break;
+		const parent = describeObject(link.object);
+		if (parent == null || link.truncated) return fail({ type: "unknownCollectionOwner" });
+		top = parent;
+		link = link.referrer;
+	}
+	let rootId;
+	let rootOrigin;
+	let candidate;
+	if (state != null) {
+		rootId = state.rootId;
+		rootOrigin = state.rootOrigin;
+		const ownerCandidate = state.owner == null ? state.ownerCandidate : { id: canonicalize(state.owner.id) };
+		if (ownerCandidate == null) return fail({ type: "unknownCollectionOwner" });
+		candidate = ownerCandidate;
+	} else {
+		rootId = top.id;
+		rootOrigin = top.origin;
+		const attributedTo = top.attributedTo;
+		if (attributedTo == null) return fail({ type: "unknownCollectionOwner" });
+		if (link != null && ACTOR_COLLECTION_PROPERTIES.has(link.property)) {
+			const id = link.id == null ? null : canonicalize(link.id);
+			if (id == null) return fail({ type: "unknownCollectionOwner" });
+			candidate = {
+				id,
+				object: link.object,
+				acceptance: link.acceptance
+			};
+		} else if (attributedTo.length === 1) candidate = {
+			id: attributedTo[0],
+			url: top.attributedToUrls?.[0]
+		};
+		else if (attributedTo.length > 1) return fail({
+			type: "conflictingCollectionOwners",
+			candidates: attributedTo.map(toUrl)
+		});
+		else return fail({ type: "unknownCollectionOwner" });
+		const conflict = attributedTo.find((id) => id !== candidate.id);
+		if (conflict != null) return fail({
+			type: "conflictingCollectionOwners",
+			candidates: [toUrl(candidate.id), toUrl(conflict)]
+		});
+	}
+	if (getFe34Origin(candidate.id) !== rootOrigin) return fail({ type: "unknownCollectionOwner" });
+	for (const page of pages) {
+		if (page.origin !== rootOrigin) return fail({
+			type: "collectionPageMismatch",
+			pageId: page.url,
+			collectionId: toUrl(rootId),
+			partOf: null
+		});
+		if (page.partOf == null) return fail({ type: "unknownCollectionOwner" });
+		const partOf = page.partOf.find((id) => id !== rootId);
+		if (partOf != null) return fail({
+			type: "collectionPageMismatch",
+			pageId: page.url,
+			collectionId: toUrl(rootId),
+			partOf: toUrl(partOf)
+		});
+		if (page.attributedTo == null) return fail({ type: "unknownCollectionOwner" });
+		const conflict = page.attributedTo.find((id) => id !== candidate.id);
+		if (conflict != null) return fail({
+			type: "conflictingCollectionOwners",
+			candidates: [toUrl(candidate.id), toUrl(conflict)]
+		});
+	}
+	return {
+		rootId,
+		rootOrigin,
+		owner: state?.owner ?? null,
+		candidate
+	};
+}
+function getActorCollectionIds(actor) {
+	const ids = [];
+	for (const id of [
+		actor.inboxId,
+		actor.outboxId,
+		actor.followersId,
+		actor.followingId,
+		actor.likedId
+	]) {
+		if (id == null) continue;
+		const canonical = canonicalize(id);
+		if (canonical != null) ids.push(canonical);
+	}
+	return ids;
+}
+async function fetchOwner(candidate, options) {
+	const documentLoader = options.documentLoader ?? getDocumentLoader();
+	const contextLoader = options.contextLoader ?? getDocumentLoader();
+	const tracerProvider = options.tracerProvider ?? trace.getTracerProvider();
+	const tracer = tracerProvider.getTracer(name, version);
+	let inferredGateways;
+	try {
+		const portable = fromCompatibleEf61Id(candidate);
+		if (portable != null) {
+			inferredGateways = [new URL(candidate.origin)];
+			candidate = portable;
+		}
+	} catch (error) {
+		if (!(error instanceof TypeError)) throw error;
+		logger.debug("The owner {owner} of a portable collection is a malformed compatible identifier.", { owner: candidate.href });
+		return null;
+	}
+	const gateways = options.gateways ?? (inferredGateways != null || getPortableGatewayCandidates(candidate).length > 0 ? void 0 : options.gatewayHints);
+	if (options.gateways != null) inferredGateways = void 0;
+	const span = tracer.startSpan("activitypub.lookup_object");
+	try {
+		const object = await dereferencePortableIri(candidate, {
+			documentLoader,
+			contextLoader,
+			tracerProvider,
+			gateways,
+			...inferredGateways == null ? {} : { inferredGateways },
+			verifyPortableObject: (document, verifierOptions) => verifyPortableObjectProof(document, {
+				...options,
+				...verifierOptions
+			}),
+			suppressError: true,
+			span,
+			parse: (document, parseOptions) => Object$1.fromJsonLd(document, {
+				documentLoader,
+				contextLoader: parseOptions.contextLoader,
+				tracerProvider,
+				baseUrl: parseOptions.baseUrl
+			})
+		});
+		return isActor(object) ? object : null;
+	} catch (error) {
+		logger.debug("Failed to fetch the owner {owner} of a portable collection: {error}", {
+			owner: formatIri(candidate),
+			error
+		});
+		return null;
+	} finally {
+		span.end();
+	}
+}
+async function resolveOwner(chain, options) {
+	if (chain.owner != null) return chain.owner;
+	const { candidate } = chain;
+	const candidateUrl = toUrl(candidate.id);
+	let actor = null;
+	if (candidate.acceptance === "verified" && isActor(candidate.object) && candidate.object.id != null && canonicalize(candidate.object.id) === candidate.id) actor = candidate.object;
+	else actor = await fetchOwner(candidate.url ?? (candidate.object instanceof Object$1 && candidate.object.id != null ? candidate.object.id : candidateUrl), options);
+	if (actor == null || actor.id == null) return fail({
+		type: "collectionOwnerUnavailable",
+		owner: candidateUrl
+	});
+	const gateways = actor.gateways;
+	if (gateways.length < 1) return fail({
+		type: "collectionOwnerUnavailable",
+		owner: candidateUrl
+	});
+	if (!getActorCollectionIds(actor).includes(chain.rootId)) return fail({
+		type: "collectionNotListedByOwner",
+		owner: candidateUrl,
+		collectionId: toUrl(chain.rootId)
+	});
+	return {
+		id: candidateUrl,
+		gateways
+	};
+}
+function getSourceGateway(node, documentUrl) {
+	if (documentUrl == null || documentUrl.protocol !== "http:" && documentUrl.protocol !== "https:") return null;
+	let portableId;
+	try {
+		portableId = fromCompatibleEf61Id(documentUrl);
+	} catch (error) {
+		if (error instanceof TypeError) return null;
+		throw error;
+	}
+	if (portableId == null || canonicalize(portableId) !== node.id) return null;
+	return new URL(documentUrl.origin);
+}
+/**
+* Applies the [FEP-ef61] trust policy to a portable object fetched through
+* a gateway.
+*
+* Portable actors, activities, objects, and collections with proofs are
+* verified by {@link verifyPortableObjectProof}.  A portable collection or
+* collection page without a proof is accepted only if all of the following
+* hold:
+*
+*  -  It was retrieved from a gateway: its final URL (`documentUrl`) is
+*     a compatible identifier for the same portable collection.
+*  -  Its owner is determined unambiguously: the actor whose `inbox`,
+*     `outbox`, `followers`, `following`, or `liked` property referred to
+*     the collection, or the single actor in its `attributedTo`.  A page
+*     inherits the owner of the collection it was reached from through
+*     `first`, `last`, `current`, `next`, or `prev`, and must not name
+*     another collection in `partOf`.
+*  -  The owner's actor document is verified by its proof and lists the
+*     collection as its `inbox`, `outbox`, `followers`, `following`, or
+*     `liked`.
+*  -  The gateway that served the collection is in the owner's `gateways`.
+*
+* Where the document came from and which object referred to it are passed
+* by property accessors when this function is used as their
+* `verifyPortableObject` option.  Objects embedded in an unsecured
+* collection accepted this way are not trusted: accessors dereference and
+* verify them one by one.
+*
+* Note that acceptance through the gateway policy does not verify anything
+* cryptographically; it only means that the owner trusts the gateway.
+*
+* [FEP-ef61]: https://w3id.org/fep/ef61
+*
+* @param jsonLd The JSON-LD document to verify.
+* @param options Additional options.  See also
+*                {@link VerifyPortableObjectOptions}.
+* @returns The detailed result.
+* @throws {TypeError} If the input is not a single JSON-LD object or has a
+*                     malformed portable ID.
+* @since 2.4.0
+*/
+async function verifyPortableObject(jsonLd, options = {}) {
+	const { result, root, objectType } = await verifyPortableObjectProofWithRoot(jsonLd, options);
+	if (result.verified) {
+		const node = objectType === "collection" && root != null ? describeRoot(root) : null;
+		const chain = node == null ? null : resolveChain(node, options.referrer);
+		if (chain == null || !("rootId" in chain)) return {
+			verified: true,
+			method: "proof",
+			keys: result.keys
+		};
+		return {
+			verified: true,
+			method: "proof",
+			keys: result.keys,
+			collectionContext: createContext({
+				rootId: chain.rootId,
+				rootOrigin: chain.rootOrigin,
+				owner: chain.owner,
+				ownerCandidate: chain.candidate
+			})
+		};
+	}
+	if (result.reason.type !== "unsecuredCollection") return {
+		verified: false,
+		reason: result.reason
+	};
+	const node = root == null ? null : describeRoot(root);
+	if (node == null) return fail({ type: "unknownCollectionOwner" });
+	const gateway = getSourceGateway(node, options.documentUrl);
+	if (gateway == null) return fail({
+		type: "unknownCollectionSource",
+		documentUrl: options.documentUrl ?? null
+	});
+	const chain = resolveChain(node, options.referrer);
+	if (!("rootId" in chain)) return chain;
+	const owner = await resolveOwner(chain, options);
+	if (!("gateways" in owner)) return owner;
+	if (!owner.gateways.some((g) => g.origin === gateway.origin)) return fail({
+		type: "untrustedGateway",
+		owner: owner.id,
+		gateway,
+		gateways: owner.gateways
+	});
+	return {
+		verified: true,
+		method: "gateway",
+		unsecured: true,
+		owner: owner.id,
+		gateway,
+		collectionContext: createContext({
+			rootId: chain.rootId,
+			rootOrigin: chain.rootOrigin,
+			owner,
+			ownerCandidate: null
+		})
+	};
+}
+//#endregion
+export { verifyPortableObject as t };