From ab93e0ae4e46b32a62365af85e7d0b4553c59efd Mon Sep 17 00:00:00 2001 From: D4rkst3r Date: Wed, 12 Aug 2026 15:46:03 +0200 Subject: [PATCH] feat: die Archive lassen sich aus dem Panel holen Einstellungen -> "Sicherungen holen": die fertigen Archive mit Datum, Groesse und einem Knopf. Der erste Schritt, der eine Kopie VON DIESEM RECHNER HERUNTER bringt -- bisher haette man sich dafuer per Fernwartung auf den Server klicken muessen, und genau daran hat es gelegen. Nicht Unwille, sondern Umstaendlichkeit. Der Ordner haengt NUR LESEND in den Container. Ein Dienst, der seine eigenen Sicherungen loeschen kann, ist genau das Werkzeug, das man einem uebernommenen Dienst nicht in die Hand geben will. Nachgemessen im Container: touch /sicherungen/probe -> Read-only file system Und es gibt NUR EINE FORM VON NAMEN -- nicht "alles ausser .. und /", sondern ein Muster, das genau auf die eigenen Archive passt. Wer einen Pfad hineinschmuggeln will, muesste ihn erst so benennen. Das ist der Unterschied zwischen dicht gemacht und dicht gebaut: ../../etc/passwd -> 404 ..%2f..%2fdata%2fmedia.db -> 400 media.db -> 400 .tar.gz.evil -> 400 ohne Anmeldung -> 401 Der ganze Weg einmal wirklich gegangen, nicht nur die Kopfzeilen: 336 MB in 15,9 s durch den Proxy, sha256 auf der Platte gleich sha256 heruntergeladen, tar tzf zeigt 4639 Eintraege. Gestroemt und nicht in den Speicher gelesen -- sonst haetten Dienst UND Proxy die 336 MB gleichzeitig im Arbeitsspeicher. Jeder Griff steht im Verwaltungs-Verlauf. Geloggt wird der GRIFF und nicht der Erfolg: ein abgebrochener Download taucht ebenfalls auf, und das ist gewollt -- wer spaeter fragt, wer sich den Bestand geholt hat, will die Anfrage sehen. Die fuenf neuen Pruefungen sind in tools/rundgang.py mit drin; der steht jetzt bei 29 in Ordnung, 0 nicht. Co-Authored-By: Claude Opus 5 --- ROADMAP.md | 45 +++++++ docker-compose.yml | 11 ++ docs/ideen.md | 8 ++ server/src/routes/dash.ts | 74 ++++++++++++ server/ui/src/api.ts | 8 ++ server/ui/src/components/SicherungenKarte.tsx | 110 ++++++++++++++++++ server/ui/src/pages/Einstellungen.tsx | 2 + tools/rundgang.py | 20 +++- 8 files changed, 277 insertions(+), 1 deletion(-) create mode 100644 server/ui/src/components/SicherungenKarte.tsx diff --git a/ROADMAP.md b/ROADMAP.md index cbd8a34..1e54c40 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -1235,6 +1235,51 @@ Dazu steht auf der Serverseite schon alles bereit: `sshd` läuft (Automatic, fehlt ein Konto, das nur lesen darf — und ein Skript auf dem Heimrechner, das **holt**. Kandidaten und Begründung in `docs/ideen.md`. +### ✅ Fertig — die Archive lassen sich aus dem Panel holen + +Einstellungen → **Sicherungen holen**: die fertigen Archive mit Datum, Größe +und einem Knopf. Der erste Schritt, der eine Kopie **von diesem Rechner +herunter** bringt — bisher hätte man sich dafür per Fernwartung auf den Server +klicken müssen, und genau daran hat es gelegen. Nicht Unwille, sondern +Umständlichkeit. + +**Der Ordner hängt nur lesend.** Ein Dienst, der seine eigenen Sicherungen +löschen kann, ist genau das Werkzeug, das man einem übernommenen Dienst nicht +in die Hand geben will. Herausgeben reicht. Nachgemessen im Container: + +``` +touch /sicherungen/probe -> Read-only file system +``` + +**Und es gibt nur eine Form von Namen** — nicht „alles außer `..` und `/`", +sondern ein Muster, das genau auf die eigenen Archive passt. Wer einen Pfad +hineinschmuggeln will, müsste ihn erst so benennen. Das ist der Unterschied +zwischen dicht gemacht und dicht gebaut: + +``` +../../etc/passwd -> 404 +..%2f..%2fdata%2fmedia.db -> 400 +media.db -> 400 +d4rk_media-…-0854.tar.gz.evil -> 400 +ohne Anmeldung -> 401 +``` + +Der ganze Weg einmal wirklich gegangen, nicht nur die Kopfzeilen: + +``` +336 MB in 15,9 s durch den Proxy (~21 MB/s) +sha256 auf der Platte == sha256 heruntergeladen +tar tzf -> 4639 Eintraege +``` + +Jeder Griff steht im **Verwaltungs-Verlauf** (`sicherung | geholt | | + | `). Geloggt wird der Griff und nicht der Erfolg: ein +abgebrochener Download taucht dort ebenfalls auf, und das ist so gewollt — wer +später fragt, wer sich den Bestand geholt hat, will die Anfrage sehen. + +Die fünf neuen Prüfungen sind in `tools/rundgang.py` mit drin; der steht jetzt +bei **29 in Ordnung, 0 nicht**. + ### ⬜ Als Nächstes **Der Vergleichsmaßstab ist weg.** Am 11.08.2026 sind die Lite-Container diff --git a/docker-compose.yml b/docker-compose.yml index c3526a5..83da8f3 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -81,6 +81,17 @@ services: # genau ein Kopiervorgang. - media-data:/data + # Die fertigen Archive, damit man sie sich aus dem Panel holen kann, + # ohne sich per Fernwartung auf den Server zu klicken. Genau das war + # der Grund, aus dem es lange keine Kopie ausserhalb dieser Maschine + # gab: nicht Unwillen, sondern Umstaendlichkeit. + # + # DAS :ro AM ENDE IST DER WICHTIGE TEIL. Ein Dienst, der seine + # eigenen Sicherungen loeschen kann, ist genau das Werkzeug, das man + # einem uebernommenen Dienst nicht in die Hand geben will. + # Herausgeben reicht. + - ${BACKUP_DIR:-C:/backup/d4rk_media}:/sicherungen:ro + ports: # Links der Host-Port, rechts der im Container. Nur die LINKE Zahl # muss auf diesem Server einmalig sein. diff --git a/docs/ideen.md b/docs/ideen.md index 6e1bf9c..6e57642 100644 --- a/docs/ideen.md +++ b/docs/ideen.md @@ -158,6 +158,14 @@ Sicherungsziel kaum. | **Discord-Kanal** (nur der Bot) | dasselbe | 9 MB je Datei — für d4rk_media mit 336 MB unbrauchbar | | 5-TB-Platte **am Server** | nur Plattenausfall | dritte Platte im selben Gehäuse — `D:` kann das schon | +### Der erste Schritt ist gemacht: von Hand holen + +Einstellungen → **Sicherungen holen** listet die Archive und gibt sie heraus +(nur lesend eingehängt, Namensmuster statt Filter, jeder Griff im +Verwaltungs-Verlauf). Das ersetzt keine geplante Abholung — aber es macht die +Auswärtskopie zu etwas, das man im Vorbeigehen erledigt, statt zu einem +Vorhaben. Was noch fehlt, ist, dass es **von allein** passiert. + ### Warum HOLEN und nicht SCHICKEN Ein Ziel, in das der Server selbst schreiben darf, ist auch eines, das ein diff --git a/server/src/routes/dash.ts b/server/src/routes/dash.ts index fb38f4d..89724eb 100644 --- a/server/src/routes/dash.ts +++ b/server/src/routes/dash.ts @@ -41,6 +41,7 @@ import { } from '../auth.js' import { mkdir, readdir, readFile, rm, rmdir, stat } from 'node:fs/promises' import { join } from 'node:path' +import { createReadStream } from 'node:fs' import { DISCORD_KEYS, MARKE_KEY, @@ -1938,6 +1939,79 @@ const GEHEIM = new Set([DISCORD_KEYS.clientSecret, SICHERUNG_KEYS.passwo * behaupten, die es dort nie gab. */ const NICHT_MITNEHMEN = [/^sicherung\.letzte$/, /^discord\.zuletzt/] +// ------------------------------------------------------- Sicherungen holen +// +// WOZU. Die Archive liegen auf dem WIRT, nicht im Container -- und wer sie +// woanders haben will, musste sich bisher per Fernwartung auf den Server +// klicken und sie von Hand ziehen. Das ist der Grund, aus dem es keine Kopie +// ausserhalb dieser Maschine gibt: nicht Unwillen, sondern Umstaendlichkeit. +// +// DER ORDNER HAENGT NUR LESEND. Ein Dienst, der seine eigenen Sicherungen +// loeschen kann, ist genau das Werkzeug, das man einem uebernommenen Dienst +// nicht in die Hand geben will. Herausgeben reicht. +// +// UND ES GIBT NUR EINE FORM VON NAMEN. Nicht "alles ausser .. und /", sondern +// ein Muster, das genau auf die eigenen Archive passt -- wer einen Pfad +// hineinschmuggeln will, muesste ihn erst so benennen. Das ist der Unterschied +// zwischen "dicht gemacht" und "dicht gebaut". +const SICHERUNGEN_DIR = process.env.SICHERUNGEN_DIR || '/sicherungen' +const ARCHIV_MUSTER = /^d4rk_media-\d{4}-\d{2}-\d{2}-\d{4}\.tar\.gz$/ + +dashRoutes.get('/sicherungen', async (c) => { + let namen: string[] + try { + namen = await readdir(SICHERUNGEN_DIR) + } catch { + // Nicht eingehaengt ist kein Fehler, sondern ein Zustand -- die + // Oberflaeche sagt dann, was zu tun ist, statt eine rote Meldung zu + // zeigen, die nach Defekt aussieht. + return c.json({ eingehaengt: false, items: [], ordner: SICHERUNGEN_DIR }) + } + + const items = [] + for (const name of namen.filter((n) => ARCHIV_MUSTER.test(n))) { + try { + const s = await stat(join(SICHERUNGEN_DIR, name)) + items.push({ name, size: s.size, at: s.mtimeMs }) + } catch { + /* zwischendurch weggeraeumt -- dann gehoert es nicht in die Liste */ + } + } + items.sort((a, b) => b.at - a.at) + + return c.json({ + eingehaengt: true, + ordner: SICHERUNGEN_DIR, + items, + bytes: items.reduce((n, i) => n + i.size, 0), + }) +}) + +dashRoutes.get('/sicherungen/:name', async (c) => { + const name = c.req.param('name') + if (!ARCHIV_MUSTER.test(name)) { + return c.json({ error: 'Kein Sicherungsarchiv.' }, 400) + } + + const pfad = join(SICHERUNGEN_DIR, name) + let groesse: number + try { + groesse = (await stat(pfad)).size + } catch { + return c.json({ error: 'Gibt es nicht (mehr).' }, 404) + } + + // Gestroemt und nicht in den Speicher gelesen: das Archiv ist 336 MB, und + // die haetten sonst der Dienst UND der Proxy gleichzeitig im Arbeitsspeicher. + logVerwaltung(c.get('user').username, 'sicherung', 'geholt', name, `${groesse} Bytes`) + return c.body(createReadStream(pfad) as any, 200, { + 'Content-Type': 'application/gzip', + 'Content-Length': String(groesse), + 'Content-Disposition': `attachment; filename="${name}"`, + 'Cache-Control': 'no-store', + }) +}) + dashRoutes.get('/einstellungen/export', (c) => { const mitGeheim = c.req.query('geheim') === '1' const alle = db.prepare('SELECT key, value FROM settings ORDER BY key').all() as { diff --git a/server/ui/src/api.ts b/server/ui/src/api.ts index 33d83df..5336f6c 100644 --- a/server/ui/src/api.ts +++ b/server/ui/src/api.ts @@ -230,6 +230,13 @@ export type Uebersicht = { vorlagen: Vorlage[] } +export type Sicherung = { + eingehaengt: boolean + ordner: string + bytes: number + items: { name: string; size: number; at: number }[] +} + export type Vorlage = { name: string; muster: string } /** Ein Konto. `weg` sagt, worueber jemand hereinkommt — die wichtigere Auskunft @@ -480,6 +487,7 @@ export const api = { ), einstellungen: () => get('/api/dash/settings'), + sicherungen: () => get('/api/dash/sicherungen'), sicherungSpeichern: (sicherung: Record) => post<{ ok: true; bereit: boolean; fehlt: string[] }>('/api/dash/settings', { sicherung }), meldungenSpeichern: (meldungen: { webhook?: string; anlaesse?: string[] }) => diff --git a/server/ui/src/components/SicherungenKarte.tsx b/server/ui/src/components/SicherungenKarte.tsx new file mode 100644 index 0000000..b89437b --- /dev/null +++ b/server/ui/src/components/SicherungenKarte.tsx @@ -0,0 +1,110 @@ +import { useEffect, useState } from 'react' +import { Download, HardDriveDownload, Loader2 } from 'lucide-react' +import { api, type Sicherung } from '../api' +import { useStore } from '../store' +import { bytes, zeit } from '../format' +import { Karte } from './Bausteine' + +/** Die fertigen Archive herunterladen. + * + * WOZU: die Sicherung lief längst, aber sie lag ausschließlich auf **dieser** + * Maschine — auf zwei Platten, und die dritte Kopie in der Nextcloud läuft + * auch hier. Wer sie woanders haben wollte, musste sich per Fernwartung auf + * den Server klicken und sie von Hand ziehen. Das ist der Grund, aus dem es + * keine Kopie außerhalb gab: nicht Unwillen, sondern Umständlichkeit. + * + * Ein Knopf hier ersetzt keine geplante Abholung — aber er macht die + * Auswärtskopie zu etwas, das man im Vorbeigehen erledigt, statt zu einem + * Vorhaben. */ +export function SicherungenKarte() { + const note = useStore((s) => s.note) + const [daten, setDaten] = useState(null) + const [laedt, setLaedt] = useState(true) + + useEffect(() => { + api.sicherungen() + .then(setDaten) + .catch((err) => note('fehler', err instanceof Error ? err.message : 'Unbekannt')) + .finally(() => setLaedt(false)) + // eslint-disable-next-line react-hooks/exhaustive-deps + }, []) + + if (laedt) { + return ( + +
+ +
+ + ) + } + + return ( + + {daten.items.length} Stück · {bytes(daten.bytes)} + + ) : undefined + } + > + {!daten?.eingehaengt ? ( +

+ Der Sicherungsordner ist nicht eingehängt. In der{' '} + docker-compose.yml braucht der + Dienst{' '} + + {daten?.ordner ?? '/sicherungen'} + {' '} + — nur lesend. +

+ ) : daten.items.length === 0 ? ( +

+ Noch keine Archive in {daten.ordner}. + Die Sicherung läuft täglich um 04:30. +

+ ) : ( + <> +

+ + + Alle Kopien liegen auf dieser{' '} + Maschine — auch die in der Nextcloud, die hier mitläuft. Ein Archiv, + das du herunterlädst, ist das erste, das den Server verlässt. + +

+ + + + )} + + ) +} diff --git a/server/ui/src/pages/Einstellungen.tsx b/server/ui/src/pages/Einstellungen.tsx index be7e835..9a8852d 100644 --- a/server/ui/src/pages/Einstellungen.tsx +++ b/server/ui/src/pages/Einstellungen.tsx @@ -14,6 +14,7 @@ import { bytes, zeit } from '../format' import { Feld, Karte, Knopf } from '../components/Bausteine' import { DiscordKarte } from '../components/DiscordKarte' import { VorlagenKarte } from '../components/VorlagenKarte' +import { SicherungenKarte } from '../components/SicherungenKarte' import { FreigabenKarte } from '../components/FreigabenKarte' import { BenutzerKarte } from '../components/BenutzerKarte' import { MitnehmenKarte } from '../components/MitnehmenKarte' @@ -46,6 +47,7 @@ export function Einstellungen() { + diff --git a/tools/rundgang.py b/tools/rundgang.py index 40267b2..f7fdb26 100644 --- a/tools/rundgang.py +++ b/tools/rundgang.py @@ -89,7 +89,8 @@ if r.stdout != '200': print('\n-- Was ohne Anmeldung dicht sein muss ' + '-' * 32) for weg in ('/api/dash/media', '/api/dash/tokens', '/api/dash/verlauf/export', '/api/dash/papierkorb', '/api/dash/benutzer', '/api/dash/settings', - '/api/dash/einstellungen/export', '/api/dash/verwaltung'): + '/api/dash/einstellungen/export', '/api/dash/verwaltung', + '/api/dash/sicherungen'): code, *_ = curl(f'{BASIS}{weg}', keks=False) pruefe(weg, code == '401', f'HTTP {code}') @@ -155,6 +156,23 @@ for anhang, name in (('', 'dateien'), ('?was=verwaltung', 'verwaltung')): pruefe(f'CSV {name}', name in r.stdout and nackte == 0, f'{roh.count(CRLF)} Zeilen, {nackte} nackte LF') +# -- Die Archive zum Mitnehmen ------------------------------------------------- +print(chr(10) + '-- Die Archive zum Mitnehmen ' + '-' * 40) +code, _, _, rumpf = curl(f'{BASIS}/api/dash/sicherungen') +sich = json.loads(rumpf) +pruefe('Sicherungsordner eingehaengt', sich.get('eingehaengt') is True, + f"{len(sich.get('items', []))} Archive in {sich.get('ordner')}") + +# Der Weg nach draussen ist der, den man pruefen MUSS: dort liegt der ganze +# Bestand als eine Datei, und ein Muster, das zu viel durchlaesst, gaebe jede +# Datei des Servers heraus. Geprueft wird deshalb, was NICHT gehen darf. +for boese, was in (('../../etc/passwd', 'Pfad hoch'), + ('..%2f..%2fdata%2fmedia.db', 'kodiert hoch'), + ('media.db', 'andere Datei'), + ('d4rk_media-2026-01-01-0000.tar.gz.evil', 'Anhang drangehaengt')): + code, *_ = curl(f'{BASIS}/api/dash/sicherungen/{boese}') + pruefe(f'abgewiesen: {was}', code in ('400', '404'), f'HTTP {code}') + # -- Papierkorb und Sicherung -------------------------------------------------- print('\n-- Papierkorb und Sicherung ' + '-' * 42) code, _, _, rumpf = curl(f'{BASIS}/api/dash/papierkorb')