Changeset b5a0268c in Klonkt for src/services/ap-inbox.js

Timestamp:

09/04/2026 11:07:47 AM (4 days ago)

Author:

Robin <roboburr@…>

Branches:

main

Children:

59f404a

Parents:

9041d35

Message:

De negatieve dereference-cache is geen censuurknop meer (shaer-qawr)

De cache onthield elke mislukte dereference op de note-URI alleen, en een
van de twee manieren om te mislukken is volledig door een vreemde te
sturen. Neem de echte note-URI van je slachtoffer, zet je eigen actor op
DEZELFDE host als beweerde afzender en wijs met inReplyTo naar een van
onze publieke notes: de fetch bij de bron slaagt, attributedTo is het
slachtoffer en niet jij, en die note-URI stond dertig minuten op de
zwarte lijst. Het echte doorgestuurde antwoord liep daar daarna op stuk.
Elke dertig minuten herhalen gaf onbeperkte, gerichte onderdrukking van
een specifiek antwoord, voor een verzoek per keer.

De sleutel is nu de hele bescherming, want de twee soorten mislukking
zeggen iets verschillends. Een TRANSPORTFOUT is een eigenschap van de
note zelf en geldt voor iedereen die hem doorstuurt: sleutel is de
note. Een attributedTo-MISMATCH zegt iets over DEZE doorstuurder:
sleutel is (note, beweerde actor). De leugenaar remt daarmee alleen
zichzelf af, en dat was de rem die de cache moest zijn.

Tweede punt uit dezelfde bead: query en fragment tellen niet meer mee in
de sleutel. Met een kale URL waren ?x=1 en ?x=2 losse ingangen, dus
varieren kostte niets en er was helemaal geen rem -- en met vijfhonderd
losse sleutels waren de echte ingangen eruit te duwen.

Bewust NIET gedaan: een rem per HOST. Wie een handvol niet-bestaande
URL's op een host laat mislukken zou daarmee die hele host het zwijgen
opleggen, en dat is een grotere versie van precies de fout die hier
gerepareerd wordt. Dat staat als waarschuwing bij de code.

Drie toetsen, elk met eigen tegenbewijs: met de sleutel terug op de note
alleen valt de censuurtoets en blijven de andere twee groen, en met de
URL-normalisatie eruit valt alleen de remtoets. Volle suite 1237.

File:

• src/services/ap-inbox.js (modified) (3 diffs)

src/services/ap-inbox.js

@@ -142 +142 @@
 // dagenlang; zonder dit doet elke herhaling de fetch opnieuw, ook als die de
 // vorige twintig keer niets opleverde. Dempt meteen de scherpte van misbruik.
+//
+// DE SLEUTEL IS DE HELE BESCHERMING (shaer-qawr). Er zijn twee soorten
+// mislukking en ze zeggen iets heel verschillends:
+//
+//   TRANSPORTFOUT -- de note is niet op te halen. Dat is een eigenschap van de
+//   note zelf en geldt voor iedereen die hem doorstuurt, dus de objId alleen is
+//   de goede sleutel.
+//
+//   attributedTo-MISMATCH -- de bron zegt dat iemand ANDERS de auteur is. Dat
+//   zegt alles over de doorstuurder en niets over de note, dus die onthouden we
+//   per (note, beweerde actor).
+//
+// Met een enkele sleutel voor allebei was dit een censuurknop: neem de echte
+// note-URI van je slachtoffer, zet er je eigen actor op dezelfde host bij en
+// wijs naar een van onze publieke notes. De fetch slaagt, de mismatch volgt, en
+// die note-URI stond dertig minuten op de zwarte lijst -- waarna het ECHTE
+// doorgestuurde antwoord erop stukliep. Elke dertig minuten herhalen gaf
+// onbeperkte, gerichte onderdrukking van een specifiek antwoord, voor een
+// verzoek per keer. Nu raakt de leugenaar alleen zijn eigen ingang.
+//
+// Query en fragment tellen niet mee. Ze horen zelden bij de identiteit van een
+// note, en met een kale URL als sleutel waren ?x=1, ?x=2 enzovoort losse
+// ingangen: dan is de rem geen rem, want varieren kost niets. Zelfde reden dat
+// de host in kleine letters gaat.
+//
+// GEEN rem per HOST, hoe verleidelijk ook: wie een handvol niet-bestaande
+// URL's op een host laat mislukken zou daarmee die HELE host het zwijgen
+// opleggen. Dat is een grotere versie van precies de fout die hier gerepareerd
+// wordt.
 const _derefMiss = new Map();
 const DEREF_MISS_MS = 30 * 60 * 1000;
