Merge tag '1.9.9' into 1.10-maintenance

Fedify 1.9.9

Author: dahlia

CHANGES.md

@@ -8,6 +8,23 @@ Version 1.10.8
 
 To be released.
 
+### @fedify/fedify
+
+ -  Fixed `Context.getActorKeyPairs()` assigning the same key ID to both
+    the `CryptographicKey` (used for HTTP Signatures and Linked Data
+    Signatures) and the `Multikey` (used for Object Integrity Proofs) within
+    an `ActorKeyPair`.  The `Multikey` now receives a distinct ID
+    (`#multikey-1`, `#multikey-2`, …) so that the actor document no longer
+    contains two objects sharing the same `id`, which was invalid JSON-LD.
+    Object Integrity Proof signatures now reference the correct `Multikey` ID
+    instead of the `CryptographicKey` ID.  [[#663]]
+
+ -  Object Integrity Proofs signing now takes place before activity fanout,
+    so all recipients receive the same pre-signed activity.  Previously, OIP
+    signing was deferred until after fanout, meaning each fanout worker would
+    re-sign independently with potentially different timestamps and the fanout
+    message itself contained an unsigned activity.
+
 
 Version 1.10.7
 --------------
@@ -209,6 +226,31 @@ Released on December 24, 2025.
  -  Implemented `list()` method in `WorkersKvStore`.  [[#498], [#500]]
 
 
+Version 1.9.9
+-------------
+
+Released on April 8, 2026.
+
+### @fedify/fedify
+
+ -  Fixed `Context.getActorKeyPairs()` assigning the same key ID to both
+    the `CryptographicKey` (used for HTTP Signatures and Linked Data
+    Signatures) and the `Multikey` (used for Object Integrity Proofs) within
+    an `ActorKeyPair`.  The `Multikey` now receives a distinct ID
+    (`#multikey-1`, `#multikey-2`, …) so that the actor document no longer
+    contains two objects sharing the same `id`, which was invalid JSON-LD.
+    Object Integrity Proof signatures now reference the correct `Multikey` ID
+    instead of the `CryptographicKey` ID.  [[#663]]
+
+ -  Object Integrity Proofs signing now takes place before activity fanout,
+    so all recipients receive the same pre-signed activity.  Previously, OIP
+    signing was deferred until after fanout, meaning each fanout worker would
+    re-sign independently with potentially different timestamps and the fanout
+    message itself contained an unsigned activity.
+
+[#663]: https://github.com/fedify-dev/fedify/issues/663
+
+
 Version 1.9.8
 -------------
 

packages/fedify/src/federation/context.ts

@@ -873,7 +873,10 @@ export interface GetSignedKeyOptions {
  */
 export interface ActorKeyPair extends CryptoKeyPair {
   /**
-   * The URI of the public key, which is used for verifying HTTP Signatures.
+   * The URI of the public key for {@link CryptographicKey}, which is used for
+   * verifying HTTP Signatures and Linked Data Signatures.  Note that this is
+   * the ID of the {@link cryptographicKey}, not of the {@link multikey};
+   * the {@link Multikey} instance has a distinct ID of its own.
    */
   keyId: URL;
 

packages/fedify/src/federation/middleware.test.ts

@@ -330,7 +330,7 @@ test({
               owner: new URL("https://example.com/users/handle"),
             }),
             multikey: new Multikey({
-              id: new URL("https://example.com/users/handle#main-key"),
+              id: new URL("https://example.com/users/handle#multikey-1"),
               controller: new URL("https://example.com/users/handle"),
               publicKey: rsaPublicKey2.publicKey!,
             }),
@@ -344,7 +344,7 @@ test({
               owner: new URL("https://example.com/users/handle"),
             }),
             multikey: new Multikey({
-              id: new URL("https://example.com/users/handle#key-2"),
+              id: new URL("https://example.com/users/handle#multikey-2"),
               controller: new URL("https://example.com/users/handle"),
               publicKey: ed25519PublicKey.publicKey!,
             }),
@@ -1691,9 +1691,10 @@ test("ContextImpl.sendActivity()", async (t) => {
           const keys = await ctx.getActorKeyPairs("1");
           for (const key of keys) {
             if (key.keyId.href === keyId.href) {
-              if (key.publicKey.algorithm.name === "Ed25519") {
-                return key.multikey;
-              } else return key.cryptographicKey;
+              return key.cryptographicKey;
+            }
+            if (key.multikey.id?.href === keyId.href) {
+              return key.multikey;
             }
           }
           return undefined;
@@ -1927,30 +1928,44 @@ test("ContextImpl.sendActivity()", async (t) => {
       activity,
       { fanout: "force" },
     );
-    assertEquals(queue.messages, [
-      {
-        id: queue.messages[0].id,
-        type: "fanout",
-        activity: await activity.toJsonLd({
-          format: "compact",
-          contextLoader: fetchDocumentLoader,
-        }),
-        activityId: "https://example.com/activity/1",
-        activityType: "https://www.w3.org/ns/activitystreams#Create",
-        baseUrl: "https://example.com",
-        collectionSync: undefined,
-        inboxes: {
-          "https://example.com/inbox": {
-            actorIds: [
-              "https://example.com/recipient",
-            ],
-            sharedInbox: false,
-          },
-        },
-        keys: queue.messages[0].type === "fanout" ? queue.messages[0].keys : [],
-        traceContext: {},
+    assertEquals(queue.messages.length, 1);
+    assert(queue.messages[0].type === "fanout");
+    const fanoutMsg = queue.messages[0];
+    assertEquals(fanoutMsg.activityId, "https://example.com/activity/1");
+    assertEquals(
+      fanoutMsg.activityType,
+      "https://www.w3.org/ns/activitystreams#Create",
+    );
+    assertEquals(fanoutMsg.baseUrl, "https://example.com");
+    assertEquals(fanoutMsg.collectionSync, undefined);
+    assertEquals(fanoutMsg.inboxes, {
+      "https://example.com/inbox": {
+        actorIds: ["https://example.com/recipient"],
+        sharedInbox: false,
       },
-    ]);
+    });
+    // Regression test for <https://github.com/fedify-dev/fedify/issues/663>:
+    // The activity in the fanout message should be pre-signed with OIP before
+    // fanout, and the proof must reference the Multikey ID (#multikey-N),
+    // not the CryptographicKey ID (#main-key or #key-N):
+    const signedActivity = await Create.fromJsonLd(fanoutMsg.activity, {
+      contextLoader: fetchDocumentLoader,
+      documentLoader: fetchDocumentLoader,
+    });
+    assertEquals(signedActivity.id?.href, "https://example.com/activity/1");
+    let proofCount = 0;
+    for await (
+      const proof of signedActivity.getProofs({
+        contextLoader: fetchDocumentLoader,
+      })
+    ) {
+      assertEquals(
+        proof.verificationMethodId?.href,
+        "https://example.com/john#multikey-2",
+      );
+      proofCount++;
+    }
+    assertEquals(proofCount, 1);
   });
 
   queue.clear();

packages/fedify/src/federation/middleware.ts

@@ -1021,14 +1021,23 @@ export class FederationImpl<TContextData>
       validateCryptoKey(privateKey, "private");
       if (rsaKey == null && privateKey.algorithm.name === "RSASSA-PKCS1-v1_5") {
         rsaKey = { keyId, privateKey };
-        continue;
       }
-      if (privateKey.algorithm.name === "Ed25519") {
-        activity = await signObject(activity, privateKey, keyId, {
-          contextLoader,
-          tracerProvider: this.tracerProvider,
-        });
-        proofCreated = true;
+    }
+    // If Object Integrity Proofs were already created before fanout (e.g., in
+    // sendActivityInternal()), skip signing to avoid duplicates.
+    for await (const _ of activity.getProofs({ contextLoader })) {
+      proofCreated = true;
+      break;
+    }
+    if (!proofCreated) {
+      for (const { keyId, privateKey } of keys) {
+        if (privateKey.algorithm.name === "Ed25519") {
+          activity = await signObject(activity, privateKey, keyId, {
+            contextLoader,
+            tracerProvider: this.tracerProvider,
+          });
+          proofCreated = true;
+        }
       }
     }
     let jsonLd = await activity.toJsonLd({
@@ -1920,6 +1929,7 @@ export class ContextImpl<TContextData> implements Context<TContextData> {
     }
     const owner = this.getActorUri(identifier);
     const result = [];
+    let i = 1;
     for (const keyPair of keyPairs) {
       const newPair: ActorKeyPair = {
         ...keyPair,
@@ -1929,12 +1939,13 @@ export class ContextImpl<TContextData> implements Context<TContextData> {
           publicKey: keyPair.publicKey,
         }),
         multikey: new Multikey({
-          id: keyPair.keyId,
+          id: new URL(`#multikey-${i}`, owner),
           controller: owner,
           publicKey: keyPair.publicKey,
         }),
       };
       result.push(newPair);
+      i++;
     }
     return result;
   }
@@ -2192,6 +2203,7 @@ export class ContextImpl<TContextData> implements Context<TContextData> {
     const logger = getLogger(["fedify", "federation", "outbox"]);
     let keys: SenderKeyPair[];
     let identifier: string | null = null;
+    let actorKeyPairs: ActorKeyPair[] | null = null;
     if ("identifier" in sender || "username" in sender || "handle" in sender) {
       if ("identifier" in sender) {
         identifier = sender.identifier;
@@ -2225,12 +2237,19 @@ export class ContextImpl<TContextData> implements Context<TContextData> {
         }
       }
       span.setAttribute("fedify.actor.identifier", identifier);
-      keys = await this.getKeyPairsFromIdentifier(identifier);
-      if (keys.length < 1) {
+      if (this.federation.actorCallbacks?.keyPairsDispatcher == null) {
+        throw new Error("No actor key pairs dispatcher registered.");
+      }
+      actorKeyPairs = await this.getActorKeyPairs(identifier);
+      if (actorKeyPairs.length < 1) {
         throw new Error(
           `No key pair found for actor ${JSON.stringify(identifier)}.`,
         );
       }
+      keys = actorKeyPairs.map((kp) => ({
+        keyId: kp.keyId,
+        privateKey: kp.privateKey,
+      }));
     } else if (Array.isArray(sender)) {
       if (sender.length < 1) {
         throw new Error("The sender's key pairs are empty.");
@@ -2288,6 +2307,22 @@ export class ContextImpl<TContextData> implements Context<TContextData> {
         "The activity to send must have at least one actor property.",
       );
     }
+    // Pre-sign with Object Integrity Proofs before fanout so that all
+    // recipients receive the same signed activity.  Uses Multikey IDs so that
+    // verifiers can look up the correct key type in the actor document.
+    if (actorKeyPairs != null) {
+      const contextLoader = this.contextLoader;
+      for (const kp of actorKeyPairs) {
+        if (
+          kp.privateKey.algorithm.name !== "Ed25519" ||
+          kp.multikey.id == null
+        ) continue;
+        activity = await signObject(activity, kp.privateKey, kp.multikey.id, {
+          contextLoader,
+          tracerProvider: this.tracerProvider,
+        });
+      }
+    }
     const inboxes = extractInboxes({
       recipients: expandedRecipients,
       preferSharedInbox: options.preferSharedInbox,
@@ -2840,12 +2875,16 @@ export class InboxContextImpl<TContextData> extends ContextImpl<TContextData>
           identifier = mapped;
         }
       }
-      keys = await this.getKeyPairsFromIdentifier(identifier);
-      if (keys.length < 1) {
+      const actorKeyPairs = await this.getActorKeyPairs(identifier);
+      if (actorKeyPairs.length < 1) {
         throw new Error(
           `No key pair found for actor ${JSON.stringify(identifier)}.`,
         );
       }
+      keys = actorKeyPairs.map((kp) => ({
+        keyId: kp.keyId,
+        privateKey: kp.privateKey,
+      }));
     } else if (Array.isArray(forwarder)) {
       if (forwarder.length < 1) {
         throw new Error("The forwarder's key pairs are empty.");