dogfather-universe/server/pruef-schranke.mjs

/* KOMMT MAN AN DER SCHRANKE VORBEI?

   Auftrag vom 04.09.2026 (vollstaendiger Audit): "pruefe direkte
   URL-Aufrufe, Zugriff ohne Login, Zugriff mit falscher Rolle".

   WARUM DIESE PRUEFUNG NOETIG IST. Der Seitenschutz in workspace.js
   vergleicht `req.path` gegen eine Liste:

       if (!Object.hasOwn(GESCHUETZT, req.path)) return next();

   Ein EXAKTER Vergleich. Trifft er nicht, geht die Anfrage ungeprueft
   weiter an express.static. Alles haengt damit an der Frage, ob es eine
   Schreibweise derselben Datei gibt, die anders aussieht als der
   Listeneintrag -- ein zweiter Schraegstrich, ein Punkt-Segment, eine
   kodierte Form, eine andere Gross-/Kleinschreibung.

   Das laesst sich nicht durch Lesen entscheiden: Ob Express den Pfad
   vorher zurechtruecken, ob serve-static ihn nochmal aufloest, haengt an
   den Fassungen im Einsatz. Also wird es AUSPROBIERT, gegen den echten
   Server, mit den echten Fassungen.

   ERWARTUNG je Aufruf: entweder Umleitung zur Anmeldung (302) oder
   "gibt es nicht" (404). Was NICHT vorkommen darf, ist 200 mit Inhalt.

   DIE GEGENPROBE steht am Ende: Mit gueltiger Anmeldung MUSS dieselbe
   Seite mit 200 kommen. Sonst pruefte dieser Lauf nur, dass der Server
   auf alles 404 sagt -- und waere wertlos. */

import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-schranke-"));
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(4231, "die Schrankenpruefung");

process.env.PORT = "4231";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
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:4231";

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

/* ---- 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();
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;
}
anlegen("Chef", "admin", "CODE-DOGI-0001");
anlegen("Mara", "manager", "CODE-MANA-0001");
anlegen("Pat", "scout", "CODE-SCOU-0001");
anlegen("Luna", "creator", "CODE-CREA-0001");
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 roh = a.headers.getSetCookie?.() || [];
  const keks = roh.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"),
};

/** Roh anfragen, ohne Umleitungen zu folgen -- die Umleitung IST die
 *  Antwort, der wir nachgehen. */
const hol = (pfad, keks) => fetch(BASIS + pfad, {
  redirect: "manual", headers: keks ? { cookie: keks } : {} });

/* =======================================================================
   1. Ohne Anmeldung an eine geschuetzte Seite
   ======================================================================= */
console.log("\n=== Ohne Anmeldung ===");

/* Die Liste aus workspace.js, damit hier keine zweite entsteht, die
   irgendwann abweicht. */
const { readFileSync } = await import("node:fs");
const quelle = readFileSync(new URL("./workspace.js", import.meta.url), "utf8");
const block = quelle.slice(quelle.indexOf("const GESCHUETZT = {"));
const SEITEN = [...block.slice(0, block.indexOf("\n};")).matchAll(/"(\/workspace\/[a-z]+\.html)"/g)]
  .map((m) => m[1]);

ok(SEITEN.length >= 15, `${SEITEN.length} geschuetzte Seiten aus workspace.js gelesen`);

let geprueft = 0;
for (const seite of SEITEN) {
  const a = await hol(seite, null);
  geprueft++;
  if (a.status !== 302) ok(false, `${seite} ohne Anmeldung -> ${a.status} statt 302`);
}
ok(geprueft === SEITEN.length && SEITEN.length > 0,
  `alle ${geprueft} Seiten leiten ohne Anmeldung zur Anmeldung um`);

/* =======================================================================
   2. Andere Schreibweisen desselben Pfades
   ======================================================================= */
console.log("\n=== Andere Schreibweisen (Umgehungsversuche) ===");

/* Jede Variante muss dasselbe tun wie der schlichte Pfad: wegschicken
   oder nicht finden. Ein 200 mit HTML waere die Luecke. */
const VARIANTEN = (s) => {
  const name = s.replace("/workspace/", "");
  return [
    [`//workspace/${name}`,            "zwei Schraegstriche vorn"],
    [`/workspace//${name}`,            "zwei Schraegstriche in der Mitte"],
    [`/workspace/./${name}`,           "Punkt-Segment"],
    [`/workspace/x/../${name}`,        "Umweg ueber .."],
    [`/workspace/%2e/${name}`,         "kodierter Punkt"],
    [`/workspace/${name.toUpperCase()}`, "Grossschreibung"],
    [`/workspace/${name}%20`,          "angehaengtes Leerzeichen"],
    [`/workspace/${name}.`,            "angehaengter Punkt"],
    [`/workspace/${encodeURIComponent(name)}`, "kodierter Name"],
    [`/workspace/${name};x=1`,         "Pfad-Parameter"],
    [`/./workspace/${name}`,           "Punkt vor workspace"],
  ];
};

