@fedify/fedify 2.4.0-dev.1964 → 2.4.0-dev.1995

package/dist/sig/compound-proof.test.mjs

@@ -0,0 +1,324 @@
+import { Temporal } from "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { t as assertEquals } from "../assert_equals-CBlRfA-_.mjs";
+import "../std__assert-CxFT0MNt.mjs";
+import { t as assert } from "../assert-CebeUf0C.mjs";
+import { n as ed25519PrivateKey, r as ed25519PublicKey } from "../keys-DIJNHW-Y.mjs";
+import { n as preloadedOnlyDocumentLoader } from "../public-audience-Cc2YJ3ip.mjs";
+import { r as normalizeOutgoingActivityJsonLd } from "../outgoing-jsonld-B5Ne7JoL.mjs";
+import { c as verifyProof, r as signObject } from "../proof-BDxNVZ3E.mjs";
+import { t as map_local_create_note_default } from "../map-local-create-note-B0SeXJms.mjs";
+import { t as map_local_context_conflict_default } from "../map-local-context-conflict-DOYEEJ3u.mjs";
+import { Create, DataIntegrityProof, Note } from "@fedify/vocab";
+import { mockDocumentLoader, test } from "@fedify/fixture";
+import { encodeMultibase, exportDidKey, parseIri } from "@fedify/vocab-runtime";
+import { encodeHex } from "byte-encodings/hex";
+import jsonld from "@fedify/vocab-runtime/jsonld";
+import serialize from "json-canon";
+//#region src/sig/compound-proof.test.ts
+const outerPrivateKey = await crypto.subtle.importKey("jwk", {
+	kty: "OKP",
+	crv: "Ed25519",
+	d: "yW756hDF5BTEcXI6_53nLDX6W3D66X6IMuysfS4rjtY",
+	x: "sA2Nk45_dz1RVlqtNqYj9TRPf10ZYPnPPo4SYg6igQ8",
+	key_ops: ["sign"],
+	ext: true
+}, "Ed25519", true, ["sign"]);
+const outerDid = await exportDidKey(await crypto.subtle.importKey("jwk", {
+	kty: "OKP",
+	crv: "Ed25519",
+	x: "sA2Nk45_dz1RVlqtNqYj9TRPf10ZYPnPPo4SYg6igQ8",
+	key_ops: ["verify"],
+	ext: true
+}, "Ed25519", true, ["verify"]));
+const innerDid = await exportDidKey(ed25519PublicKey.publicKey);
+const outerMethod = outerDid.substring(8);
+const innerMethod = innerDid.substring(8);
+const outerKeyId = new URL(`${outerDid}#${outerMethod}`);
+const innerKeyId = new URL(`${innerDid}#${innerMethod}`);
+const vectorInnerKeyId = new URL(map_local_create_note_default.keys.inner.verificationMethod);
+const conflictVectorInnerKeyId = new URL(map_local_context_conflict_default.keys.inner.verificationMethod);
+const context = ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/data-integrity/v1"];
+const distinctInnerContext = [...context, { ex: "https://example.com/ns#" }];
+const options = {
+	context,
+	contextLoader: mockDocumentLoader,
+	documentLoader: mockDocumentLoader
+};
+async function parseProof(document) {
+	const proof = document.proof;
+	assert(proof != null && typeof proof === "object" && !Array.isArray(proof));
+	return await DataIntegrityProof.fromJsonLd({
+		"@context": document["@context"],
+		...proof
+	}, options);
+}
+function asRecord(value) {
+	assert(value != null && typeof value === "object" && !Array.isArray(value));
+	return value;
+}
+function withoutDirectProof(document) {
+	const unsecuredDocument = structuredClone(document);
+	delete unsecuredDocument.proof;
+	return unsecuredDocument;
+}
+function withoutProofValue(proof) {
+	const proofConfiguration = structuredClone(proof);
+	delete proofConfiguration.proofValue;
+	return proofConfiguration;
+}
+async function sha256(value) {
+	return new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value)));
+}
+async function assertRecordedProof(entry) {
+	assertEquals(withoutProofValue(entry.proof), entry.proofConfiguration);
+	assertEquals(entry.proof.proofValue, entry.proofValue);
+	const documentJcs = serialize(entry.document);
+	const proofConfigurationJcs = serialize(entry.proofConfiguration);
+	assertEquals(documentJcs, entry.canonicalization.documentJcs);
+	assertEquals(proofConfigurationJcs, entry.canonicalization.proofConfigurationJcs);
+	const documentDigest = await sha256(documentJcs);
+	const proofConfigurationDigest = await sha256(proofConfigurationJcs);
+	assertEquals(encodeHex(documentDigest), entry.hashes.documentSha256);
+	assertEquals(encodeHex(proofConfigurationDigest), entry.hashes.proofConfigurationSha256);
+	const combinedSigningInput = new Uint8Array(proofConfigurationDigest.length + documentDigest.length);
+	combinedSigningInput.set(proofConfigurationDigest);
+	combinedSigningInput.set(documentDigest, proofConfigurationDigest.length);
+	assertEquals(encodeHex(combinedSigningInput), entry.hashes.combinedSigningInput);
+	assertEquals(entry.hashes.combinedSigningInput, entry.hashes.proofConfigurationSha256 + entry.hashes.documentSha256);
+	const privateJwk = structuredClone(entry.key.testPrivateKeyJwk);
+	const publicJwk = structuredClone(entry.key.publicKeyJwk);
+	assertEquals(privateJwk.x, publicJwk.x);
+	const privateKey = await crypto.subtle.importKey("jwk", privateJwk, "Ed25519", true, ["sign"]);
+	const publicKey = await crypto.subtle.importKey("jwk", publicJwk, "Ed25519", true, ["verify"]);
+	const controller = await exportDidKey(publicKey);
+	assertEquals(controller, entry.key.controller);
+	const publicKeyMultibase = controller.replace(/^did:key:/, "");
+	assertEquals(publicKeyMultibase, entry.key.publicKeyMultibase);
+	assertEquals(entry.key.verificationMethod, `${controller}#${publicKeyMultibase}`);
+	assertEquals(entry.proofConfiguration.verificationMethod, entry.key.verificationMethod);
+	const signature = new Uint8Array(await crypto.subtle.sign("Ed25519", privateKey, combinedSigningInput));
+	assert(await crypto.subtle.verify("Ed25519", publicKey, signature, combinedSigningInput));
+	assertEquals(new TextDecoder().decode(encodeMultibase("base58btc", signature)), entry.proofValue);
+}
+test("map-local compound vector records independently reproducible proofs", async () => {
+	const securedOuter = asRecord(map_local_create_note_default.documents.finalSecuredCompound);
+	const securedInner = asRecord(map_local_create_note_default.documents.securedInner);
+	const outerProof = asRecord(securedOuter.proof);
+	const innerProof = asRecord(securedInner.proof);
+	const replacementInnerProof = asRecord(map_local_create_note_default.documents.replacementInnerProof);
+	const replacementInnerProofConfiguration = withoutProofValue(replacementInnerProof);
+	assertEquals(withoutDirectProof(securedOuter), map_local_create_note_default.documents.outerUnsecuredDocument);
+	assertEquals(withoutDirectProof(securedInner), map_local_create_note_default.documents.innerUnsecuredDocument);
+	assertEquals(withoutProofValue(outerProof), map_local_create_note_default.documents.outerProofConfiguration);
+	assertEquals(withoutProofValue(innerProof), map_local_create_note_default.documents.innerProofConfiguration);
+	const entries = [
+		{
+			document: map_local_create_note_default.documents.outerUnsecuredDocument,
+			proofConfiguration: map_local_create_note_default.documents.outerProofConfiguration,
+			proof: outerProof,
+			key: map_local_create_note_default.keys.outer,
+			canonicalization: map_local_create_note_default.canonicalization.outer,
+			hashes: map_local_create_note_default.hashes.outer,
+			proofValue: map_local_create_note_default.proofValues.outer
+		},
+		{
+			document: map_local_create_note_default.documents.innerUnsecuredDocument,
+			proofConfiguration: map_local_create_note_default.documents.innerProofConfiguration,
+			proof: innerProof,
+			key: map_local_create_note_default.keys.inner,
+			canonicalization: map_local_create_note_default.canonicalization.inner,
+			hashes: map_local_create_note_default.hashes.inner,
+			proofValue: map_local_create_note_default.proofValues.inner
+		},
+		{
+			document: map_local_create_note_default.documents.innerUnsecuredDocument,
+			proofConfiguration: replacementInnerProofConfiguration,
+			proof: replacementInnerProof,
+			key: map_local_create_note_default.keys.inner,
+			canonicalization: map_local_create_note_default.canonicalization.replacementInner,
+			hashes: map_local_create_note_default.hashes.replacementInner,
+			proofValue: map_local_create_note_default.proofValues.replacementInner
+		}
+	];
+	for (const entry of entries) await assertRecordedProof(entry);
+});
+test("the context-conflict vector records valid proofs and divergent semantics", async () => {
+	const compound = asRecord(map_local_context_conflict_default.documents.finalSecuredCompound);
+	const embedded = asRecord(compound.object);
+	const securedInner = asRecord(map_local_context_conflict_default.documents.securedInner);
+	const outerProof = asRecord(compound.proof);
+	const innerProof = asRecord(embedded.proof);
+	assertEquals(embedded, securedInner);
+	assertEquals(withoutDirectProof(compound), map_local_context_conflict_default.documents.outerUnsecuredDocument);
+	assertEquals(withoutDirectProof(embedded), map_local_context_conflict_default.documents.innerUnsecuredDocument);
+	await assertRecordedProof({
+		document: map_local_context_conflict_default.documents.outerUnsecuredDocument,
+		proofConfiguration: map_local_context_conflict_default.documents.outerProofConfiguration,
+		proof: outerProof,
+		key: map_local_context_conflict_default.keys.outer,
+		canonicalization: map_local_context_conflict_default.canonicalization.outer,
+		hashes: map_local_context_conflict_default.hashes.outer,
+		proofValue: map_local_context_conflict_default.proofValues.outer
+	});
+	await assertRecordedProof({
+		document: map_local_context_conflict_default.documents.innerUnsecuredDocument,
+		proofConfiguration: map_local_context_conflict_default.documents.innerProofConfiguration,
+		proof: innerProof,
+		key: map_local_context_conflict_default.keys.inner,
+		canonicalization: map_local_context_conflict_default.canonicalization.inner,
+		hashes: map_local_context_conflict_default.hashes.inner,
+		proofValue: map_local_context_conflict_default.proofValues.inner
+	});
+	const inboundOptions = {
+		contextLoader: preloadedOnlyDocumentLoader,
+		documentLoader: preloadedOnlyDocumentLoader
+	};
+	const verifiedInner = await verifyProof(embedded, await parseProof(embedded), inboundOptions);
+	assertEquals(verifiedInner != null, map_local_context_conflict_default.expectedVerification.original.inner);
+	assertEquals(verifiedInner?.id, conflictVectorInnerKeyId);
+	const verifiedOuter = await verifyProof(compound, await parseProof(compound), inboundOptions);
+	assertEquals(verifiedOuter != null, map_local_context_conflict_default.expectedVerification.original.outer);
+	assertEquals(verifiedOuter?.id, outerKeyId);
+	const standaloneExpansion = await jsonld.expand(embedded, { documentLoader: preloadedOnlyDocumentLoader });
+	const compoundExpansion = await jsonld.expand(compound, { documentLoader: preloadedOnlyDocumentLoader });
+	const content = "https://www.w3.org/ns/activitystreams#content";
+	const object = "https://www.w3.org/ns/activitystreams#object";
+	const standaloneContent = asRecord(standaloneExpansion[0])[content];
+	const inParentObject = asRecord(asRecord(compoundExpansion[0])[object][0]);
+	const inParentContent = inParentObject[content];
+	assertEquals(serialize(standaloneExpansion[0]) === serialize(inParentObject), map_local_context_conflict_default.expectedInterpretation.standaloneAndInParentExpansionsEqual);
+	assertEquals(standaloneContent, [{ "@value": "A portable note with inherited language" }]);
+	assertEquals(inParentContent, [{
+		"@value": "A portable note with inherited language",
+		"@language": map_local_context_conflict_default.expectedInterpretation.inParentContentLanguage
+	}]);
+	assertEquals(standaloneContent[0]["@language"] ?? null, map_local_context_conflict_default.expectedInterpretation.standaloneContentLanguage);
+	assertEquals(serialize(standaloneContent) !== serialize(inParentContent), !map_local_context_conflict_default.expectedInterpretation.standaloneAndInParentExpansionsEqual);
+});
+test("the raw same-context baseline verifies map-locally", async () => {
+	const compound = structuredClone(map_local_create_note_default.documents.finalSecuredCompound);
+	const embedded = compound.object;
+	const embeddedProof = embedded.proof;
+	assertEquals(embedded, map_local_create_note_default.documents.securedInner);
+	assertEquals(embeddedProof["@context"], context);
+	assertEquals(embedded["@context"], context);
+	assert("proof" in embedded);
+	const verifiedInnerKey = await verifyProof(embedded, await parseProof(embedded), options);
+	assertEquals(verifiedInnerKey != null, map_local_create_note_default.expectedVerification.original.inner);
+	assertEquals(verifiedInnerKey != null, map_local_create_note_default.expectedVerification.standaloneInner);
+	assertEquals(verifiedInnerKey?.id, vectorInnerKeyId);
+	const verifiedOuterKey = await verifyProof(compound, await parseProof(compound), options);
+	assertEquals(verifiedOuterKey != null, map_local_create_note_default.expectedVerification.original.outer);
+	assertEquals(verifiedOuterKey != null, map_local_create_note_default.expectedVerification.standaloneOuter);
+	assertEquals(verifiedOuterKey?.id, outerKeyId);
+	const tampered = structuredClone(compound);
+	const tamperedInner = tampered.object;
+	tamperedInner.content = "A tampered portable note";
+	assertEquals(await verifyProof(tamperedInner, await parseProof(tamperedInner), options) != null, map_local_create_note_default.expectedVerification.tamperedInnerContent.inner);
+	assertEquals(await verifyProof(tampered, await parseProof(tampered), options) != null, map_local_create_note_default.expectedVerification.tamperedInnerContent.outer);
+	const replaced = structuredClone(compound);
+	const replacedInner = replaced.object;
+	replacedInner.proof = structuredClone(map_local_create_note_default.documents.replacementInnerProof);
+	const replacementInnerKey = await verifyProof(replacedInner, await parseProof(replacedInner), options);
+	assertEquals(replacementInnerKey != null, map_local_create_note_default.expectedVerification.replacedInnerProof.inner);
+	assertEquals(replacementInnerKey?.id, vectorInnerKeyId);
+	assertEquals(await verifyProof(replaced, await parseProof(replaced), options) != null, map_local_create_note_default.expectedVerification.replacedInnerProof.outer);
+});
+test("typed Create serialization bypasses a parsed child's JSON-LD cache", async () => {
+	const created = Temporal.Instant.from("2023-02-24T23:36:38Z");
+	const inner = await signObject(new Note({
+		id: parseIri(`ap+ef61://${innerDid}/objects/distinct-context`),
+		attribution: parseIri(`ap+ef61://${innerDid}/actor`),
+		content: "A portable note with its own context"
+	}), ed25519PrivateKey, innerKeyId, {
+		...options,
+		context: distinctInnerContext,
+		created
+	});
+	const standaloneInner = await normalizeOutgoingActivityJsonLd(await inner.toJsonLd({
+		format: "compact",
+		...options,
+		context: distinctInnerContext
+	}), mockDocumentLoader);
+	const compound = await normalizeOutgoingActivityJsonLd(await (await signObject(new Create({
+		id: parseIri(`ap+ef61://${outerDid}/activities/distinct-context`),
+		actor: parseIri(`ap+ef61://${outerDid}/actor`),
+		object: inner
+	}), outerPrivateKey, outerKeyId, {
+		...options,
+		created
+	})).toJsonLd({
+		format: "compact",
+		...options
+	}), mockDocumentLoader);
+	const embedded = compound.object;
+	const embeddedProof = embedded.proof;
+	const standaloneProof = await parseProof(standaloneInner);
+	assertEquals(standaloneInner["@context"], distinctInnerContext);
+	assertEquals(standaloneInner.proof["@context"], distinctInnerContext);
+	assertEquals(embedded["@context"], void 0);
+	assertEquals(embeddedProof["@context"], void 0);
+	assertEquals(embeddedProof.proofValue, standaloneInner.proof.proofValue);
+	const compactedStandalone = structuredClone(standaloneInner);
+	const compactedStandaloneProof = compactedStandalone.proof;
+	delete compactedStandalone["@context"];
+	delete compactedStandaloneProof["@context"];
+	assertEquals(embedded, compactedStandalone);
+	assertEquals((await verifyProof(standaloneInner, standaloneProof, options))?.id, innerKeyId);
+	const rewrittenContext = structuredClone(standaloneInner);
+	rewrittenContext["@context"] = context;
+	assertEquals(await verifyProof(rewrittenContext, standaloneProof, options), null);
+	assertEquals(await verifyProof(embedded, standaloneProof, options), null);
+	assertEquals((await verifyProof(compound, await parseProof(compound), options))?.id, outerKeyId);
+	const reparsedInner = await Note.fromJsonLd(standaloneInner, {
+		contextLoader: mockDocumentLoader,
+		documentLoader: mockDocumentLoader
+	});
+	assert(reparsedInner instanceof Note);
+	assertEquals(await reparsedInner.toJsonLd(), standaloneInner);
+	const reparsedCompound = await normalizeOutgoingActivityJsonLd(await (await signObject(new Create({
+		id: parseIri(`ap+ef61://${outerDid}/activities/reparsed-context`),
+		actor: parseIri(`ap+ef61://${outerDid}/actor`),
+		object: reparsedInner
+	}), outerPrivateKey, outerKeyId, {
+		...options,
+		created
+	})).toJsonLd({
+		format: "compact",
+		...options
+	}), mockDocumentLoader);
+	const reparsedEmbedded = reparsedCompound.object;
+	const reparsedEmbeddedProof = reparsedEmbedded.proof;
+	assertEquals(reparsedEmbedded["@context"], void 0);
+	assertEquals(reparsedEmbeddedProof["@context"], void 0);
+	assertEquals(reparsedEmbeddedProof.proofValue, standaloneInner.proof.proofValue);
+	assertEquals(reparsedEmbedded, compactedStandalone);
+	assertEquals(reparsedEmbedded, embedded);
+	assertEquals(await verifyProof(reparsedEmbedded, standaloneProof, options), null);
+	assertEquals((await verifyProof(reparsedCompound, await parseProof(reparsedCompound), options))?.id, outerKeyId);
+});
+test("verifyProof() does not invent a missing child context", async () => {
+	const received = structuredClone(map_local_create_note_default.documents.finalSecuredCompound);
+	const receivedInner = received.object;
+	const receivedInnerProof = receivedInner.proof;
+	delete receivedInner["@context"];
+	delete receivedInnerProof["@context"];
+	const inboundOptions = {
+		contextLoader: preloadedOnlyDocumentLoader,
+		documentLoader: preloadedOnlyDocumentLoader
+	};
+	const snapshot = structuredClone(received);
+	const proof = await DataIntegrityProof.fromJsonLd(received.proof, inboundOptions);
+	assertEquals(await verifyProof(received, proof, inboundOptions), null);
+	assertEquals(received, snapshot);
+	const guessed = structuredClone(received);
+	const guessedInner = guessed.object;
+	const guessedInnerProof = guessedInner.proof;
+	guessedInner["@context"] = structuredClone(guessed["@context"]);
+	guessedInnerProof["@context"] = structuredClone(guessed["@context"]);
+	assertEquals((await verifyProof(guessed, proof, inboundOptions))?.id, outerKeyId);
+});
+//#endregion
+export {};

