Sicherung: laeuft von allein, und ein stiller Ausfall faellt auf

Filipe zu Recht: "wieso soll ich diesen Befehl einmal die Woche eingeben,
ich will einmal und dass es dann alleine laeuft". Ein Befehl, den man
selbst eintippen muss, wird irgendwann vergessen -- und zwar genau dann,
wenn er zaehlt.

tools/sicherung-einrichten.ps1 legt eine Windows-Aufgabe an: taeglich
statt woechentlich (der Lauf dauert Sekunden, bei woechentlich waere die
Kopie im schlimmsten Fall sechs Tage alt), 13:30 statt nachts (der
Rechner laeuft nicht durch), und mit StartWhenAvailable -- war der
Rechner aus, holt Windows den Lauf beim naechsten Hochfahren nach. Ohne
diesen Schalter fiele jeder verpasste Termin ersatzlos aus. Braucht keine
Administratorrechte und macht am Ende gleich einen Probelauf: eine
Einrichtung, die man nicht ausprobiert, ist eine Vermutung.

Damit entsteht aber ein neues, schlimmeres Problem: Wenn die Aufgabe
still klemmt oder der Rechner wochenlang aus ist, merkt es NIEMAND. Man
glaubt, man haette eine Kopie ausser Haus, und hat sie nicht. Deshalb
meldet sich das Abholskript nach jedem Lauf beim Server zurueck, und die
Automationen-Seite zeigt, wie alt die Kopie ist -- nach zehn Tagen wird
sie auffaellig.

Die Rueckmeldung laeuft ueber einen eigenen langen Schluessel, nicht ueber
einen Zugangscode: Das Skript laeuft unbeaufsichtigt und muesste einen
Code sonst dauerhaft auf der Platte halten. Der Schluessel kann NUR einen
Zeitstempel setzen -- nichts lesen, nichts aendern. Verglichen wird
zeitunabhaengig.

Dabei eine unauffaellige Falle gefunden: In workspace-aufgaben.js steht
`aufgabenRouter.use("/workspace/api", angemeldet)` -- eine Schranke ueber
JEDEN Pfad unter /workspace/api, nicht nur die eigenen. Alle spaeter
eingehaengten Module leben stillschweigend davon. Die Rueckmeldung wurde
dort mit 401 abgewiesen, bevor ihr Schluessel ueberhaupt geprueft wurde;
der richtige Schluessel sah dadurch aus wie ein Fehler in der Pruefung.
Das Sicherungsmodul haengt jetzt VOR dem Aufgabenmodul und bringt seine
eigene Schranke mit -- damit haengt es an keinem anderen Modul mehr.

Ausserdem: Die Ueberschrift im Kasten nennt jetzt den GRUND, aus dem er
gelb ist. Vorher stand dort "Zuletzt gesichert vor 2 Minuten", waehrend
die Farbe wegen der fehlenden Kopie warnte -- die Anzeige widersprach
sich selbst und man sucht den Fehler an der falschen Stelle.

Co-Authored-By: Claude Opus 5 <[email protected]>

server/workspace-sicherung.js

@@ -40,9 +40,11 @@ import {
 } from "node:fs";
 import { join, dirname } from "node:path";
 import { createRequire } from "node:module";
+import { randomBytes, timingSafeEqual } from "node:crypto";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import {
-  db, DB_PFAD, DATEN_ORDNER, einstellung, einstellungSetzen, istLeitung, protokolliere,
+  db, DB_PFAD, DATEN_ORDNER, einstellung, einstellungSetzen, istLeitung, istDogFather,
+  protokolliere, sitzungLesen,
 } from "./workspace.js";
 
 /* node:sqlite wird wie in workspace.js NACHTRAEGLICH geholt, nicht oben
@@ -255,12 +257,33 @@ export function sicherungStarten() {
 
 export const sicherungRouter = express.Router();
 
+/* ACHTUNG, unauffaellige Falle: In workspace-aufgaben.js steht
+   `aufgabenRouter.use("/workspace/api", angemeldet)` -- eine Schranke,
+   die JEDEN Pfad unter /workspace/api abfaengt, nicht nur die eigenen.
+   Alle spaeter eingehaengten Module leben davon mit, ohne es zu sagen.
+
+   Fuer die Rueckmeldung der Kopie ist das toedlich: Sie kommt von einem
+   unbeaufsichtigten Skript ohne Sitzung und wuerde dort mit 401
+   abgewiesen, noch bevor der Schluessel ueberhaupt geprueft wird. Genau
+   das ist beim ersten Versuch passiert -- der richtige Schluessel gab
+   401 und sah aus wie ein Fehler in der Pruefung.
+
+   Deshalb haengt dieses Modul VOR dem Aufgabenmodul (siehe index.js) und
+   bringt seine eigene Schranke mit. Nebeneffekt: Es haengt an keinem
+   anderen Modul mehr. */
+function angemeldet(req, res, next) {
+  const person = sitzungLesen(req);
+  if (!person) return res.status(401).json({ fehler: "nicht_angemeldet" });
+  req.person = person;
+  next();
+}
+
 function nurLeitung(req, res, next) {
   if (!istLeitung(req.person)) return res.status(404).json({ fehler: "nicht gefunden" });
   next();
 }
 
