@fedify/fedify 2.4.0-dev.2056 → 2.4.0-dev.2065

package/dist/sig/proof.test.mjs

@@ -9,11 +9,11 @@ import { t as assertInstanceOf } from "../assert_instance_of-mrXWWNY-.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { l as verifyRequest } from "../http-CotELN-4.mjs";
+import { l as verifyRequest } from "../http-f1qaBtOh.mjs";
 import { i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2, t as ed25519Multikey } from "../keys-DIJNHW-Y.mjs";
-import { t as getAuthenticatedDocumentLoader } from "../docloader-CJADEtqb.mjs";
+import { t as getAuthenticatedDocumentLoader } from "../docloader-_aSNLA90.mjs";
 import { r as normalizeOutgoingActivityJsonLd } from "../outgoing-jsonld-4IJqPYos.mjs";
-import { a as verifyObject, c as verifyProof, n as hasProofLike, o as verifyPortableObjectProof, r as signObject, t as createProof } from "../proof-BigVZwkl.mjs";
+import { a as verifyObject, l as verifyProof, n as hasProofLike, o as verifyPortableObjectProof, r as signObject, t as createProof } from "../proof-B03JXhrk.mjs";
 import { Create, DataIntegrityProof, Document, Multikey, Note, PUBLIC_COLLECTION, Place, Translation } from "@fedify/vocab";
 import { createTestMeterProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { decodeMultibase, encodeMultibase, exportDidKey, exportMultibaseKey, formatIri, importMultibaseKey, parseIri } from "@fedify/vocab-runtime";

package/dist/sig-B1E2uyhQ.cjs

@@ -0,0 +1,405 @@
+const { URLPattern } = require("urlpattern-polyfill");
+const require_http = require("./http-BGShIsd6.cjs");
+const require_owner = require("./owner-D8ZpRusc.cjs");
+let _logtape_logtape = require("@logtape/logtape");
+let _fedify_vocab = require("@fedify/vocab");
+let _opentelemetry_api = require("@opentelemetry/api");
+let _fedify_vocab_runtime = require("@fedify/vocab-runtime");
+let _fedify_vocab_runtime_internal_portable_dereference = require("@fedify/vocab-runtime/internal/portable-dereference");
+//#region src/sig/portable-collection.ts
+const logger = (0, _logtape_logtape.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 {
+		return (0, _fedify_vocab_runtime.canonicalizePortableUri)(typeof id === "string" ? id : (0, _fedify_vocab_runtime.formatIri)(id));
+	} catch (error) {
+		if (error instanceof TypeError) return null;
+		throw error;
+	}
+}
+function toUrl(canonicalId) {
+	return (0, _fedify_vocab_runtime.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((0, _fedify_vocab_runtime.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: (0, _fedify_vocab_runtime.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 _fedify_vocab.Object) || object.id == null) return null;
+	const id = canonicalize(object.id);
+	if (id == null) return null;
+	const partOfId = object instanceof _fedify_vocab.CollectionPage ? object.partOfId : null;
+	return {
+		id,
+		url: toUrl(id),
+		origin: (0, _fedify_vocab_runtime.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 ((0, _fedify_vocab_runtime.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 ?? (0, _fedify_vocab_runtime.getDocumentLoader)();
+	const contextLoader = options.contextLoader ?? (0, _fedify_vocab_runtime.getDocumentLoader)();
+	const tracerProvider = options.tracerProvider ?? _opentelemetry_api.trace.getTracerProvider();
+	const tracer = tracerProvider.getTracer(require_http.name, require_http.version);
+	const gateways = options.gateways ?? ((0, _fedify_vocab_runtime_internal_portable_dereference.getPortableGatewayCandidates)(candidate).length > 0 ? void 0 : options.gatewayHints);
+	const span = tracer.startSpan("activitypub.lookup_object");
+	try {
+		const object = await (0, _fedify_vocab_runtime_internal_portable_dereference.dereferencePortableIri)(candidate, {
+			documentLoader,
+			contextLoader,
+			tracerProvider,
+			gateways,
+			verifyPortableObject: (document, verifierOptions) => require_owner.verifyPortableObjectProof(document, {
+				...options,
+				...verifierOptions
+			}),
+			suppressError: true,
+			span,
+			parse: (document, parseOptions) => _fedify_vocab.Object.fromJsonLd(document, {
+				documentLoader,
+				contextLoader: parseOptions.contextLoader,
+				tracerProvider,
+				baseUrl: parseOptions.baseUrl
+			})
+		});
+		return (0, _fedify_vocab.isActor)(object) ? object : null;
+	} catch (error) {
+		logger.debug("Failed to fetch the owner {owner} of a portable collection: {error}", {
+			owner: (0, _fedify_vocab_runtime.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" && (0, _fedify_vocab.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 _fedify_vocab.Object && 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 = (0, _fedify_vocab_runtime.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 require_owner.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
+Object.defineProperty(exports, "verifyPortableObject", {
+	enumerable: true,
+	get: function() {
+		return verifyPortableObject;
+	}
+});