package/dist/sig/http.test.mjs

@@ -10,8 +10,8 @@ import { t as assertThrows } from "../assert_throws-BJ5wuvR2.mjs";
 import "../std__assert-CxFT0MNt.mjs";
 import { t as assertRejects } from "../assert_rejects-wFbSPn1O.mjs";
 import { t as assert } from "../assert-CebeUf0C.mjs";
-import { t as exportJwk } from "../key-BVjgbs_9.mjs";
-import { a as parseRfc9421Signature, c as timingSafeEqual, i as formatRfc9421SignatureParameters, l as verifyRequest, n as doubleKnock, o as parseRfc9421SignatureInput, r as formatRfc9421Signature, s as signRequest, t as createRfc9421SignatureBase, u as verifyRequestDetailed } from "../http-D7LX-BL9.mjs";
+import { t as exportJwk } from "../key-Ccs8cnd7.mjs";
+import { a as parseRfc9421Signature, c as timingSafeEqual, i as formatRfc9421SignatureParameters, l as verifyRequest, n as doubleKnock, o as parseRfc9421SignatureInput, r as formatRfc9421Signature, s as signRequest, t as createRfc9421SignatureBase, u as verifyRequestDetailed } from "../http-D9urSO2D.mjs";
 import { i as rsaPrivateKey2, l as rsaPublicKey5, o as rsaPublicKey1, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
 import { createTestMeterProvider, createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { FetchError, exportSpki } from "@fedify/vocab-runtime";

package/dist/sig/key.test.mjs

@@ -5,7 +5,8 @@ import { t as assertEquals } from "../assert_equals-CBlRfA-_.mjs";
 import { t as assertThrows } from "../assert_throws-BJ5wuvR2.mjs";
 import "../std__assert-CxFT0MNt.mjs";
 import { t as assertRejects } from "../assert_rejects-wFbSPn1O.mjs";
-import { a as importJwk, i as generateCryptoKeyPair, n as fetchKey, o as validateCryptoKey, r as fetchKeyDetailed, t as exportJwk } from "../key-BVjgbs_9.mjs";
+import { t as assert } from "../assert-CebeUf0C.mjs";
+import { a as generateCryptoKeyPair, i as fetchKeyDetailed, o as importJwk, r as fetchKey, s as validateCryptoKey, t as exportJwk } from "../key-Ccs8cnd7.mjs";
 import { c as rsaPublicKey3, i as rsaPrivateKey2, o as rsaPublicKey1, r as ed25519PublicKey, s as rsaPublicKey2, t as ed25519Multikey } from "../keys-DIJNHW-Y.mjs";
 import { CryptographicKey, Multikey } from "@fedify/vocab";
 import { createTestMeterProvider, createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
@@ -267,7 +268,7 @@ test("fetchKeyDetailed()", async () => {
 		key: rsaPublicKey1,
 		cached: false
 	});
-	assertEquals(documentLoaderCalls, 1);
+	assertEquals(documentLoaderCalls, 2);
 	const spans = exporter.getSpans("activitypub.fetch_key");
 	assertEquals(spans.length, 2);
 	assertEquals(spans[0].attributes["activitypub.actor.key.cached"], true);
@@ -679,5 +680,171 @@ test("fetchKey() returns null for a malformed actor publicKey", async () => {
 		cached: true
 	});
 });
+test("fetchKey() rejects a key whose owner does not link back", async () => {
+	const keyId = "https://attacker.example/key";
+	const keyDocument = await rsaPublicKey1.toJsonLd({ contextLoader: mockDocumentLoader });
+	const serveKeyOwnedBy = (owner) => ({
+		documentLoader(resource) {
+			if (resource === keyId) return Promise.resolve({
+				contextUrl: null,
+				documentUrl: resource,
+				document: {
+					...keyDocument,
+					id: keyId,
+					owner
+				}
+			});
+			return mockDocumentLoader(resource);
+		},
+		contextLoader: mockDocumentLoader
+	});
+	assertEquals(await fetchKey(keyId, CryptographicKey, serveKeyOwnedBy("https://example.com/person")), {
+		key: null,
+		cached: false
+	});
+	assertEquals(await fetchKey(keyId, CryptographicKey, serveKeyOwnedBy("https://impersonated.invalid/users/victim")), {
+		key: null,
+		cached: false
+	});
+});
+test("fetchKey() rejects a Multikey whose controller does not link back", async () => {
+	const keyId = "https://attacker.example/multikey";
+	const keyDocument = await ed25519Multikey.toJsonLd({ contextLoader: mockDocumentLoader });
+	assertEquals(await fetchKey(keyId, Multikey, {
+		documentLoader(resource) {
+			if (resource === keyId) return Promise.resolve({
+				contextUrl: null,
+				documentUrl: resource,
+				document: {
+					...keyDocument,
+					id: keyId,
+					controller: "https://example.com/person2"
+				}
+			});
+			return mockDocumentLoader(resource);
+		},
+		contextLoader: mockDocumentLoader
+	}), {
+		key: null,
+		cached: false
+	});
+});
+test("fetchKey() rejects an actor document from another origin", async () => {
+	const keyId = "https://attacker.example/key";
+	const impersonated = "https://example.com/person";
+	const { publicKeyPem } = await rsaPublicKey1.toJsonLd({ contextLoader: mockDocumentLoader });
+	assertEquals(await fetchKey(keyId, CryptographicKey, {
+		documentLoader(resource) {
+			if (resource === keyId) return Promise.resolve({
+				contextUrl: null,
+				documentUrl: resource,
+				document: {
+					"@context": ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/v1"],
+					id: impersonated,
+					type: "Person",
+					publicKey: [{
+						id: `${impersonated}#main-key`,
+						type: "CryptographicKey",
+						owner: impersonated,
+						publicKeyPem
+					}]
+				}
+			});
+			return mockDocumentLoader(resource);
+		},
+		contextLoader: mockDocumentLoader
+	}), {
+		key: null,
+		cached: false
+	});
+});
+test("fetchKey() rejects a key that disowns the actor document holding it", async () => {
+	const actorId = "https://attacker.example/actor";
+	const keyId = `${actorId}#main-key`;
+	const { publicKeyPem } = await rsaPublicKey1.toJsonLd({ contextLoader: mockDocumentLoader });
+	assertEquals(await fetchKey(keyId, CryptographicKey, {
+		documentLoader(resource) {
+			if (resource === keyId || resource === actorId) return Promise.resolve({
+				contextUrl: null,
+				documentUrl: resource,
+				document: {
+					"@context": ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/v1"],
+					id: actorId,
+					type: "Person",
+					publicKey: [{
+						id: keyId,
+						type: "CryptographicKey",
+						owner: "https://example.com/person",
+						publicKeyPem
+					}]
+				}
+			});
+			return mockDocumentLoader(resource);
+		},
+		contextLoader: mockDocumentLoader
+	}), {
+		key: null,
+		cached: false
+	});
+});
+test("fetchKey() records the owner its actor document establishes", async () => {
+	const { key } = await fetchKey("https://example.com/users/handle#main-key", CryptographicKey, {
+		documentLoader: mockDocumentLoader,
+		contextLoader: mockDocumentLoader
+	});
+	assertEquals(key?.ownerId, new URL("https://example.com/users/handle"));
+});
+test("fetchKey() accepts a key document that leaves its id implicit", async () => {
+	const keyId = "https://example.com/key";
+	const keyDocument = await rsaPublicKey1.toJsonLd({ contextLoader: mockDocumentLoader });
+	delete keyDocument.id;
+	const { key } = await fetchKey(keyId, CryptographicKey, {
+		documentLoader(resource) {
+			if (resource === keyId) return Promise.resolve({
+				contextUrl: null,
+				documentUrl: resource,
+				document: keyDocument
+			});
+			return mockDocumentLoader(resource);
+		},
+		contextLoader: mockDocumentLoader
+	});
+	assertEquals(key?.id, new URL(keyId));
+	assertEquals(key?.ownerId, new URL("https://example.com/person"));
+	assert(key?.publicKey != null);
+});
+test("fetchKey() records the controller an actor document establishes", async () => {
+	const actorId = "https://example.com/multikey-actor";
+	const keyId = `${actorId}#assertion`;
+	const { publicKeyMultibase } = await ed25519Multikey.toJsonLd({ contextLoader: mockDocumentLoader });
+	const { key } = await fetchKey(keyId, Multikey, {
+		documentLoader(resource) {
+			if (resource === actorId || resource === keyId) return Promise.resolve({
+				contextUrl: null,
+				documentUrl: actorId,
+				document: {
+					"@context": [
+						"https://www.w3.org/ns/activitystreams",
+						"https://w3id.org/security/v1",
+						"https://w3id.org/security/multikey/v1",
+						"https://w3id.org/security/data-integrity/v1",
+						"https://www.w3.org/ns/did/v1"
+					],
+					id: actorId,
+					type: "Person",
+					assertionMethod: [{
+						id: keyId,
+						type: "Multikey",
+						publicKeyMultibase
+					}]
+				}
+			});
+			return mockDocumentLoader(resource);
+		},
+		contextLoader: mockDocumentLoader
+	});
+	assertEquals(key?.controllerId, new URL(actorId));
+	assert(key?.publicKey != null);
+});
 //#endregion
 export {};

package/dist/sig/ld.test.mjs

@@ -4,12 +4,13 @@ globalThis.addEventListener = () => {};
 import { t as assertEquals } from "../assert_equals-CBlRfA-_.mjs";
 import { t as assertFalse } from "../assert_false-3pLLLsO4.mjs";
 import { t as assertGreaterOrEqual } from "../assert_greater_or_equal-BApOTh1h.mjs";
+import { t as assertInstanceOf } from "../assert_instance_of-g3WcyYNR.mjs";
 import { t as assertThrows } from "../assert_throws-BJ5wuvR2.mjs";
 import { t as assertRejects } from "../assert_rejects-wFbSPn1O.mjs";
 import { t as assert } from "../assert-CebeUf0C.mjs";
-import { i as generateCryptoKeyPair } from "../key-BVjgbs_9.mjs";
+import { a as generateCryptoKeyPair } from "../key-Ccs8cnd7.mjs";
 import { a as rsaPrivateKey3, c as rsaPublicKey3, i as rsaPrivateKey2, n as ed25519PrivateKey, s as rsaPublicKey2, t as ed25519Multikey } from "../keys-DIJNHW-Y.mjs";
-import { a as compactJsonLd, f as isInvalidUrlTypeError, g as verifySignature, h as verifyJsonLd, i as attachSignature, n as UnsafeJsonLdError, o as createSignature, p as signJsonLd, s as detachSignature, u as hasSignatureLike } from "../ld-OuCeQFny.mjs";
+import { a as compactJsonLd, f as isInvalidUrlTypeError, g as verifySignature, h as verifyJsonLd, i as attachSignature, n as UnsafeJsonLdError, o as createSignature, p as signJsonLd, s as detachSignature, u as hasSignatureLike } from "../ld-qup__MAW.mjs";
 import { CryptographicKey } from "@fedify/vocab";
 import { createTestMeterProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { encodeBase64 } from "byte-encodings/base64";
@@ -940,5 +941,57 @@ test("compactJsonLd() rejects inputs that compact into @graph wrappers", async (
 		content: "two"
 	}], mockDocumentLoader), UnsafeJsonLdError, "Unsupported JSON-LD keyword: @graph.");
 });