-sicherungRouter.get("/workspace/api/zustand", nurLeitung, (req, res) => {
+sicherungRouter.get("/workspace/api/zustand", angemeldet, nurLeitung, (req, res) => {
   try {
     const d = db();
     const lies = (s) => { try { return JSON.parse(einstellung(s) || "null"); } catch { return null; } };
@@ -290,6 +313,7 @@ sicherungRouter.get("/workspace/api/zustand", nurLeitung, (req, res) => {
     res.json({
       letzte: lies("sicherung_letzte"),
       fehler: lies("sicherung_fehler"),
+      kopie: lies("kopie_letzte"),
       sicherungen: liste.slice(0, 20),
       anzahl: liste.length,
       belegt: liste.reduce((n, s) => n + s.groesse, 0),
@@ -310,9 +334,67 @@ sicherungRouter.get("/workspace/api/zustand", nurLeitung, (req, res) => {
   }
 });
 
+/* ---------- Rueckmeldung der Kopie ausserhalb des Servers -------------
+
+   Der Rechner holt sich die Sicherungen selbst -- der Server kann ihn ja
+   nicht erreichen. Damit hat das Ganze aber eine gefaehrliche
+   Eigenschaft: Bleibt der Rechner wochenlang aus oder scheitert die
+   geplante Aufgabe still, merkt es NIEMAND. Man glaubt, man haette eine
+   Kopie ausserhalb, und hat sie nicht.
+
+   Deshalb meldet sich das Abholskript nach jedem erfolgreichen Lauf hier
+   zurueck. Auf der Automationen-Seite steht dann, wie alt die Kopie ist,
+   und sie wird auffaellig, wenn zu lange nichts kam.
+
+   Bewusst KEINE Anmeldung mit Zugangscode: Das Skript liefe unbeaufsichtigt
+   und muesste den Code dauerhaft auf der Platte liegen haben. Stattdessen
+   ein eigener, langer Schluessel, der NUR dieses eine kann -- einen
+   Zeitstempel setzen. Wer ihn stiehlt, kann nichts lesen und nichts
+   aendern. Verglichen wird zeitunabhaengig, damit sich der Schluessel
+   nicht ueber die Antwortzeit erraten laesst.
+   --------------------------------------------------------------------- */
+
+function kopieSchluessel() {
+  let s = einstellung("kopie_schluessel");
+  if (!s) {
+    s = randomBytes(24).toString("base64url");
+    einstellungSetzen("kopie_schluessel", s);
+  }
+  return s;
+}
+
+sicherungRouter.post("/workspace/api/zustand/kopie", express.json({ limit: "8kb" }), (req, res) => {
+  try {
+    const gesendet = String(req.get("x-kopie-schluessel") || "");
+    const echt = kopieSchluessel();
+    const a = Buffer.from(gesendet);
+    const b = Buffer.from(echt);
+    if (a.length !== b.length || !timingSafeEqual(a, b)) {
+      return res.status(401).json({ fehler: "Schlüssel stimmt nicht." });
+    }
+    einstellungSetzen("kopie_letzte", JSON.stringify({
+      zeit: new Date().toISOString(),
+      dateien: Number(req.body?.dateien) || 0,
+      sicherungen: Number(req.body?.sicherungen) || 0,
+      bytes: Number(req.body?.bytes) || 0,
+      rechner: String(req.body?.rechner || "").slice(0, 60),
+    }));
+    res.json({ ok: true });
+  } catch (fehler) {
+    res.status(500).json({ fehler: String(fehler?.message || fehler) });
+  }
+});
+
+/* Den Schluessel darf nur DogFather sehen -- er ist ein Geheimnis, auch
+   wenn er wenig kann. Gebraucht wird er genau einmal beim Einrichten. */
+sicherungRouter.get("/workspace/api/zustand/kopie-schluessel", angemeldet, nurLeitung, (req, res) => {
+  if (!istDogFather(req.person)) return res.status(404).json({ fehler: "nicht gefunden" });
+  res.json({ schluessel: kopieSchluessel() });
+});
+
 /* Von Hand ausloesen -- vor einer groesseren Aenderung will man nicht bis
    drei Uhr nachts warten. Nur die Leitung, und es wird protokolliert. */
-sicherungRouter.post("/workspace/api/zustand/sichern", nurLeitung, (req, res) => {
+sicherungRouter.post("/workspace/api/zustand/sichern", angemeldet, nurLeitung, (req, res) => {
   try {
     const e = sicherungJetzt("von Hand · " + (req.person?.name || "?"));
     protokolliere("sicherung_erstellt", {