Changeset 691311f in Klonkt for test/authorized-fetch.test.js

Timestamp:

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

Author:

Claude (agent) <aiclaude@…>

Branches:

main

Children:

5d0d41d

Parents:

57aee3b

git-author:

Robin <roboburr@…> (08/06/2026 10:40:39 AM)

git-committer:

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

Message:

Sleutel-ophaal ondertekenen: volgers achter authorized fetch kunnen weer volgen

Op boiert.eu bleven vier accounts eindeloos in het log hangen met een geweigerde
Follow, terwijl tientallen andere gewoon lukten. Oorzaak: hun instances draaien
Mastodons secure mode en serveren hun actor-document -- en dus hun publieke
sleutel -- alleen aan een ONDERTEKEND verzoek. fetchActor deed een onbetekende
GET, kreeg 401, vond geen sleutel, en dus kon verifyRequest een correct
ondertekende Follow niet verifiëren. Mastodon probeert het daarna dagenlang
opnieuw, en daarom domineerden juist die vier het log.

De correlatie is volledig: infosec.exchange, masto.hackers.town, toot.cat en
mastodon.africa geven 401 op een onbetekende actor-GET; mstdn.social en
mastodon.xyz geven 200. Precies de eerste vier werden geweigerd.

fetchActor accepteert nu een ondertekenaar en gebruikt signedGetJson, dat al
bestond. verifyRequest geeft de ontvangende site mee; voor de gedeelde inbox een
willekeurige lokale site, want elke Klonkt-actor is een geldige ondertekenaar --
het gaat de andere kant erom DAT er ondertekend is.

Terugval op de onbetekende GET blijft: niet elke 401 komt van secure mode, en een
instance die geen handtekening verwacht moet blijven werken. Een test dwingt dat
af door de ondertekende poging te laten falen.

Geen kip-ei-probleem: om onze handtekening te controleren haalt de andere kant
ons actor-document op, en dat serveert Klonkt publiek.

Het gevolg reikt verder dan Follow. Elke ophaalactie bij zo'n instance faalde --
profielen, notes, reacties -- dus een deel van de geweigerde Creates uit
shaer-s8k kan dezelfde oorzaak hebben gehad.

Suite 453/453.

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

File:

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

test/authorized-fetch.test.js

@@ -1 @@
-// FEP-633c §5.3 note: a committed guardian is recognised for authorized fetch.
+// Authorized fetch (shaer-afq): een instance in Mastodons secure mode geeft zijn
+// actor-document -- en dus zijn publieke sleutel -- alleen aan een ONDERTEKEND
+// verzoek. Zonder die handtekening kregen we 401, vonden we geen sleutel, en
+// wezen we elke correct ondertekende Follow van die instance af. Op boiert.eu
+// bleven daardoor vier accounts eindeloos hangen.
+//
+// De fetch is hier gestubd: het gaat om de vraag OF er ondertekend wordt en of
+// er wordt teruggevallen, niet om echte HTTP of crypto.
+//
+// Run: npm test
+
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 
 process.env.DATABASE_PATH = ':memory:';
-process.env.PUBLIC_BASE_URL = 'https://test.example';
+process.env.PUBLIC_BASE_URL = 'https://klonkt.test';
 
 const dbMod = await import('../src/config/database.js');
 const db = dbMod.default;
 dbMod.initializeDatabase();
-const AP = (await import('../src/services/ActivityPubService.js')).default;
+const AP = await import('../src/services/ActivityPubService.js');
 
-db.prepare('INSERT INTO users (id, username, email, password_hash, role) VALUES (?,?,?,?,?)').run('u1', 'u1', 'u1@t', 'x', 'god');
-db.prepare('INSERT INTO sites (id, slug, title, owner_id, is_primary) VALUES (?,?,?,?,1)').run('s1', 'kid', 'kid', 'u1');
-// Commit a guardian relation: kid (ward) is guarded by mom.
-const MOM = 'https://mom.example/ap/users/mom';
-db.prepare("INSERT INTO ap_guardianships (slug, role, other_uri, status, created_at) VALUES ('kid','ward',?, 'accepted', CURRENT_TIMESTAMP)").run(MOM);
+db.prepare('INSERT INTO users (id, username, email, password_hash, role) VALUES (?,?,?,?,?)')
+  .run('u1', 'u1', 'u1@test', 'x', 'god');
+db.prepare('INSERT INTO sites (id, slug, title, owner_id) VALUES (?,?,?,?)').run('s1', 'me', 'Me', 'u1');
 