+test("verifyJsonLd() rejects a key that claims a forged owner", async () => {
+	const keyId = new URL("https://attacker.example/key");
+	const impersonated = "https://example.com/person";
+	const { publicKeyPem } = await rsaPublicKey2.toJsonLd({ contextLoader: mockDocumentLoader });
+	const signed = await signJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id: "https://attacker.example/activities/1",
+		type: "Create",
+		actor: impersonated
+	}, rsaPrivateKey2, keyId, { contextLoader: mockDocumentLoader });
+	const serveKeyOwnedBy = (owner) => (resource) => {
+		if (resource === keyId.href) return Promise.resolve({
+			contextUrl: null,
+			documentUrl: resource,
+			document: {
+				"@context": "https://w3id.org/security/v1",
+				id: keyId.href,
+				type: "CryptographicKey",
+				owner,
+				publicKeyPem
+			}
+		});
+		if (resource === "https://attacker.example/actor") return Promise.resolve({
+			contextUrl: null,
+			documentUrl: resource,
+			document: {
+				"@context": ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/v1"],
+				id: resource,
+				type: "Person",
+				publicKey: [keyId.href]
+			}
+		});
+		return mockDocumentLoader(resource);
+	};
+	assertEquals(await verifySignature(signed, {
+		documentLoader: serveKeyOwnedBy(impersonated),
+		contextLoader: mockDocumentLoader
+	}), null);
+	assertFalse(await verifyJsonLd(signed, {
+		documentLoader: serveKeyOwnedBy(impersonated),
+		contextLoader: mockDocumentLoader
+	}));
+	const honestLoader = serveKeyOwnedBy("https://attacker.example/actor");
+	assertInstanceOf(await verifySignature(signed, {
+		documentLoader: honestLoader,
+		contextLoader: mockDocumentLoader
+	}), CryptographicKey);
+	assertFalse(await verifyJsonLd(signed, {
+		documentLoader: honestLoader,
+		contextLoader: mockDocumentLoader
+	}));
+});
 //#endregion
 export {};

