Changeset 29eb745 in Klonkt

Timestamp:

08/08/2026 08:53:20 PM (4 weeks ago)

Author:

roboburr <roboburr@…>

Branches:

main

Children:

dc0da72

Parents:

ea211b9

git-author:

Robin <roboburr@…> (08/08/2026 08:53:18 PM)

git-committer:

roboburr <roboburr@…> (08/08/2026 08:53:20 PM)

Message:

Doorslaggevend schuift mee, en de daemons hoeven geen TLS

Drie dingen van Bart (8-8).

1. DOORSLAGGEVEND IS EEN STAND, GEEN MOMENT -- een fout in wat ik een uur eerder

bouwde. Ik berekende shaer:decisive een keer bij het doorsturen en bevroor het.
Bij vijf guardians staat er dan "je beslist niets", en zodra er een ja bij komt IS
elk van de anderen de doorslag. Precies de stille kant: het scherm zwijgt op het
moment dat het moet spreken. Na elke stem die het besluit open laat krijgen de
overgeblevenen nu een herziene stand, en alleen zij.

2. DE VOLGPOORT MAG UITGEROLD (Barts akkoord). Zit in deze reeks.

3. GEEN TLS VOOR DE TESTKUDDE. Barts vraag: waarom via https, gewoon localhost

::1. Terecht -- een certificaat en een publieke hostname toevoegen aan een doos
die ook andermans sites draait, om honderd neptestkinderen te bereiken, is de
verkeerde prijs.

Daarvoor mag de SSRF-poort gericht open: AP_ALLOW_HOSTS, een lijst van precieze
host:poort-paren. Geen "loopback is oke"-vlag. [::1]:3060 opent niet 127.0.0.1,
niet 3061, en niets in het interne netwerk -- want een brede vlag zet de
bescherming uit in een dev-omgeving, en dev-omgevingen worden productie. Leeg
tenzij een beheerder hem vult, en dat is de stand van elke productie-instance.

En het toetst iets dat we toch moesten kunnen: http MET HTTP-signatures, zonder
TLS. Een echt federatiegeval, tot nu toe nergens uitgeprobeerd.

ONDERWEG EEN LATENTE FOUT GEVONDEN. URL.hostname geeft een IPv6-literal met
blokhaken, en net.isIP herkent die vorm niet -- elk IPv6-adres viel door naar de
DNS-tak en strandde daar op ENOTFOUND. Geweigerd, maar per ongeluk en met de
verkeerde reden; isBlockedIp strippte die haken al en verwachtte dus input die
nooit aankwam. Nu wordt een IPv6-literal echt gecontroleerd.

EN EEN SLAAGTEST, want die ontbrak. Al mijn SSRF-toetsen controleerden alleen
weigeringen: de lijst helemaal negeren gaf nul rode toetsen, en de farm zou
stilletjes nooit werken. Nu bewijst er een dat wat op de lijst staat er ook
doorheen komt.

Suite 755/755. Drie mutaties gecontroleerd.

Files:

• src/services/ActivityPubService.js (modified) (2 diffs)
• src/services/guardianship/handshake.js (modified) (2 diffs)
• test/decisive-vote.test.js (modified) (1 diff)
• test/ssrf-allowlist.test.js (added)
• tools/ward-farm/farm.mjs (modified) (2 diffs)
• tools/ward-farm/offer-many.mjs (modified) (1 diff)

src/services/ActivityPubService.js

@@ -110 +110 @@
   return true; // not an IP literal we recognise → refuse
 }