-function derefRecentlyFailed(uri) {
-  const t = _derefMiss.get(uri);
-  if (t === undefined) return false;
-  if (Date.now() - t > DEREF_MISS_MS) { _derefMiss.delete(uri); return false; }
-  return true;
+const derefKey = (uri, claimedActor) => {
+  let basis = String(uri || '');
+  try { const u = new URL(basis); basis = `${u.protocol}//${u.host.toLowerCase()}${u.pathname}`; }
+  catch { /* onparseerbaar: de kale string is dan de sleutel */ }
+  // Een NUL-teken als scheiding, als escape geschreven en niet als byte: het
+  // kan in geen enkele URL staan, dus een actor-sleutel is nooit per ongeluk
+  // als note-sleutel te lezen.
+  return claimedActor ? `${basis}\u0000${claimedActor}` : basis;
+};
+function derefRecentlyFailed(uri, claimedActor) {
+  for (const k of [derefKey(uri), derefKey(uri, claimedActor)]) {
+    const t = _derefMiss.get(k);
+    if (t === undefined) continue;
+    if (Date.now() - t > DEREF_MISS_MS) { _derefMiss.delete(k); continue; }
+    return true;
+  }
+  return false;
 }
-function noteDerefFailure(uri) {
+function noteDerefFailure(uri, claimedActor) {
   if (_derefMiss.size > 500) {   // simpele begrenzing: oudste helft eruit
     const oud = [..._derefMiss.entries()].sort((a, b) => a[1] - b[1]).slice(0, 250);
     for (const [k] of oud) _derefMiss.delete(k);
   }
-  _derefMiss.set(uri, Date.now());
+  _derefMiss.set(derefKey(uri, claimedActor), Date.now());
 }
+// Alleen voor de toets: de aanval speelt zich af in deze twee functies, en de
+// weg erheen (dereferenceForwarded) eist https en een echte fetch. De
+// dienstlaag exporteert ze niet, dus het uitvoeroppervlak blijft gelijk.
+export const _derefCacheForTests = { derefRecentlyFailed, noteDerefFailure };
 
 async function dereferenceForwarded(act, claimedActor, type, slugParam) {
@@ -184 +229 @@
     : null;
   if (!knownNoteUri(parent)) return skipped('unknown inReplyTo', parent || '(none)');
-  if (derefRecentlyFailed(objId)) return skipped('recent failure', objId);
+  if (derefRecentlyFailed(objId, claimedActor)) return skipped('recent failure', objId);
   // Onbetekend eerst; tekenen alleen als terugval. Anders kan een ander ons een
   // ONDERTEKEND verzoek naar een adres van zijn keuze laten sturen -- dezelfde
@@ -207 +252 @@
   if (attributed !== claimedActor) {
     // Not a transport hiccup: the source itself says someone else wrote this.
-    noteDerefFailure(objId);
+    // Per (note, beweerde actor), nooit op de note alleen: dit zegt iets over
+    // DEZE doorstuurder, en op de note alleen was het een censuurknop op de
+    // note van een ander (shaer-qawr).
+    noteDerefFailure(objId, claimedActor);
     return skipped('attributedTo mismatch', `${objId} claims ${attributed || '(none)'}`);
   }