package/dist/sig/mod.cjs

@@ -1,31 +1,31 @@
 const { URLPattern } = require("urlpattern-polyfill");
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_http = require("../http-B3skRvGo.cjs");
-const require_proof = require("../proof-Dua0d906.cjs");
-exports.attachSignature = require_proof.attachSignature;
-exports.createProof = require_proof.createProof;
-exports.createSignature = require_proof.createSignature;
-exports.detachSignature = require_proof.detachSignature;
-exports.doesActorOwnKey = require_proof.doesActorOwnKey;
+const require_http = require("../http-CRFns-UE.cjs");
+const require_owner = require("../owner-CVA7L9MA.cjs");
+exports.attachSignature = require_owner.attachSignature;
+exports.createProof = require_owner.createProof;
+exports.createSignature = require_owner.createSignature;
+exports.detachSignature = require_owner.detachSignature;
+exports.doesActorOwnKey = require_owner.doesActorOwnKey;
 exports.exportJwk = require_http.exportJwk;
 exports.fetchKey = require_http.fetchKey;
 exports.fetchKeyDetailed = require_http.fetchKeyDetailed;
 exports.formatAcceptSignature = require_http.formatAcceptSignature;
 exports.fulfillAcceptSignature = require_http.fulfillAcceptSignature;
 exports.generateCryptoKeyPair = require_http.generateCryptoKeyPair;
