dogfather-universe/server/pruef-alle-wege.mjs

/* JEDER WEG, JEDE ROLLE — die Vollabdeckung.

   Auftrag vom 04.09.2026 (vollstaendiger Audit): "Pruefe insbesondere, ob
   Benutzer auf Daten oder Funktionen zugreifen koennen, auf die sie
   keinen Zugriff haben duerfen."

   WARUM ZUSAETZLICH ZU DEN VORHANDENEN PRUEFUNGEN. Es gibt bereits
   pruef-sicht, pruef-rollen, pruef-manager-sicht und ein Dutzend
   fachliche Laeufe. Die sind gruendlich -- aber sie pruefen AUSGEWAEHLTE
   Wege. Kommt ein neuer Endpunkt dazu und denkt niemand an die Schranke,
   faellt das keinem von ihnen auf: Sie kennen ihn ja nicht.

   Diese Pruefung kennt keinen Endpunkt auswendig. Sie LIEST die Routen
   aus dem Quelltext und geht stumpf ueber alle. Was dazukommt, ist
   damit automatisch mitgeprueft.

   DIE EINE HARTE REGEL, die ohne Fachwissen gilt:

       Ohne Anmeldung darf keine einzige /workspace/api-Route Daten
       herausgeben.

   Ausgenommen sind genau drei, und jede mit Grund (siehe OHNE_ANMELDUNG).
   Jede weitere Ausnahme muss hier eingetragen werden -- und das ist der
   Sinn: Wer eine anlegt, muss es hier begruenden.

   ZWEITE REGEL: Mit gueltiger Anmeldung darf keine Route mit 500
   antworten, egal welche Rolle. Ein 403/404 ist eine Aussage, ein 500
   ist ein Fehler.

   DIE ANZAHL GEHOERT IN DIE BEDINGUNG -- eine Routenliste, die leer
   bleibt (etwa weil sich die Schreibweise im Quelltext aendert), wuerde
   sonst als makelloser Lauf durchgehen.

   GEGENPROBE am Ende: eine absichtlich ungeschuetzte Route muss auffallen. */

import { mkdtempSync, rmSync, readFileSync, readdirSync } from "node:fs";
import { tmpdir } from "node:os";
import { join, dirname } from "node:path";
import { fileURLToPath } from "node:url";
import { heuteLokal } from "./helfer-zeit.mjs";