let variantenGeprueft = 0;
const durchgerutscht = [];
for (const seite of SEITEN) {
  for (const [pfad, wie] of VARIANTEN(seite)) {
    let a;
    try { a = await hol(pfad, null); } catch { continue; }
    variantenGeprueft++;
    if (a.status === 200) {
      const text = await a.text();
      /* Nur echter Seiteninhalt zaehlt -- eine leere 200 waere zwar
         auch seltsam, aber kein Datenabfluss. */
      if (/<html|<!doctype/i.test(text) && text.length > 500) {
        durchgerutscht.push(`${pfad} (${wie}) -> 200, ${text.length} Zeichen`);
      }
    }
  }
}
ok(variantenGeprueft > 100, `${variantenGeprueft} Schreibweisen ausprobiert`);
ok(durchgerutscht.length === 0,
  durchgerutscht.length
    ? `SCHRANKE UMGANGEN: ${durchgerutscht.slice(0, 6).join(" · ")}`
    : "keine Schreibweise kommt an der Schranke vorbei");

/* =======================================================================
   3. Falsche Rolle
   ======================================================================= */
console.log("\n=== Falsche Rolle ===");

/* Was jede Rolle NICHT sehen darf, steht ebenfalls in workspace.js.
   Hier wird gegengeprueft, dass die Umleitung wirklich greift. */
const NUR_DOGFATHER = ["/workspace/personen.html", "/workspace/automation.html"];
for (const seite of NUR_DOGFATHER) {
  for (const rolle of ["manager", "scout", "creator"]) {
    const a = await hol(seite, kekse[rolle]);
    ok(a.status === 302, `${rolle} auf ${seite} -> ${a.status} (erwartet 302)`);
  }
  const a = await hol(seite, kekse.admin);
  ok(a.status === 200, `DogFather auf ${seite} -> ${a.status} (erwartet 200)`);
}

const NUR_TEAM = "/workspace/scouting.html";
{
  const a = await hol(NUR_TEAM, kekse.creator);
  ok(a.status === 302, `Creator auf ${NUR_TEAM} -> ${a.status} (erwartet 302)`);
  const b = await hol(NUR_TEAM, kekse.scout);
  ok(b.status === 200, `Scout auf ${NUR_TEAM} -> ${b.status} (erwartet 200)`);
}

/* Und dieselben Umgehungsversuche MIT falscher Rolle -- ein Manager, der
   personen.html ueber //workspace/ bekaeme, waere genauso ein Loch. */
console.log("\n=== Falsche Rolle + andere Schreibweise ===");
const rolleDurchgerutscht = [];
let rolleGeprueft = 0;
for (const seite of NUR_DOGFATHER) {
  for (const [pfad, wie] of VARIANTEN(seite)) {
    for (const rolle of ["manager", "creator"]) {
      let a;
      try { a = await hol(pfad, kekse[rolle]); } catch { continue; }
      rolleGeprueft++;
      if (a.status === 200) {
        const text = await a.text();
        if (/<html|<!doctype/i.test(text) && text.length > 500) {
          rolleDurchgerutscht.push(`${rolle}: ${pfad} (${wie})`);
        }
      }
    }
  }
}
ok(rolleGeprueft > 40, `${rolleGeprueft} Versuche mit falscher Rolle`);
ok(rolleDurchgerutscht.length === 0,
  rolleDurchgerutscht.length
    ? `ROLLE UMGANGEN: ${rolleDurchgerutscht.slice(0, 6).join(" · ")}`
    : "auch mit anderer Schreibweise kommt keine falsche Rolle durch");

/* =======================================================================
   4. Die Datenbank und die Ablagen sind nicht aus dem Netz erreichbar
   ======================================================================= */
console.log("\n=== Nicht ausliefern, was nicht ins Netz gehoert ===");
for (const pfad of [
  "/server/workspace.js", "/server/.env", "/.git/config", "/server/gate.js",
  "/workspace-daten/workspace.db", "/CLAUDE.md", "/DEPLOY.md",
  "/../workspace-daten/workspace.db", "/workspace/../server/workspace.js",
]) {
  const a = await hol(pfad, kekse.admin);
  const text = a.status === 200 ? await a.text() : "";
  ok(a.status !== 200 || text.length < 200,
    `${pfad} -> ${a.status}${a.status === 200 ? ` (${text.length} Zeichen!)` : ""}`);
}

/* =======================================================================
   5. Abgelaufene und gefaelschte Sitzung
   ======================================================================= */