+/**
+ * Uitzonderingen op de SSRF-poort, voor een testkudde op de eigen machine
+ * (shaer-6wt: honderd wards met een guardian, Barts opdracht 8-8).
+ *
+ * WAAROM DIT MAG BESTAAN. De bescherming hierboven is er omdat een actor-URI van
+ * een VREEMDE komt: een aanvaller die "http://169.254.169.254/" doorgeeft laat
+ * ons zijn werk doen. Deze lijst gaat niet over vreemden -- hij staat in de
+ * omgeving van deze server, wordt door de beheerder gezet, en is leeg tenzij
+ * iemand hem expliciet vult.
+ *
+ * WAAROM HIJ ZO SMAL IS. Geen vlag die "loopback is oke" zegt, maar een lijst
+ * van precieze host:poort-paren. `[::1]:3060` opent niet 127.0.0.1, niet poort
+ * 3061, en niets in het interne netwerk. Een brede vlag zou de bescherming in
+ * een dev-omgeving uitzetten, en dev-omgevingen worden productie.
+ *
+ *   AP_ALLOW_HOSTS="[::1]:3060,[::1]:3061"
+ */
+const AP_ALLOW_HOSTS = new Set(
+  String(process.env.AP_ALLOW_HOSTS || '').split(',').map((x) => x.trim().toLowerCase()).filter(Boolean),
+);
+function isAllowedTestHost(u) {
+  if (!AP_ALLOW_HOSTS.size) return false;
+  return AP_ALLOW_HOSTS.has(u.host.toLowerCase());
+}
 async function assertPublicHost(hostname) {
-  if (net.isIP(hostname)) { if (isBlockedIp(hostname)) throw new Error('ssrf-blocked-ip'); return; }
-  const addrs = await dns.promises.lookup(hostname, { all: true });
+  // URL.hostname geeft een IPv6-literal MET blokhaken ("[::1]"), en net.isIP
+  // herkent die vorm niet. Zonder strippen viel elk IPv6-adres door naar de
+  // DNS-tak, waar het strandde op ENOTFOUND: geweigerd, maar per ongeluk en met
+  // de verkeerde reden. isBlockedIp strippde ze al -- die verwachtte dus input
+  // die hier nooit aankwam.
+  const naakt = String(hostname || '').replace(/^\[|\]$/g, '');
+  if (net.isIP(naakt)) { if (isBlockedIp(naakt)) throw new Error('ssrf-blocked-ip'); return; }
+  const addrs = await dns.promises.lookup(naakt, { all: true });
   if (!addrs.length || addrs.some((a) => isBlockedIp(a.address))) throw new Error('ssrf-blocked-host');
 }
@@ -128 +158 @@
     const u = new URL(target); // throws on malformed → caller's catch
     if (u.protocol !== 'https:' && u.protocol !== 'http:') throw new Error('ssrf-bad-scheme');
-    await assertPublicHost(u.hostname);
+    // Alleen op de precieze host:poort uit AP_ALLOW_HOSTS, en per hop opnieuw:
+    // een omleiding naar een ANDER intern adres blijft geweigerd.
+    if (!isAllowedTestHost(u)) await assertPublicHost(u.hostname);
     const r = await fetch(target, {
       ...opts,

src/services/guardianship/handshake.js

@@ -44 +44 @@
   if (type !== 'Undo') return null;
   return parseRelationship(activity && activity.object);
+}
+
+/**
+ * De overgebleven guardians opnieuw vertellen of ZIJ nu de doorslag geven
+ * (shaer-8vt, Barts correctie 8-8).
+ *
+ * "Doorslaggevend" is geen eigenschap van een moment maar van een STAND: zodra
+ * er nog een stem nodig is, is iedereen die nog moet antwoorden het. Eenmalig
+ * berekenen bij het doorsturen bevriest een antwoord dat verandert.
+ *
+ * Nooit dragend: lukt de update niet, dan blijft de oude waarde staan. Die is
+ * dan te voorzichtig of te stil -- en juist daarom staat de FAALSTAND aan de
+ * kant van waarschuwen (isDecisive leest onbekend als "ja, jij beslist").
+ */
+function herzieDoorslag(site, offerId, gsOffer, laatsteStem) {
+  try {
+    const p = gated.gatedProgress(site.slug, gsOffer.feature);
+    if (!gated.isDecisive(p.votes, p.need)) return;   // nog niets veranderd
+    const me = deps.selfId(site.slug);
+    const gestemd = new Set([gsOffer.proposer, laatsteStem].filter(Boolean));
+    for (const g of relations.listGuardians(site.slug).map((x) => x.other_uri)) {
+      if (gestemd.has(g)) continue;
+      deps.deliverTo(site, g, {
+        id: offerId, type: 'Offer', actor: me, to: [g],
+        object: { type: 'shaer:GatedSetting', 'shaer:ward': me, 'shaer:feature': gsOffer.feature, 'shaer:value': !!gsOffer.value },
+        'shaer:proposer': gsOffer.proposer || undefined,
+        'shaer:decisive': true,
+      }).catch(() => { /* de bezorgwachtrij probeert opnieuw */ });
+    }
+  } catch { /* nooit dragend */ }
 }
 
@@ -537 +567 @@
     const r = gated.recordGatedVote(site.slug, gsOffer.feature, actor, value);
     if (r.state === 'settled') answerGatedProposer(site, offerId, r);
+    // DOORSLAGGEVEND SCHUIFT MEE (Barts correctie, 8-8). Ik berekende dit een
+    // keer bij het doorsturen en bevroor het. Bij vijf guardians staat er dan
+    // "je beslist niets" -- en zodra er een ja bij komt IS elk van de anderen de
+    // doorslag. Dat is precies de stille kant: het scherm zwijgt op het moment
+    // dat het moet spreken.
+    //
+    // Dus na elke stem die het open laat: de overgeblevenen opnieuw vertellen
+    // waar ze staan. Alleen wie NOG NIET geantwoord heeft, en alleen als het
+    // antwoord verandert -- anders is dit een bericht per stem per guardian.
+    else herzieDoorslag(site, offerId, gsOffer, actor);
     notify(site.slug, { kind: 'gated_setting', feature: gsOffer.feature, value, state: r.state });
     return true;

test/decisive-vote.test.js

@@ -47 +47 @@
   assert.equal(gated.isDecisive(null, null), true);
 });
