Changeset 5296349 in Klonkt for src/services/ActivityPubService.js

Timestamp:

08/06/2026 10:30:50 AM (5 weeks ago)

Author:

Claude (agent) <aiclaude@…>

Branches:

main

Children:

57aee3b

Parents:

25f2e64

git-author:

Robin <roboburr@…> (08/06/2026 10:30:49 AM)

git-committer:

Claude (agent) <aiclaude@…> (08/06/2026 10:30:50 AM)

Message:

Doorgestuurde activiteiten alsnog verifiëren bij de bron (shaer-s8k)

De inbox eiste dat een activiteit was ondertekend door de actor die hij claimde
te zijn. Bij DOORSTUREN klopt dat niet: reageert iemand in een thread, dan stuurt
de server van de oorspronkelijke poster die reactie door en ondertekent met zijn
EIGEN sleutel. Op boiert.eu leverde dat tientallen geweigerde Creates op van
echte accounts -- reacties die niet aankwamen, zonder dat iemand een fout zag.

Mastodon lost dit op met een LD-Signature over de payload. Dat vraagt
JSON-LD-canonicalisatie; dit doet het lichter en strenger: bij een mismatch
geloven we de bezorgde inhoud NIET en halen we het object op bij de bron.

Vier voorwaarden, en geen ervan is optioneel:

• alleen Create en Update. Een doorgestuurde Delete is niet te dereferencen (het object is weg) en blijft geweigerd.
• de host van de object-id moet die van de geclaimde actor zijn. Zonder dit anker wijst een doorsturer je naar een host die hij zelf beheert, waar attributedTo alles kan beweren.
• het OPGEHAALDE object wordt gebruikt, niet de bezorgde payload. Anders levert een doorsturer een echt id met verdraaide inhoud.
• mislukt het ophalen, wijkt het id af, of schrijft de bron het object niet toe aan de geclaimde actor, dan blijft het een weigering.

Een ongetekende activiteit wordt niet gedereferenced: zonder bewijs van wie het
bezorgde is er niets om op te bouwen. Beide fetch-paden lopen door safeFetch met
zijn SSRF-preflight.

Ook de logregel gesplitst. "(unsigned/invalid)" betekende drie dingen tegelijk;
het onderscheidt nu 'no signature', 'signature present, unverifiable' (meestal
een opgeheven account waarvan de sleutel weg is -- dat verklaart het gros van de
Delete-regels) en 'signer mismatch'.

Acht tests, waarvan zes weiger-gevallen: andere host, verkeerde attributedTo,
bron onbereikbaar, afwijkend id, doorgestuurde Delete, en ongetekend. Die
gebruiken IP-literals uit TEST-NET-3, want safeFetch doet dan geen DNS-lookup en
de test blijft offline.

Suite 449/449.

Co-Authored-By: Claude Opus 5 <noreply@…>

File:

• src/services/ActivityPubService.js (modified) (2 diffs)

src/services/ActivityPubService.js

@@ -1621 +1621 @@
 }
 