-test('a committed guardian is recognised; a stranger is not', () => {
-  assert.equal(AP.isWardGuardian('kid', MOM), true);
-  assert.equal(AP.isWardGuardian('kid', 'https://x.example/ap/users/stranger'), false);
-  assert.equal(AP.isWardGuardian('nosuch', MOM), false);
+// IP-literals: safeFetch slaat de DNS-lookup over, dus de test blijft offline.
+const OPEN_ACTOR = 'https://203.0.113.30/users/open';       // gewone instance
+const SECURE_ACTOR = 'https://203.0.113.40/users/gesloten'; // authorized fetch
+
+let verzoeken = [];
+const echteFetch = globalThis.fetch;
+globalThis.fetch = async (url, opts = {}) => {
+  const u = String(url);
+  const ondertekend = !!(opts.headers && (opts.headers.Signature || opts.headers.signature));
+  verzoeken.push({ url: u, ondertekend });
+  const doc = (id) => new Response(JSON.stringify({
+    id, type: 'Person', preferredUsername: 'x', inbox: `${id}/inbox`,
+    publicKey: { id: `${id}#main-key`, owner: id, publicKeyPem: '-----BEGIN PUBLIC KEY-----\nx\n-----END PUBLIC KEY-----' },
+  }), { status: 200, headers: { 'content-type': 'application/activity+json' } });
+
+  if (u === OPEN_ACTOR) return doc(OPEN_ACTOR);
+  // De kern van secure mode: onbetekend is het 401, ondertekend krijg je hem wel.
+  if (u === SECURE_ACTOR) return ondertekend ? doc(SECURE_ACTOR) : new Response('unauthorized', { status: 401 });
+  return new Response('not found', { status: 404 });
+};
+
+test('een actor achter authorized fetch wordt nu wél opgehaald', async () => {
+  verzoeken = [];
+  const actor = await AP.fetchActor(SECURE_ACTOR, { asSlug: 'me' });
+  assert.ok(actor, 'de actor hoort binnen te komen');
+  assert.equal(actor.id, SECURE_ACTOR);
+  assert.ok(verzoeken.some((v) => v.url === SECURE_ACTOR && v.ondertekend), 'het verzoek hoort ondertekend te zijn');
 });
+
+test('zonder ondertekenaar blijft dezelfde actor onbereikbaar', async () => {
+  // Dit is precies het oude gedrag, en het bewijst dat de stub echt onderscheid
+  // maakt in plaats van altijd mee te werken.
+  const actor = await AP.fetchActor(SECURE_ACTOR);
+  assert.equal(actor, null);
+});
+
+test('een gewone instance blijft werken, ondertekend of niet', async () => {
+  assert.ok(await AP.fetchActor(OPEN_ACTOR), 'onbetekend');
+  assert.ok(await AP.fetchActor(OPEN_ACTOR, { asSlug: 'me' }), 'ondertekend');
+});
+
+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.
+  verzoeken = [];
+  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 }); }
+    return stubOrig(url, opts);
+  };
+  const actor = await AP.fetchActor(OPEN_ACTOR, { asSlug: 'me' });
+  globalThis.fetch = stubOrig;
+  assert.ok(actor, 'de terugval hoort hem alsnog op te halen');
+});
+
+test('een onbekende actor blijft null, ondertekend of niet', async () => {
+  assert.equal(await AP.fetchActor('https://203.0.113.99/users/weg', { asSlug: 'me' }), null);
+});
+
+test.after(() => { globalThis.fetch = echteFetch; });