-exports.getKeyOwner = require_proof.getKeyOwner;
-exports.hasProofLike = require_proof.hasProofLike;
-exports.hasSignatureLike = require_proof.hasSignatureLike;
+exports.getKeyOwner = require_owner.getKeyOwner;
+exports.hasProofLike = require_owner.hasProofLike;
+exports.hasSignatureLike = require_owner.hasSignatureLike;
 exports.importJwk = require_http.importJwk;
 exports.parseAcceptSignature = require_http.parseAcceptSignature;
-exports.signJsonLd = require_proof.signJsonLd;
-exports.signObject = require_proof.signObject;
+exports.signJsonLd = require_owner.signJsonLd;
+exports.signObject = require_owner.signObject;
 exports.signRequest = require_http.signRequest;
 exports.validateAcceptSignature = require_http.validateAcceptSignature;
-exports.verifyJsonLd = require_proof.verifyJsonLd;
-exports.verifyObject = require_proof.verifyObject;
-exports.verifyPortableObjectProof = require_proof.verifyPortableObjectProof;
-exports.verifyProof = require_proof.verifyProof;
+exports.verifyJsonLd = require_owner.verifyJsonLd;
+exports.verifyObject = require_owner.verifyObject;
+exports.verifyPortableObjectProof = require_owner.verifyPortableObjectProof;
+exports.verifyProof = require_owner.verifyProof;
 exports.verifyRequest = require_http.verifyRequest;
 exports.verifyRequestDetailed = require_http.verifyRequestDetailed;