console.log("\n=== Sitzung ===");
{
  const a = await hol("/workspace/start.html", "dfw_sitzung=" + "a".repeat(64));
  ok(a.status === 302, `erfundener Sitzungsschluessel -> ${a.status} (erwartet 302)`);

  const b = await fetch(BASIS + "/workspace/api/aufgaben",
    { headers: { cookie: "dfw_sitzung=" + "b".repeat(64) } });
  ok(b.status === 401, `erfundener Schluessel an der Schnittstelle -> ${b.status} (erwartet 401)`);

  /* Eine Sitzung, deren Gueltigkeit abgelaufen ist, muss sterben --
     auch wenn der Schluessel echt ist. */
  const d2 = new DatabaseSync(process.env.WORKSPACE_DB);
  d2.prepare("UPDATE sitzungen SET gueltig_bis = ? WHERE person_id = (SELECT id FROM personen WHERE rolle='creator')")
    .run("2020-01-01T00:00:00.000Z");
  d2.close();
  const c = await hol("/workspace/start.html", kekse.creator);
  ok(c.status === 302, `abgelaufene Sitzung -> ${c.status} (erwartet 302)`);

  /* Und eine gesperrte Person kommt mit gueltiger Sitzung nicht mehr rein. */
  const d3 = new DatabaseSync(process.env.WORKSPACE_DB);
  d3.prepare("UPDATE personen SET aktiv = 0 WHERE rolle = 'scout'").run();
  d3.close();
  const e = await hol("/workspace/start.html", kekse.scout);
  ok(e.status === 302, `gesperrte Person mit gueltiger Sitzung -> ${e.status} (erwartet 302)`);
}

/* =======================================================================
   6. Sicherheits-Kopfzeilen
   ======================================================================= */
console.log("\n=== Sicherheits-Kopfzeilen ===");
{
  const a = await hol("/workspace/", null);
  for (const [name, erwartet] of [
    ["x-content-type-options", "nosniff"],
    ["x-frame-options", "SAMEORIGIN"],
    ["referrer-policy", "strict-origin-when-cross-origin"],
  ]) {
    ok(a.headers.get(name) === erwartet,
      `${name}: ${a.headers.get(name) || "fehlt"} (erwartet ${erwartet})`);
  }

  /* HSTS GEHOERT NICHT AUF EINE UNSICHERE VERBINDUNG (Befund 04.09.2026).
     RFC 6797, 7.2: "An HSTS Host MUST NOT include the STS header field
     in HTTP responses conveyed over non-secure transport."

     Vorher ging der Header bei jeder Antwort mit. Live unauffaellig --
     dort kommt alles ueber https. Aufgefallen im Browsertest: WebKit
     nimmt ihn auch von einer http-Adresse an, merkt sich 127.0.0.1 als
     "nur noch https", und danach scheitert jede Verbindung zum lokalen
     Testserver mit "SSL connect error". Chromium und Firefox machen fuer
     localhost eine Ausnahme, WebKit nicht -- also ausgerechnet der
     Browser, den jedes iPhone benutzt, war damit nicht mehr pruefbar.

     Node's fetch setzt den Host-Header selbst (verbotener Name), deshalb
     hier ein roher Aufruf -- sonst misst man dreimal denselben Fall. */
  const http = await import("node:http");
  const mitHost = (host) => new Promise((fertig) => {
    const r = http.request({ host: "127.0.0.1", port: 4231, path: "/404.html",
      method: "GET", headers: { Host: host } }, (antwort) => {
      antwort.resume();
      fertig(antwort.headers["strict-transport-security"] || null);
    });
    r.on("error", () => fertig(null));
    r.end();
  });

  ok((await mitHost("127.0.0.1:4231")) === null,
    "ueber http an eine lokale Adresse kommt KEIN HSTS (RFC 6797)");
  ok((await mitHost("localhost:4231")) === null,
    "auch an localhost kommt kein HSTS");
  const echt = await mitHost("dogfather-universe.com");
  ok(!!echt && echt.includes("max-age="),
    `an der echten Domain kommt HSTS weiterhin (${echt || "FEHLT"})`);
}

/* =======================================================================
   GEGENPROBE — kann diese Pruefung ueberhaupt "erlaubt" sagen?
   ======================================================================= */
console.log("\n=== Gegenprobe ===");
{
  const a = await hol("/workspace/start.html", kekse.admin);
  const text = a.status === 200 ? await a.text() : "";
  ok(a.status === 200 && text.length > 500,
    `angemeldet kommt start.html normal an (${a.status}, ${text.length} Zeichen)`);

  const b = await hol("/workspace/", null);
  ok(b.status === 200, `die Anmeldeseite selbst bleibt offen (${b.status})`);

  /* Und der Beweis, dass ein durchgerutschter Pfad ueberhaupt auffallen
     WUERDE: eine ungeschuetzte Datei liefert echten Inhalt. */
  const c = await hol("/workspace/assets/css/start.css", null);
  const t = c.status === 200 ? await c.text() : "";
  ok(c.status === 200 && t.length > 500,
    `eine ungeschuetzte Datei kommt mit Inhalt (${c.status}, ${t.length} Zeichen) — die Messung kann also "durchgelassen" erkennen`);
}

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