+/**
+ * Een DOORGESTUURDE activiteit alsnog verifiëren (shaer-s8k).
+ *
+ * Reageert iemand in een thread, dan stuurt de server van de oorspronkelijke
+ * poster die reactie door naar de deelnemers -- en ondertekent met zijn EIGEN
+ * sleutel. De handtekening klopt dan, maar de ondertekenaar is niet de auteur,
+ * dus de gate hieronder wees hem af. Gevolg: reacties van derden kwamen niet
+ * binnen, zonder dat iemand een fout zag.
+ *
+ * Mastodon lost dit op met een LD-Signature over de payload. Dat vraagt
+ * JSON-LD-canonicalisatie; wij doen het lichter en strenger: we geloven de
+ * bezorgde inhoud NIET en halen het object op bij de bron.
+ *
+ * Vier voorwaarden, en geen ervan is optioneel:
+ *
+ *  1. Alleen Create en Update. Een doorgestuurde Delete is per definitie niet te
+ *     dereferencen -- het object is weg -- dus die blijft geweigerd.
+ *  2. De host van de object-id MOET die van de geclaimde actor zijn. Zonder dit
+ *     anker wijst een doorsturer je naar een host die hij zelf beheert, waar
+ *     attributedTo alles kan beweren.
+ *  3. Het OPGEHAALDE object wordt gebruikt, niet de bezorgde payload. Anders
+ *     levert een doorsturer een echt id met verdraaide inhoud.
+ *  4. Mislukt het ophalen, of wijst het object zichzelf niet toe aan de
+ *     geclaimde actor, dan blijft het een weigering. Geen twijfelgeval opslaan.
+ */
+async function dereferenceForwarded(act, claimedActor, type, slugParam) {
+  if (type !== 'Create' && type !== 'Update') return null;
+  const o = act && act.object;
+  const objId = typeof o === 'string' ? o : (o && o.id);
+  if (!objId || typeof objId !== 'string' || !/^https:\/\//i.test(objId)) return null;
+  try {
+    if (new URL(objId).host !== new URL(claimedActor).host) return null;   // ankereis
+  } catch { return null; }
+  // Ondertekend als de ontvangende site wanneer we die kennen; anders anoniem,
+  // wat voor een publieke note volstaat. Beide gaan door safeFetch.
+  const fetched = await signedGetJson(slugParam, objId).catch(() => null);
+  if (!fetched || fetched.id !== objId) return null;   // ook: geen omleiding naar iets anders
+  const attributed = typeof fetched.attributedTo === 'string'
+    ? fetched.attributedTo
+    : (fetched.attributedTo && fetched.attributedTo.id);
+  if (attributed !== claimedActor) return null;
+  return fetched;
+}
+
 // Handle an incoming inbox POST. slugParam = null for the shared /ap/inbox.
 export async function handleInbox(req, slugParam, preVerified = null) {
@@ -1644 +1688 @@
   const GATED = ['Create', 'Like', 'Announce', 'Follow', 'Delete', 'Undo', 'Accept', 'Reject', 'Add', 'Remove', 'Update', 'Flag', 'Offer', 'Move'];
   if (GATED.includes(type)) {
-    if (!verified || !claimedActor || verified.id !== claimedActor) {
-      console.warn('[AP] inbox REJECTED (signature)', type, claimedActor || '?', 'from', ip, verified ? '(signer mismatch)' : '(unsigned/invalid)');
+    // Een geldige handtekening van iemand anders dan de auteur is doorsturen,
+    // geen vervalsing. Haal het object dan bij de bron op in plaats van het af
+    // te wijzen; lukt dat niet, dan valt het door naar de weigering hieronder.
+    let forwarded = null;
+    if (verified && claimedActor && verified.id !== claimedActor) {
+      forwarded = await dereferenceForwarded(act, claimedActor, type, slugParam).catch(() => null);
+      if (forwarded) {
+        act.object = forwarded;   // de OPGEHAALDE inhoud, niet de bezorgde
+        console.log('[AP] inbox forwarded, geverifieerd bij de bron:', type, claimedActor, 'via', verified.id);
+      }
+    }
+    if (!forwarded && (!verified || !claimedActor || verified.id !== claimedActor)) {
+      // Drie verschillende oorzaken, die eerder allemaal "unsigned/invalid"
+      // heetten: geen handtekening meegestuurd, wel een handtekening maar niet
+      // te verifiëren (meestal een opgeheven account waarvan de sleutel weg is),
+      // of geldig ondertekend door iemand anders.
+      const reden = verified ? '(signer mismatch)'
+        : (req.headers && req.headers.signature) ? '(signature present, unverifiable)'
+        : '(no signature)';
+      console.warn('[AP] inbox REJECTED (signature)', type, claimedActor || '?', 'from', ip, reden);
       return 401;
     }