-exports.verifySignature = require_proof.verifySignature;
+exports.verifySignature = require_owner.verifySignature;

package/dist/sig/mod.d.cts

@@ -1,5 +1,5 @@
 /// <reference lib="esnext.temporal" />
-import { C as exportJwk, D as importJwk, E as generateCryptoKeyPair, S as KeyCache, T as fetchKeyDetailed, _ as validateAcceptSignature, a as VerifyRequestDetailedResult, b as FetchKeyOptions, c as signRequest, d as AcceptSignatureMember, f as AcceptSignatureParameters, g as parseAcceptSignature, h as fulfillAcceptSignature, i as SignRequestOptions, l as verifyRequest, m as formatAcceptSignature, n as HttpMessageSignaturesSpecDeterminer, o as VerifyRequestFailureReason, p as FulfillAcceptSignatureResult, r as Rfc9421SignRequestOptions, s as VerifyRequestOptions, t as HttpMessageSignaturesSpec, u as verifyRequestDetailed, v as FetchKeyDetailedResult, w as fetchKey, x as FetchKeyResult, y as FetchKeyErrorResult } from "../http-6TI0tI03.cjs";
-import { i as getKeyOwner, n as GetKeyOwnerOptions, r as doesActorOwnKey, t as DoesActorOwnKeyOptions } from "../owner-r_waTiQj.cjs";
-import { C as verifyJsonLd, S as signJsonLd, _ as VerifySignatureOptions, a as VerifyPortableObjectProofOptions, b as detachSignature, c as createProof, d as verifyObject, f as verifyPortableObjectProof, g as VerifyJsonLdOptions, h as SignJsonLdOptions, i as VerifyPortableObjectProofFailureReason, l as hasProofLike, m as CreateSignatureOptions, n as SignObjectOptions, o as VerifyPortableObjectProofResult, p as verifyProof, r as VerifyObjectOptions, s as VerifyProofOptions, t as CreateProofOptions, u as signObject, v as attachSignature, w as verifySignature, x as hasSignatureLike, y as createSignature } from "../mod-CnGLNoVw.cjs";
+import { C as exportJwk, D as importJwk, E as generateCryptoKeyPair, S as KeyCache, T as fetchKeyDetailed, _ as validateAcceptSignature, a as VerifyRequestDetailedResult, b as FetchKeyOptions, c as signRequest, d as AcceptSignatureMember, f as AcceptSignatureParameters, g as parseAcceptSignature, h as fulfillAcceptSignature, i as SignRequestOptions, l as verifyRequest, m as formatAcceptSignature, n as HttpMessageSignaturesSpecDeterminer, o as VerifyRequestFailureReason, p as FulfillAcceptSignatureResult, r as Rfc9421SignRequestOptions, s as VerifyRequestOptions, t as HttpMessageSignaturesSpec, u as verifyRequestDetailed, v as FetchKeyDetailedResult, w as fetchKey, x as FetchKeyResult, y as FetchKeyErrorResult } from "../http-CP-7OdSq.cjs";
+import { i as getKeyOwner, n as GetKeyOwnerOptions, r as doesActorOwnKey, t as DoesActorOwnKeyOptions } from "../owner-BF0L9cMt.cjs";
+import { C as verifyJsonLd, S as signJsonLd, _ as VerifySignatureOptions, a as VerifyPortableObjectProofOptions, b as detachSignature, c as createProof, d as verifyObject, f as verifyPortableObjectProof, g as VerifyJsonLdOptions, h as SignJsonLdOptions, i as VerifyPortableObjectProofFailureReason, l as hasProofLike, m as CreateSignatureOptions, n as SignObjectOptions, o as VerifyPortableObjectProofResult, p as verifyProof, r as VerifyObjectOptions, s as VerifyProofOptions, t as CreateProofOptions, u as signObject, v as attachSignature, w as verifySignature, x as hasSignatureLike, y as createSignature } from "../mod-CbKDOnCt.cjs";
 export { AcceptSignatureMember, AcceptSignatureParameters, CreateProofOptions, CreateSignatureOptions, DoesActorOwnKeyOptions, FetchKeyDetailedResult, FetchKeyErrorResult, FetchKeyOptions, FetchKeyResult, FulfillAcceptSignatureResult, GetKeyOwnerOptions, HttpMessageSignaturesSpec, HttpMessageSignaturesSpecDeterminer, KeyCache, Rfc9421SignRequestOptions, SignJsonLdOptions, SignObjectOptions, SignRequestOptions, VerifyJsonLdOptions, VerifyObjectOptions, VerifyPortableObjectProofFailureReason, VerifyPortableObjectProofOptions, VerifyPortableObjectProofResult, VerifyProofOptions, VerifyRequestDetailedResult, VerifyRequestFailureReason, VerifyRequestOptions, VerifySignatureOptions, attachSignature, createProof, createSignature, detachSignature, doesActorOwnKey, exportJwk, fetchKey, fetchKeyDetailed, formatAcceptSignature, fulfillAcceptSignature, generateCryptoKeyPair, getKeyOwner, hasProofLike, hasSignatureLike, importJwk, parseAcceptSignature, signJsonLd, signObject, signRequest, validateAcceptSignature, verifyJsonLd, verifyObject, verifyPortableObjectProof, verifyProof, verifyRequest, verifyRequestDetailed, verifySignature };