Changeset 0bafe9e in Klonkt

Timestamp:

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

Author:

Claude (agent) <aiclaude@…>

Branches:

main

Children:

d74a461

Parents:

5d0d41d

git-author:

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

git-committer:

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

Message:

Niet standaard ondertekenen bij de sleutel-ophaal (regressie van 9561d58)

Robins vraag legde bloot wat ik een uur eerder zelf had verslechterd.
verifyRequest haalt de keyId-URL op VOORDAT er iets geverifieerd is, en die URL
komt uit een header die iedereen mag sturen. Sinds 9561d58 werd dat verzoek
standaard ondertekend als een van onze actors -- dus kon een volslagen onbekende
met één POST boiert een ONDERTEKEND verzoek laten sturen naar een adres van zijn
keuze, met onze identiteit eronder. Dat is hoe een instance op een blocklist
belandt.

fetchActor probeert nu onbetekend eerst en tekent alleen als dat niets bruikbaars
oplevert. Voor een instance met authorized fetch verandert er niets behalve één
extra verzoek; voor alle andere verdwijnt de handtekening weer. Een document dat
onbetekend wél komt maar zonder publicKey telt als mislukt -- voor een
verificatie heb je daar niets aan.

Twee tests erbij die de VOLGORDE vastleggen, want dat is hier de hele zaak: een
open instance krijgt precies één, onbetekend verzoek, en een kaal document leidt
tot een tweede, ondertekende poging.

Wat hiermee NIET is opgelost, en in shaer-afq staat: de ophaal blijft aanroepbaar
door een onbekende, alleen niet meer namens ons. Het smaller maken van de
dereference (alleen bij een inReplyTo die we kennen) en het onthouden van
mislukte pogingen zijn aparte stappen.

Suite 454/454.

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

Files:

• src/services/ActivityPubService.js (modified) (1 diff)
• test/authorized-fetch.test.js (modified) (1 diff)

src/services/ActivityPubService.js

@@ -1295 +1295 @@
   // Geen kip-ei: om ONZE handtekening te controleren haalt de andere kant ons
   // actor-document op, en dat serveert Klonkt publiek.
-  if (opts.asSlug) {
-    const signed = await signedGetJson(opts.asSlug, url).catch(() => null);
-    if (signed && signed.id) return signed;
-    // Geen terugkeer bij mislukking: een instance zonder secure mode moet
-    // blijven werken, en niet elke 401 komt van authorized fetch.
-  }
+  //
+  // ONBETEKEND EERST, en dat is een veiligheidskeuze en geen optimalisatie.
+  // verifyRequest haalt de keyId-URL op VOORDAT er iets geverifieerd is, en die
+  // URL komt uit een header die iedereen mag sturen. Tekenden we dat verzoek
+  // standaard, dan kan een volslagen onbekende ons een ONDERTEKEND verzoek laten
+  // sturen naar een adres van zijn keuze -- met onze identiteit eronder. Dat is
+  // precies hoe een instance op een blocklist belandt. Ondertekenen doen we dus
+  // pas als het onbetekend niet lukt, en dan alleen voor deze ene URL.
+  let doc = null;
   try {
     const r = await safeFetch(url, { headers: { Accept: 'application/activity+json' } });
-    if (!r.ok) return null;
-    const len = Number(r.headers.get('content-length') || 0);
-    if (len > 2_000_000) return null; // refuse oversized actor docs
-    return await r.json();
-  } catch { return null; }
+    if (r.ok) {
+      const len = Number(r.headers.get('content-length') || 0);
+      if (len > 2_000_000) return null; // refuse oversized actor docs
+      doc = await r.json();
+    }
+  } catch { /* val door naar de ondertekende poging */ }
+  // Genoeg? Dan klaar. Sommige instances serveren onbetekend wel een document
+  // maar zonder sleutel; voor een verificatie hebben we daar niets aan, dus die
+  // telt als mislukt.
+  if (doc && (!opts.asSlug || (doc.publicKey && doc.publicKey.publicKeyPem))) return doc;
+  if (!opts.asSlug) return doc;
+  const signed = await signedGetJson(opts.asSlug, url).catch(() => null);
+  return (signed && signed.id) ? signed : doc;
 }
 

test/authorized-fetch.test.js

@@ -66 +66 @@
 });
 
-test('mislukt ondertekend ophalen, dan volgt de onbetekende poging alsnog', async () => {
-  // Niet elke 401 komt van secure mode, en een instance die geen handtekening
-  // verwacht mag er niet door stukgaan. OPEN_ACTOR antwoordt op allebei, dus we
-  // meten dat er ECHT twee pogingen zijn wanneer de eerste niets oplevert.
+test('een OPEN instance wordt NIET ondertekend opgehaald', () => {
+  // De veiligheidskant van shaer-afq: verifyRequest haalt de keyId-URL op
+  // voordat er iets geverifieerd is, en die URL komt uit een header die iedereen
+  // mag sturen. Tekenden we standaard, dan kan een vreemde ons een ondertekend
+  // verzoek naar een adres van zijn keuze laten sturen, met onze identiteit
+  // eronder. Onbetekend eerst dus, en alleen tekenen als het anders niet lukt.
   verzoeken = [];
+  return AP.fetchActor(OPEN_ACTOR, { asSlug: 'me' }).then((actor) => {
+    assert.ok(actor);
+    assert.equal(verzoeken.length, 1, 'één poging, geen tweede');
+    assert.equal(verzoeken[0].ondertekend, false, 'en die was onbetekend');
+  });
+});
+
+test('een document zonder sleutel telt als mislukt en leidt tot een ondertekende poging', async () => {
+  // Sommige instances serveren onbetekend wel iets, maar zonder publicKey. Voor
+  // een verificatie hebben we daar niets aan.
+  const KAAL = 'https://203.0.113.50/users/kaal';
   const stubOrig = globalThis.fetch;
-  let eerste = true;
   globalThis.fetch = async (url, opts = {}) => {
     const ondertekend = !!(opts.headers && (opts.headers.Signature || opts.headers.signature));
-    if (String(url) === OPEN_ACTOR && ondertekend && eerste) { eerste = false; return new Response('nee', { status: 500 }); }
+    if (String(url) === KAAL) {
+      verzoeken.push({ url: String(url), ondertekend });
+      const body = ondertekend
+        ? { id: KAAL, type: 'Person', publicKey: { id: `${KAAL}#k`, owner: KAAL, publicKeyPem: 'x' } }
+        : { id: KAAL, type: 'Person' };   // kaal: geen sleutel
+      return new Response(JSON.stringify(body), { status: 200, headers: { 'content-type': 'application/activity+json' } });
+    }
     return stubOrig(url, opts);
   };
-  const actor = await AP.fetchActor(OPEN_ACTOR, { asSlug: 'me' });
+  verzoeken = [];
+  const actor = await AP.fetchActor(KAAL, { asSlug: 'me' });
   globalThis.fetch = stubOrig;
-  assert.ok(actor, 'de terugval hoort hem alsnog op te halen');
+  assert.ok(actor.publicKey && actor.publicKey.publicKeyPem, 'de ondertekende poging levert de sleutel');
+  assert.deepEqual(verzoeken.map((v) => v.ondertekend), [false, true], 'eerst onbetekend, daarna pas ondertekend');
 });