const HIER = dirname(fileURLToPath(import.meta.url));
const ordner = mkdtempSync(join(tmpdir(), "ws-wege-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* Der Port muss frei sein -- sonst wird gegen einen fremden Server
   gemessen. Begruendung in helfer-port.mjs. */
const { portMussFreiSein } = await import("./helfer-port.mjs");
await portMussFreiSein(4247, "die Wegepruefung");

process.env.PORT = "4247";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";

const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
await import("./index.js");
await new Promise((r) => setTimeout(r, 900));
const BASIS = "http://127.0.0.1:4247";

let fehler = 0;
const ok = (b, t) => { console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };

/* =======================================================================
   Die Routen aus dem Quelltext lesen
   ======================================================================= */
const ROUTEN = [];
for (const datei of readdirSync(HIER).filter((n) => /^workspace.*\.js$/.test(n))) {
  const text = readFileSync(join(HIER, datei), "utf8");
  for (const t of text.matchAll(
    /Router\.(get|post|patch|put|delete)\(\s*\n?\s*"(\/workspace\/api\/[^"]*)"/g)) {
    ROUTEN.push({ art: t[1].toUpperCase(), pfad: t[2], datei });
  }
}
console.log(`\n=== Bestand ===`);
ok(ROUTEN.length >= 90, `${ROUTEN.length} Schnittstellen aus dem Quelltext gelesen`);
ok(new Set(ROUTEN.map((r) => r.datei)).size >= 20,
  `verteilt auf ${new Set(ROUTEN.map((r) => r.datei)).size} Module`);

/* Platzhalter mit echten Nummern fuellen -- sonst antwortet alles 400,
   und die Pruefung misst nur die Zahlenpruefung statt der Schranke. */
const einsetzen = (pfad, werte) => pfad
  .replace(/:bereich/g, "live")
  .replace(/:schluessel/g, werte.schluessel ?? "technik-01")
  .replace(/:datei/g, "0".repeat(32) + ".jpg")
  .replace(/:nid\(\\\\d\+\)|:nid/g, String(werte.nachricht ?? 1))
  .replace(/:id\(\\\\d\+\)|:id/g, String(werte.id ?? 1));

/* =======================================================================
   Bestand anlegen
   ======================================================================= */
const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");
await fetch(BASIS + "/workspace/api/anmelden", {
  method: "POST", headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});
for (let i = 0; i < 60; i++) {
  try {
    const p = new DatabaseSync(process.env.WORKSPACE_DB);
    try { p.prepare("SELECT 1 FROM personen LIMIT 1").get(); break; } finally { p.close(); }
  } catch { await new Promise((r) => setTimeout(r, 250)); }
}
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();
/* ORTSZEIT, nicht UTC -- Begruendung in helfer-zeit.mjs. Mit
   `jetzt.slice(0, 10)` lag dieser Wert zwischen Mitternacht und
   zwei Uhr einen Tag daneben. */
const heute = heuteLokal();
function anlegen(name, rolle, code) {
  const salt = randomBytes(16).toString("hex");
  const hash = scryptSync(code, salt, 64, { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
  d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
    .run(name, rolle, hash, salt, 32768, jetzt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}
const idDogi = anlegen("Chef", "admin", "CODE-DOGI-0001");
const idMara = anlegen("Mara", "manager", "CODE-MANA-0001");
const idPat = anlegen("Pat", "scout", "CODE-SCOU-0001");
const idLuna = anlegen("Luna", "creator", "CODE-CREA-0001");

/* NORA GEHOERT NIEMANDEM, DER HIER MITSPIELT.
   Ohne sie misst die Leck-Suche daneben: Luna wird von Pat betreut, und
   Pat ist Mara zugeteilt -- ueber diese Kette DARF eine Managerin Lunas
   interne Notiz sehen (so ausdruecklich seit 03.09.2026). Der erste Lauf
   meldete deshalb einen "Fund", der keiner war.
   Nora haengt an einem zweiten Scout, den Mara nicht hat. Wer Noras
   interne Notiz sieht, sieht sie zu Unrecht. */
const idBea = anlegen("Bea", "scout", "CODE-SCOU-0002");
const idNora = anlegen("Nora", "creator", "CODE-CREA-0002");
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idLuna, idPat, jetzt);
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idNora, idBea, jetzt);
d.prepare("INSERT INTO scout_zuteilung (scout_id, manager_id, seit) VALUES (?,?,?)").run(idPat, idMara, jetzt);

/* GEHEIMWORT: kommt es irgendwo bei einer Rolle an, die es nicht sehen
   darf, ist das ein Leck -- egal ueber welchen Weg. */
const GEHEIM = "ZWOELFGEHEIMNIS";
d.prepare(`INSERT INTO aufgaben (titel, beschreibung, status, prioritaet, creator_id, erstellt, erstellt_von)
  VALUES (?,?,'offen','hoch',?,?,?)`).run("Aufgabe A", "harmlos", idLuna, jetzt, idDogi);
const idAufgabe = d.prepare("SELECT last_insert_rowid() AS id").get().id;
d.prepare(`INSERT INTO termine (titel, art, beginn, dauer_min, creator_id, erstellt, erstellt_von)
  VALUES ('Call A','call',?,30,?,?,?)`).run(heute + "T10:00", idLuna, jetzt, idDogi);
const idTermin = d.prepare("SELECT last_insert_rowid() AS id").get().id;
d.prepare(`INSERT INTO eintraege (bereich, art, titel, text, status, datum, creator_id, erstellt, erstellt_von)
  VALUES ('live','vorbereitung','Eintrag A','Text',?,?,?,?,?)`)
  .run("offen", heute, idLuna, jetzt, idDogi);
const idEintrag = d.prepare("SELECT last_insert_rowid() AS id").get().id;
d.prepare(`INSERT INTO leads (name, plattform, handle, status, prioritaet, notizen, scout_id, erstellt)
  VALUES ('Lead A','tiktok','@a','neu','hoch',?,?,?)`).run(GEHEIM + " im Lead", idBea, jetzt);
const idLead = d.prepare("SELECT last_insert_rowid() AS id").get().id;
/* KEIN STILLES catch HIER. Der erste Entwurf hatte eines ("Tabelle
   heisst evtl. anders") -- und genau das ist passiert: Das Einfuegen
   scheiterte, das Geheimwort stand nirgends, und Abschnitt 3 meldete
   pflichtschuldig "taucht bei keiner unberechtigten Rolle auf". Er hatte
   nur auf ein Wort geprueft, das es gar nicht gab.

   Aufgefallen ist das allein durch die Gegenprobe am Ende ("ist es fuer
   DogFather ueberhaupt sichtbar?"). Ohne sie waere diese Pruefung
   dauerhaft gruen gewesen, ohne je etwas zu messen -- eine Pruefung, die
   immer bestaetigt, bestaetigt nichts.

   Schlaegt das Einfuegen jetzt fehl, bricht der Lauf ab. Ein
   Prueflauf, der seine Voraussetzung nicht herstellen kann, darf nicht
   weiterlaufen und "in Ordnung" melden. */
/* Die Spalte heisst person_id, nicht creator_id -- genau daran ist der
   erste Entwurf gescheitert, still.
   Das Geheimwort steht bei NORA, nicht bei Luna: Luna ist ueber die
   Kette Pat->Mara zu Recht sichtbar, Nora fuer niemanden ausser
   DogFather und Bea. */
d.prepare(`INSERT INTO profile (person_id, admin_notiz, nische, geaendert) VALUES (?,?,?,?)`)
  .run(idNora, GEHEIM + " in der internen Notiz", "Basteln", jetzt);
d.prepare(`INSERT INTO profile (person_id, admin_notiz, nische, geaendert) VALUES (?,?,?,?)`)
  .run(idLuna, "Lunas Notiz (darf Mara sehen)", "Gaming", jetzt);
d.close();

async function anmelden(rolle, code) {
  const a = await fetch(BASIS + "/workspace/api/anmelden", {
    method: "POST", headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ rolle, code }) });
  const keks = (a.headers.getSetCookie?.() || []).map((z) => z.split(";")[0]).join("; ");
  if (!keks) throw new Error(`Anmeldung ${rolle} fehlgeschlagen (${a.status})`);
  return keks;
}
const KEKSE = {
  admin: await anmelden("admin", "CODE-DOGI-0001"),
  manager: await anmelden("manager", "CODE-MANA-0001"),
  scout: await anmelden("scout", "CODE-SCOU-0001"),
  creator: await anmelden("creator", "CODE-CREA-0001"),
};
const NUMMERN = {
  aufgaben: idAufgabe, termine: idTermin, eintrag: idEintrag,
  leads: idLead, profil: idNora, startcheck: idNora, steckbrief: idNora,
  personen: idNora, calls: idTermin,
};

/** Passende Nummer je nach Weg -- sonst prueft man 404 statt der Schranke. */
function nummerFuer(pfad) {
  for (const [wort, id] of Object.entries(NUMMERN)) {
    if (pfad.includes("/" + wort)) return id;
  }
  return 1;
}

async function ruf(art, pfad, keks) {
  const kopf = { "Content-Type": "application/json", origin: BASIS };
  if (keks) kopf.cookie = keks;
  const rumpf = art === "GET" || art === "DELETE" ? undefined : JSON.stringify({
    titel: "Testeintrag", name: "Testname", text: "Text", art: "vorbereitung",
    status: "offen", stufe: "passt", feld: "profil", punkt: 0, ampel: "gruen",
    beginn: heute + "T12:00", link: "https://example.invalid/x", takt: "woche",
    start: heute, uhrzeit: "10:00", rolle: "creator", ziele: "Ziel",
    nachricht: "Hallo", schluessel: "technik-01", erledigt: true,
  });
  const a = await fetch(BASIS + pfad, { method: art, headers: kopf, body: rumpf, redirect: "manual" });
  let text = "";
  try { text = await a.text(); } catch { /* egal */ }
  return { status: a.status, text };
}

/* =======================================================================
   1. Ohne Anmeldung — die harte Regel
   ======================================================================= */
console.log(`\n=== Ohne Anmeldung darf nichts herauskommen ===`);

/* Die drei begruendeten Ausnahmen. Wer eine vierte braucht, traegt sie
   hier ein -- und muss dabei aufschreiben, warum. */
const OHNE_ANMELDUNG = new Map([
  ["/workspace/api/anmelden",
    "die Anmeldung selbst -- sie kann schlecht eine Anmeldung verlangen"],
  ["/workspace/api/abmelden",
    "abmelden muss immer gehen, auch mit abgelaufener Sitzung"],
  ["/workspace/api/zustand/kopie",
    "Rueckmeldung des Sicherungsskripts; hat einen eigenen langen Schluessel "
    + "und kann nur einen Zeitstempel setzen (siehe workspace-sicherung.js)"],
]);

let ohneGeprueft = 0;
const offen = [];
for (const r of ROUTEN) {
  const pfad = einsetzen(r.pfad, { id: nummerFuer(r.pfad) });
  if (OHNE_ANMELDUNG.has(r.pfad)) continue;
  ohneGeprueft++;
  const { status, text } = await ruf(r.art, pfad, null);
  /* Erlaubt ist: 401 (nicht angemeldet), 403, 404. Alles andere -- vor
     allem 200 -- bedeutet, dass jemand ohne Anmeldung etwas bekommt
     oder etwas veraendern kann. */
  if (![401, 403, 404].includes(status)) {
    offen.push(`${r.art} ${pfad} -> ${status} ${text.slice(0, 60).replace(/\s+/g, " ")} [${r.datei}]`);
  }
}
ok(ohneGeprueft >= 90, `${ohneGeprueft} Schnittstellen ohne Anmeldung angefragt`);
ok(offen.length === 0,
  offen.length
    ? `OHNE ANMELDUNG ERREICHBAR:\n         ` + offen.slice(0, 10).join("\n         ")
    : "keine einzige Schnittstelle antwortet ohne Anmeldung mit Daten");

/* =======================================================================
   2. Mit Anmeldung — nie ein Serverfehler
   ======================================================================= */
console.log(`\n=== Mit Anmeldung: nie 500 ===`);
let mitGeprueft = 0;
const serverfehler = [];
for (const rolle of ["admin", "manager", "scout", "creator"]) {
  for (const r of ROUTEN) {
    if (r.pfad === "/workspace/api/abmelden") continue;   // beendet die Sitzung
    const pfad = einsetzen(r.pfad, { id: nummerFuer(r.pfad) });
    mitGeprueft++;
    const { status, text } = await ruf(r.art, pfad, KEKSE[rolle]);
    if (status >= 500) {
      serverfehler.push(`${rolle}: ${r.art} ${pfad} -> ${status} ${text.slice(0, 60)} [${r.datei}]`);
    }
  }
}
ok(mitGeprueft >= 360, `${mitGeprueft} Aufrufe (${ROUTEN.length} Wege x 4 Rollen)`);
ok(serverfehler.length === 0,
  serverfehler.length
    ? `SERVERFEHLER:\n         ` + serverfehler.slice(0, 12).join("\n         ")
    : "kein Weg antwortet mit 500 oder 503");

/* =======================================================================
   3. Das Geheimwort darf nicht wandern
   ======================================================================= */
console.log(`\n=== Kein Durchsickern interner Angaben ===`);

/* GEHEIM steht in einer internen Admin-Notiz und in einer Lead-Notiz.
   Ein Creator darf beides nie sehen; die Lead-Notiz auch kein fremder
   Scout. Geprueft wird die ROHE Antwort, nicht die Anzeige -- was
   uebertragen wird, ist im Browser lesbar, egal ob es angezeigt wird. */
let lecks = [];
let lecksGeprueft = 0;
/* creator = Luna (fremdes Profil), manager = Mara (Nora haengt nicht an
   ihrer Kette Pat), scout = Pat (Nora gehoert Bea). Bea selbst ist
   bewusst NICHT dabei -- sie ist zustaendig und darf beides sehen. */
for (const rolle of ["creator", "manager", "scout"]) {
  for (const r of ROUTEN.filter((x) => x.art === "GET")) {
    const pfad = einsetzen(r.pfad, { id: nummerFuer(r.pfad) });
    lecksGeprueft++;
    const { status, text } = await ruf("GET", pfad, KEKSE[rolle]);
    if (status === 200 && text.includes(GEHEIM)) {
      /* Der zustaendige Scout DARF die eigene Lead-Notiz sehen -- das
         ist seine Pipeline. Alles andere nicht. */
      /* Der Lead gehoert Bea, und Bea ist hier nicht dabei. Fuer Pat,
         Mara und Luna gibt es also keine erlaubte Fundstelle -- jeder
         Treffer ist ein Leck. */
      lecks.push(`${rolle} sieht das Geheimwort in ${r.art} ${pfad} [${r.datei}]`);
    }
  }
}
ok(lecksGeprueft > 100, `${lecksGeprueft} Leseabfragen auf durchgesickerte Angaben geprueft`);
ok(lecks.length === 0,
  lecks.length ? `DURCHGESICKERT:\n         ` + lecks.slice(0, 8).join("\n         ")
    : "das Geheimwort taucht bei keiner unberechtigten Rolle auf");

/* =======================================================================
   4. Fremde Herkunft (CSRF)
   ======================================================================= */
console.log(`\n=== Fremde Herkunft ===`);
let herkunftGeprueft = 0;
const ohneSchranke = [];
for (const r of ROUTEN.filter((x) => x.art !== "GET")) {
  if (r.pfad === "/workspace/api/anmelden" || r.pfad === "/workspace/api/abmelden") continue;
  if (r.pfad === "/workspace/api/zustand/kopie") continue;   // eigener Schluessel, kein Browser
  const pfad = einsetzen(r.pfad, { id: nummerFuer(r.pfad) });
  herkunftGeprueft++;
  const a = await fetch(BASIS + pfad, {
    method: r.art,
    headers: {
      "Content-Type": "application/json",
      cookie: KEKSE.admin,
      origin: "https://boese.example",
    },
    body: JSON.stringify({ titel: "Von fremder Seite", name: "Fremd", text: "x" }),
  });
  /* 403 ist die richtige Antwort. 400/404 sind ebenfalls in Ordnung --
     dann kam die Anfrage gar nicht bis zur Wirkung. Ein 200/201 waere
     die Luecke. */
  if (a.status === 200 || a.status === 201) {
    ohneSchranke.push(`${r.art} ${pfad} -> ${a.status} [${r.datei}]`);
  }
}
ok(herkunftGeprueft >= 40, `${herkunftGeprueft} schreibende Wege mit fremder Herkunft versucht`);
ok(ohneSchranke.length === 0,
  ohneSchranke.length
    ? `OHNE HERKUNFTSPRUEFUNG:\n         ` + ohneSchranke.slice(0, 10).join("\n         ")
    : "kein schreibender Weg nimmt eine fremde Herkunft an");

/* =======================================================================
   GEGENPROBE — findet diese Pruefung ueberhaupt etwas?
   ======================================================================= */
console.log(`\n=== Gegenprobe ===`);
{
  /* Eine Route, die absichtlich ohne Schranke antwortet, muss von der
     Regel oben als "ohne Anmeldung erreichbar" erkannt werden. */
  const testRouten = [...ROUTEN, { art: "GET", pfad: "/workspace/api/ich", datei: "workspace.js" }];
  const gefundenOhne = [];
  for (const r of testRouten.slice(0, 3)) {
    const { status } = await ruf(r.art, einsetzen(r.pfad, { id: 1 }), null);
    if (![401, 403, 404].includes(status)) gefundenOhne.push(r.pfad);
  }
  ok(gefundenOhne.length === 0, "die Stichprobe bestaetigt: ohne Anmeldung kommt nichts");

  /* Und der Beweis, dass die Messung "durchgelassen" ueberhaupt sehen
     kann: MIT Anmeldung liefert dieselbe Route Daten. */
  const a = await ruf("GET", "/workspace/api/ich", KEKSE.admin);
  ok(a.status === 200 && a.text.includes("rolle"),
    `mit Anmeldung liefert /api/ich Daten (${a.status}) — die Messung erkennt also den Unterschied`);

  /* Das Geheimwort MUSS bei DogFather ankommen -- sonst pruefte
     Abschnitt 3 nur, dass es nirgends steht. */
  const b = await ruf("GET", `/workspace/api/profil/${idNora}`, KEKSE.admin);
  const c = await ruf("GET", "/workspace/api/leads", KEKSE.admin);
  ok(b.text.includes(GEHEIM) || c.text.includes(GEHEIM),
    "das Geheimwort ist fuer DogFather sichtbar — die Leck-Suche misst also an echtem Inhalt");
}

console.log(`\n${fehler === 0 ? "ALLES IN ORDNUNG" : `${fehler} FEHLER`}`);
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
process.exit(fehler ? 1 : 0);