+
+test('doorslaggevend is een STAND, geen moment', () => {
+  // Barts correctie (8-8): het geldt voor ALLE opvolgende beslissers. Bij vijf
+  // guardians is bij het doorsturen niemand het (drempel 3, een stem), maar na
+  // de tweede ja is iedereen die nog moet antwoorden het wel.
+  const drempel = gated.thresholdFor(5);          // 3
+  assert.equal(gated.isDecisive(1, drempel), false, 'bij het doorsturen nog niet');
+  assert.equal(gated.isDecisive(2, drempel), true, 'na een ja erbij wel');
+});
+
+test('en bij drie guardians is het meteen zo', () => {
+  assert.equal(gated.isDecisive(1, gated.thresholdFor(3)), true);
+});

tools/ward-farm/farm.mjs

@@ -33 +33 @@
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 const STATE = path.join(HERE, 'state.json');
-const BASE = process.env.BASE || 'https://wards.klonkt.com';
+// GEEN TLS, en dat hoort ook zo (Barts vraag, 8-8: "waarom via https? gewoon
+// localhost ::1"). Een certificaat en een publieke hostname toevoegen aan een
+// doos die ook andermans sites draait, om honderd neptestkinderen te kunnen
+// bereiken, is de verkeerde prijs. Klonkt laat dit adres door via AP_ALLOW_HOSTS
+// -- een precies host:poort-paar, geen "loopback mag"-vlag.
+//
+// EN HET TOETST IETS DAT WE TOCH MOESTEN KUNNEN: http met HTTP-signatures, zonder
+// TLS. Dat is een echt federatiegeval (interne netwerken, onion), en tot nu toe
+// was het nergens uitgeprobeerd.
+const BASE = process.env.BASE || 'http://[::1]:3060';
 const PORT = Number(process.env.PORT || 3060);
 const N = Number(process.env.WARDS || 100);
@@ -276 +285 @@
 bewaarStaat(staat);
 
-server.listen(PORT, '127.0.0.1', () => {
+server.listen(PORT, '::1', () => {
   console.log(`[farm] ${N} wards op ${BASE} (luistert op 127.0.0.1:${PORT})`);
 });

tools/ward-farm/offer-many.mjs

@@ -25 +25 @@
 
 const slug = args.slug || 'dev';
-const farmBase = (args.base || 'https://wards.klonkt.com').replace(/\/+$/, '');
+const farmBase = (args.base || 'http://[::1]:3060').replace(/\/+$/, '');
 const van = Number(args.from || 1);
 const tot = Number(args.to || 100);