chore(release): 0.2.1

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
fix(db): Migrationen ohne Fremdschlüsselprüfung und in einer Transaktion
2026-10-10 23:53:07 +02:00 · 2026-10-10 23:51:15 +02:00 · 2026-10-10 23:43:40 +02:00 · 2026-10-10 23:43:40 +02:00 · 2026-10-10 23:43:40 +02:00 · 2026-10-10 23:43:40 +02:00
34 changed files with 1789 additions and 72 deletions
@@ -8,6 +8,72 @@ Die Version steht an genau einer Stelle: `src/netmover/__init__.py`.

 ## [Unreleased]

+## [0.2.1] – 2026-10-11
+
+### Behoben
+- **Update von 0.1.x auf 0.2.0 scheiterte**: Migration 0002 brach auf einer
+  Datenbank mit Anbindungen ab (`FOREIGN KEY constraint failed` beim Neuaufbau der
+  Tabelle `credentials`). Weil SQLite-Migrationen nicht in einer Transaktion liefen,
+  blieb dabei ein halber Zustand zurück. Migrationen laufen jetzt ohne
+  Fremdschlüsselprüfung, aber mit Integritätsprüfung vor dem Commit und vollständig
+  in einer Transaktion: Ein Abbruch hinterlässt die Datenbank unverändert.
+  Geprüft mit Tests auf verknüpften Daten und an einer Kopie einer echten Datenbank.
+- `netmover-update` zeigt beim Zurückstufen keinen irreführenden Changelog-Auszug mehr.
+
+## [0.2.0] – 2026-10-11
+
+> ⚠️ **Nicht verwenden** – das Update von 0.1.x scheitert an Migration 0002.
+> Stattdessen 0.2.1 installieren. Wer 0.2.0 schon versucht hat: Die Datenbank aus der
+> Sicherung von `netmover-update` zurückspielen und auf 0.2.1 aktualisieren.
+
+### Hinzugefügt
+- **Schlüsselverwaltung** (Seite „Schlüssel“): SSH-Schlüssel erzeugen (Ed25519) oder
+  importieren (Ed25519, ECDSA, RSA ≥ 2048 Bit; OpenSSH/PEM, auch mit Passphrase),
+  Fingerabdruck und `authorized_keys`-Zeile mit SFTP-Beschränkung zum Kopieren,
+  Umbenennen, Löschen nur wenn unbenutzt. Private Schlüssel werden nie angezeigt.
+- SFTP-Anbindungen können einen gespeicherten Schlüssel auswählen; der Benutzername
+  gehört zur Anbindung (Migration 0002: `credentials.managed`, `mounts.username`).
+- **`netmover-update`**: Update aus dem Git-Repo mit Sicherung von Datenbank,
+  Schlüsseln und Einstellungen, Changelog-Auszug, Neustart und Healthcheck;
+  Versionswahl, Warnung beim Zurückstufen.
+- Installation als Git-Klon unter `/opt/netmover/src`; `install.sh` installiert
+  `git` und das Update-Skript.
+
+### Geändert
+- Klartext-Hinweis bei `mount error(95)` (keine gemeinsame SMB-Version) mit
+  Synology-Einstellung; aufgefallen bei der Anbindung des echten NAS.
+- SFTP-Anbindungen gelten nach erfolgreichem Test als „erreichbar“ (vorher bis
+  zum ersten Regellauf „nicht geprüft“).
+
+## [0.1.1] – 2026-10-10
+
+Korrekturen aus dem ersten Praxistest auf einer Debian-13-VM mit echten
+SMB-, NFS- und SFTP-Servern.
+
+### Behoben
+- **systemd-Unit:** `ProtectSystem`, `PrivateTmp` und `ProtectControlGroups`
+  gaben dem Dienst einen eigenen Mount-Namespace. Die Mounts waren für das System
+  und andere Programme unsichtbar und verschwanden bei jedem Neustart des Dienstes
+  (`MountFlags=shared` half nicht). Jetzt nur noch Härtungen ohne Namespace.
+- **Stabilitätsprüfung:** CIFS lieferte per `stat()` sekundenlang eine veraltete
+  Größe einer noch wachsenden Datei. Gemessen wird jetzt per `open()` + `fstat()`,
+  das erzwingt frische Attribute. Gesperrte Dateien gelten als „in Benutzung“.
+  (Die zweite Sicherung, die Byte-Zählung beim Kopieren, hatte den Fall bereits
+  abgefangen; es kam keine unvollständige Datei an.)
+- **Ausfall länger als die Wiederherstellung (z. B. NAS-Neustart, Stromausfall):**
+  Von NetMover selbst ausgehängte Anbindungen mit „automatisch einhängen“ werden
+  jetzt jede Minute erneut eingehängt, auch wenn das Einhängen schon beim
+  Dienststart scheiterte. Entwarnung per Webhook. Von außen ausgehängte Anbindungen
+  bleiben weiterhin unangetastet.
+- Bei einer Zeitüberschreitung von `mount` wird die ganze Prozessgruppe beendet, damit
+  `mount.nfs` nicht später doch noch einhängt.
+- Hinweistexte zu `mount`-Fehlern werden nicht mehr mitgeschwärzt.
+- `install.sh` ohne `debconf`-Warnungen, wenn kein Terminal angeschlossen ist.
+
+### Dokumentation
+- Fehlersuche: verzögert sichtbare Dateien auf CIFS → `nohandlecache`.
+- README erklärt, warum die Unit keine Namespace-Härtung nutzt.
+
 ## [0.1.0] – 2026-10-10

 Erste Version.
@@ -99,5 +165,8 @@ Erste Version.
 - Löschen von Zugangsdaten, die noch von einem Mount benutzt werden, trennt den
  Mount nicht mehr stillschweigend ab, sondern wird von der Datenbank abgelehnt.

-[Unreleased]: https://git.wilde-server.de/florian.wilde/netmover/compare/v0.1.0...HEAD
+[Unreleased]: https://git.wilde-server.de/florian.wilde/netmover/compare/v0.2.1...HEAD
+[0.2.1]: https://git.wilde-server.de/florian.wilde/netmover/compare/v0.2.0...v0.2.1
+[0.2.0]: https://git.wilde-server.de/florian.wilde/netmover/compare/v0.1.1...v0.2.0
+[0.1.1]: https://git.wilde-server.de/florian.wilde/netmover/compare/v0.1.0...v0.1.1
 [0.1.0]: https://git.wilde-server.de/florian.wilde/netmover/releases/tag/v0.1.0
@@ -13,10 +13,85 @@ Zeiten in Ortszeit (Europe/Berlin).
 | 2026-10-10 | 19:10 | 19:17 | 0:07  | 4       | Scheduler, Protokoll, Benachrichtigung |
 | 2026-10-10 | 19:18 | 19:34 | 0:16  | 5       | Weboberfläche und Anmeldung            |
 | 2026-10-10 | 19:40 | 19:50 | 0:10  | 6       | Deployment, README, Release 0.1.0      |
-| **Summe**  |       |       | **1:06** |      |                                        |
+| 2026-10-10 | 21:36 | 22:05 | 0:29  | –       | Praxistest auf VM, Release 0.1.1       |
+| 2026-10-10 | 22:45 | 23:00 | 0:15  | –       | Echtes NAS/Paperless anbinden          |
+| 2026-10-10 | 23:31 | 23:58 | 0:27  | –       | Schlüsselverwaltung, Update-Skript, 0.2.x |
+| **Summe**  |       |       | **2:17** |      |                                        |

 ---

+## 2026-10-10 · 23:31–23:58 · Schlüsselverwaltung, Update-Skript, Releases 0.2.0/0.2.1
+
+**Erledigt**
+- Schlüsselverwaltung (`keys.py`, Seite „Schlüssel“, Auswahl in SFTP-Anbindungen),
+  Migration 0002 (`credentials.managed`, `mounts.username`).
+- `deploy/update.sh` → `netmover-update`: Tags holen, Sicherung (SQLite-Online-
+  Backup + Schlüssel + env), Checkout, `install.sh`, Healthcheck, Rückweg-Anleitung.
+- VM auf Git-Klon `/opt/netmover/src` umgestellt (Repo ist öffentlich lesbar).
+
+**Zwischenfall beim Update der VM auf 0.2.0**
+- Migration 0002 scheiterte: `FOREIGN KEY constraint failed` bei `DROP TABLE
+  credentials` (Alembic-Batch baut die Tabelle neu; `foreign_keys=ON`, und die
+  Anbindungen verweisen darauf). Danach crashte jeder Neustart an der
+  übriggebliebenen `_alembic_tmp_credentials` (DDL lief ohne Transaktion).
+- `netmover-update` hat den Fehler erkannt und die Rückweg-Befehle genannt.
+  Sicherung zurückgespielt, mit `netmover-update v0.1.1` zurückgestuft – in
+  ~1 Minute wieder lauffähig, NAS-Mount blieb durchgehend eingehängt.
+- Ursache, warum die Tests es nicht fanden: Migrationen wurden nur auf **leeren**
+  Datenbanken getestet. Neu: `tests/test_migrations.py` mit verknüpften Daten und
+  mit Abbruch mitten in der Migration (Datenbank muss unverändert bleiben).
+- Fix: eigene Migrationsverbindung (FK aus, `BEGIN IMMEDIATE`, `transactional_ddl`,
+  `foreign_key_check` vor dem Commit). Vor dem Release an einer Kopie der echten
+  Datenbank auf der VM geprüft.
+- Tag v0.2.0 bleibt (veröffentlicht), im Changelog als „nicht verwenden“ markiert.
+
+**Lehre**
+- Jede künftige Migration bekommt einen Test auf einer befüllten Datenbank.
+
+## 2026-10-10 · 21:36–22:05 · Praxistest auf der Debian-13-VM, Release 0.1.1
+
+**Umgebung**
+- KVM-VM `srv-rz-netmover` (10.0.10.223), Debian 13, Python 3.13, 2 GB RAM.
+- Installation per `deploy/install.sh` aus einem `git archive` (VM ohne Gitea-Zugang).
+- Vorübergehende Testserver auf der VM: Samba (nur `lo`), NFS-Exporte für
+  `127.0.0.1` (mit/ohne Root-Squash), SFTP-Benutzer `paperless` mit Schlüssel
+  `restrict,command="/usr/lib/openssh/sftp-server"`.
+- Auf Wunsch `NETMOVER_HOST=0.0.0.0`, damit die Oberfläche im LAN erreichbar ist.
+
+**Bestanden**
+- Ersteinrichtung mit Code aus dem Log, Cookie-Flags.
+- CIFS (Passwort mit Komma/Ausrufezeichen, Credentials-Datei danach weg), NFS 4,
+  NFS 3, Root-Squash-Erkennung mit Synology-Hinweis, SFTP mit TOFU (Fingerabdruck
+  = `ssh-keygen -lf`), echtes OpenSSH liefert `statvfs`.
+- Probelauf, Kollision `scan001-1.pdf`, `.txt`/`.part` ignoriert, keine `.part`-Reste,
+  Eigentümer `paperless` im SFTP-Ziel.
+- Langsam wachsende Datei (20 × 50 KB/s): erst nach Ende verschoben, Prüfsumme gleich.
+- Kopiermodus rekursiv mit Eigentümer/Modus; zweiter Lauf „2 bereits übertragen“.
+- Samba gestoppt: Lebenszeichen 15 s → gestört → 3 Versuche → Fehler, `/healthz` 503,
+  nichts angefasst. NFS-Server gestoppt (hängender `hard`-Mount): Oberfläche und
+  andere Regel liefen weiter, Rückkehr automatisch.
+- Mounts überstehen Stopp/Start des Dienstes (gleiche Mount-IDs).
+- Neustart der VM: NFS sofort, SMB per Neuversuch nach ~1 min, Regel läuft weiter.
+
+**Gefunden und behoben (v0.1.1)**
+1. **systemd-Unit mit eigenem Mount-Namespace** (ProtectSystem/PrivateTmp/…):
+   Mounts nur im Dienst sichtbar, `shared,slave`. Härtung ohne Namespace.
+2. **CIFS-Attribut-Cache**: `stat()` meldete 3 s lang eine veraltete Größe einer
+   wachsenden Datei; die Byte-Zählung beim Kopieren fing das ab. Jetzt
+   `open()` + `fstat()` für beide Messungen.
+3. **Nach drei gescheiterten Versuchen endgültig aufgegeben** – zu kurz für einen
+   NAS-Neustart, und beim Booten vor dem NAS kam die Freigabe nie zurück.
+   Jetzt minütlicher Neuversuch (nur für von NetMover selbst ausgehängte
+   Anbindungen mit `auto_mount`) plus Scheduler-Job.
+4. `mount`-Zeitlimit beendete nur `mount`, nicht `mount.nfs` → später doch
+   eingehängt. Jetzt ganze Prozessgruppe.
+5. Hinweistext wurde mitgeschwärzt; `debconf`-Warnungen in `install.sh`.
+
+**Nicht nachstellbar**
+- Einmalig 46 s Verzögerung direkt nach dem Booten (CIFS-Verzeichnis-Cache bei
+  lokal statt per SMB angelegter Datei). Messungen danach 9–11 s, mit und ohne
+  `nohandlecache`. Als Hinweis in die Fehlersuche aufgenommen.
+
 ## 2026-10-10 · 19:40–19:50 · Schritt 6: Deployment, README, Release 0.1.0

 **Erledigt**
@@ -47,15 +47,36 @@ heißt deshalb immer **kopieren, prüfen, dann erst die Quelle löschen**:

 ```bash
 apt install -y git
-git clone https://git.wilde-server.de/florian.wilde/netmover.git
-cd netmover
-sudo ./deploy/install.sh
+git clone https://git.wilde-server.de/florian.wilde/netmover.git /opt/netmover/src
+cd /opt/netmover/src && git checkout "$(git tag -l 'v*' --sort=-v:refname | head -n 1)"
+./deploy/install.sh
 ```

-Das Skript installiert `python3-venv`, `cifs-utils` und `nfs-common` und richtet
-NetMover in `/opt/netmover/venv` ein. Danach installiert es
-[`deploy/netmover.service`](deploy/netmover.service) und startet den Dienst.
-Ein Update ist derselbe Aufruf nach einem `git pull`.
+Das Skript installiert `python3-venv`, `cifs-utils`, `nfs-common` und `git`. Es
+richtet NetMover in `/opt/netmover/venv` ein, installiert
+[`deploy/netmover.service`](deploy/netmover.service) und das Update-Skript
+`netmover-update` und startet den Dienst.
+
+### Update
+
+```bash
+netmover-update            # auf die neueste Version
+netmover-update --list     # verfügbare Versionen
+netmover-update v0.2.0     # bestimmte Version
+```
+
+`netmover-update` geht so vor:
+1. Neue Versions-Tags aus Gitea holen und die Änderungen laut Changelog anzeigen.
+2. **Datenbank, `secret.key` und Einstellungen nach `/var/backups/netmover/` sichern**
+   (die letzten 10 bleiben).
+3. Die Version auschecken, installieren und den Dienst neu starten. Neue
+   Datenbank-Migrationen laufen dabei automatisch.
+4. `/healthz` prüfen.
+
+Die Mounts bleiben die ganze Zeit eingehängt. Geht etwas schief, nennt das Skript
+die Befehle, um die Sicherung zurückzuspielen und zur vorherigen Version zu wechseln.
+**Zurückstufen** auf eine ältere Version geht nur mit der Datenbank-Sicherung von
+vor dem Update, wenn das Update eine Migration enthielt; das Skript fragt deshalb nach.

 Was wo liegt:

@@ -69,13 +90,18 @@ Was wo liegt:

 **Warum als root?** Ein- und Aushängen braucht `CAP_SYS_ADMIN`. Außerdem soll
 NetMover Dateien auf beliebigen Freigaben lesen, löschen und mit den richtigen
-Eigentümern anlegen können. Die Unit härtet den Dienst so weit, wie es sich mit
-Mounten verträgt: `ProtectSystem=full`, `PrivateTmp`, `NoNewPrivileges`, Zustand nur
-für root lesbar. Weil diese Optionen einen eigenen Mount-Namespace erzeugen, steht
-`MountFlags=shared` in der Unit. Nur so sieht das System die Mounts:
+Eigentümern anlegen können.
+
+**Warum so wenig systemd-Härtung?** Optionen wie `ProtectSystem=`, `PrivateTmp=`
+oder `ProtectHome=` geben dem Dienst einen eigenen Mount-Namespace. Die Mounts
+landeten dann *nur dort*: Das System und Paperless sähen sie nicht, und jeder
+Neustart des Dienstes würde sie verwerfen. `MountFlags=shared` hilft dagegen nicht.
+Auf der Test-VM nachgewiesen. Die Unit nutzt deshalb nur Härtungen ohne eigenen
+Namespace (`NoNewPrivileges`, `RestrictSUIDSGID`, `LockPersonality`,
+`RestrictRealtime`); Datenbank und Schlüssel sind nur für root lesbar. Prüfen:

 ```bash
-findmnt -R /mnt/netmover    # sollte die eingehängten Freigaben zeigen
+findmnt -l | grep /mnt/netmover    # die eingehängten Freigaben müssen hier stehen
 ```

 **Beim Beenden bleiben die Mounts eingehängt**, weil andere Programme sie benutzen
@@ -144,11 +170,18 @@ Lege in NetMover die *Anbindung → Neue Anbindung* an:
 | Typ | SFTP (nur Ziel) |
 | Server / SSH-Port | IP des LXC / `22` |
 | Freigabe / Pfad | `/opt/paperless_data/consume` |
-| Anmeldeart | SSH-Schlüssel (NetMover erzeugt ihn) |
+| Anmeldeart | SSH-Schlüssel |
+| Schlüssel | einen gespeicherten Schlüssel wählen (siehe unten) oder „neuer Schlüssel nur für diese Anbindung“ |
 | Benutzername | `paperless` (der Benutzer, unter dem Paperless läuft) |

-Nach dem Speichern zeigt NetMover den **öffentlichen Schlüssel**. Trage ihn im LXC
-ein, und zwar so, dass der Schlüssel **nur SFTP** darf:
+**Schlüsselverwaltung:** Unter *Schlüssel* erzeugst du Ed25519-Schlüssel oder
+importierst vorhandene (Ed25519, ECDSA, RSA ≥ 2048 Bit; OpenSSH- oder PEM-Format,
+auch mit Passphrase). Ein Schlüssel kann von mehreren Anbindungen genutzt werden; den
+Benutzernamen legt jede Anbindung selbst fest. Private Schlüssel liegen verschlüsselt
+in der Datenbank und werden nie angezeigt. Die Seite zeigt den Fingerabdruck und eine
+fertige `authorized_keys`-Zeile zum Kopieren.
+
+Trage den öffentlichen Schlüssel im LXC so ein, dass er **nur SFTP** darf:

 ```bash
 # im Paperless-LXC als root
@@ -322,6 +355,7 @@ findmnt -R /mnt/netmover                     # was ist wirklich eingehängt?
 |---|---|
 | `mount error(13): Permission denied` (CIFS) | Benutzer oder Passwort falsch, oder keine Rechte auf die Freigabe. |
 | `mount error(2): No such file or directory` | Freigabename falsch geschrieben (Groß/klein!). |
+| `mount error(95): Operation not supported` | Keine gemeinsame SMB-Version (im Kernel-Log: „Dialect not supported by server“). Am NAS das maximale SMB-Protokoll auf SMB3 stellen oder Zusatzoption `vers=2.0`. |
 | `mount error(112): Host is down` | NAS nicht erreichbar, oder SMB1 erwartet: `vers=3.0` bzw. `vers=2.1` probieren. |
 | `… helper program` / `unknown filesystem type` | `apt install cifs-utils nfs-common` |
 | `Operation not permitted` / `only root can do that` | Kein `CAP_SYS_ADMIN`: unprivilegierter LXC oder Docker ohne `cap_add`. |
@@ -330,10 +364,12 @@ findmnt -R /mnt/netmover                     # was ist wirklich eingehängt?
 | „… ist nicht leer“ beim Einhängen | Im Mountpoint liegen Dateien, die geschrieben wurden, als nichts eingehängt war. Inhalt prüfen und sichern, Verzeichnis leeren, erneut einhängen. |
 | „nicht eingehängt – Lauf abgebrochen“ | Die Freigabe ist weg (z. B. von Hand ausgehängt). Auf der Anbindungsseite **Einhängen**. NetMover hängt verschwundene Mounts absichtlich nicht selbst neu ein. |
 | „gestört (ESTALE …)“, danach wieder OK | NAS-Neustart; NetMover hat neu eingehängt. Bleibt der Fehler: Netzwerk/NAS prüfen. |
+| „weiterhin nicht verfügbar – neuer Versuch in 60 s“ | Das NAS ist (noch) weg, z. B. während eines DSM-Updates. Bei Anbindungen mit „automatisch einhängen“ versucht NetMover es jede Minute erneut und meldet per Webhook, wenn es wieder klappt. |
 | „Keine Reaktion seit 120 s“ | Ein Dateizugriff hängt (meist NFS mit `hard`). Die Regel bleibt blockiert („läuft seit …“), bis der Zugriff zurückkehrt; die Anbindung wird vor dem nächsten Lauf geprüft. |
 | „Hostschlüssel … hat sich geändert“ (SFTP) | Wurde der Zielserver neu aufgesetzt? Dann bei der Anbindung „Hostschlüssel zurücksetzen“ und neu testen. Sonst **nicht** verbinden. |
 | SFTP: „Anmeldung abgelehnt“ | Öffentlicher Schlüssel fehlt in `authorized_keys`, oder Rechte von `~/.ssh` stimmen nicht (700/600, Eigentümer). |
 | Paperless bemerkt neue Dateien nicht | Ältere Paperless-Versionen: `PAPERLESS_CONSUMER_POLLING=10` setzen. |
+| Neue Dateien erscheinen erst nach bis zu 30 s | Der CIFS-Client speichert Verzeichnislisten zwischen. Gelangen Dateien nicht per SMB aufs NAS (z. B. per FTP vom Scanner), erfährt er nichts davon. Abhilfe: Zusatzoption `nohandlecache`. |
 | Regel gelb „länger als 3 × Intervall“ | Seit dem Dreifachen des Intervalls kein erfolgreicher Lauf; Protokoll der Regel ansehen. |
 | Einrichtungscode verloren | `systemctl restart netmover` erzeugt einen neuen. |

@@ -381,7 +417,7 @@ Aufbau:
 | `mounting/` | `MountBackend` (Linux/Fake), Mount-Verwaltung, Test, Wiederherstellung, SFTP |
 | `mover/` | Scan, Stabilität, atomares Schreiben, Kollisionen, Buchführung, Regellauf |
 | `runs.py`, `scheduler.py`, `health.py`, `notify.py` | Protokoll, Zeitsteuerung, Gesundheit, Webhook |
-| `admin.py`, `transfer.py`, `web/` | Formulare, Export/Import, Oberfläche |
+| `admin.py`, `keys.py`, `transfer.py`, `web/` | Formulare, Schlüsselverwaltung, Export/Import, Oberfläche |

 Die gesamte Mover-Logik ist mit dem `FakeMountBackend` ohne root testbar. SFTP
 wird gegen einen echten SFTP-Server im Testprozess getestet.
@@ -4,7 +4,7 @@
 services:
  netmover:
    build: .
-    image: netmover:0.1.0
+    image: netmover:0.2.1
    container_name: netmover
    restart: unless-stopped
    cap_add:
@@ -1,8 +1,10 @@
 #!/bin/sh
 # NetMover auf Debian 13 installieren bzw. aktualisieren (als root ausführen).
 #
-#   ./deploy/install.sh                 # aus diesem Verzeichnis installieren
-#   ./deploy/install.sh 'git+https://git.wilde-server.de/florian.wilde/netmover.git@v0.1.0'
+#   git clone https://git.wilde-server.de/florian.wilde/netmover.git /opt/netmover/src
+#   /opt/netmover/src/deploy/install.sh
+#
+# Spätere Updates: netmover-update (siehe deploy/update.sh).
 set -eu

 SOURCE="${1:-$(cd "$(dirname "$0")/.." && pwd)}"
@@ -14,8 +16,9 @@ if [ "$(id -u)" -ne 0 ]; then
 fi

 echo "==> Pakete"
+export DEBIAN_FRONTEND=noninteractive
 apt-get update -qq
-apt-get install -y -qq python3 python3-venv cifs-utils nfs-common >/dev/null
+apt-get install -y -qq python3 python3-venv cifs-utils nfs-common git >/dev/null

 echo "==> Virtuelle Umgebung in $PREFIX/venv"
 install -d -m 0755 "$PREFIX"
@@ -30,6 +33,9 @@ if [ ! -f /etc/netmover/netmover.env ]; then
 fi
 install -d -m 0755 /mnt/netmover

+echo "==> Update-Skript"
+install -m 0755 "$(dirname "$0")/update.sh" /usr/local/sbin/netmover-update
+
 echo "==> systemd"
 install -m 0644 "$(dirname "$0")/netmover.service" /etc/systemd/system/netmover.service
 systemctl daemon-reload
@@ -27,18 +27,17 @@ RuntimeDirectory=netmover
 RuntimeDirectoryMode=0700

 # Härtung, soweit mit Mounten vereinbar.
-# Die Optionen unten erzeugen einen eigenen Mount-Namespace für den Dienst.
-# MountFlags=shared sorgt dafür, dass Mounts unter /mnt/netmover trotzdem im
-# System sichtbar sind (prüfen mit: findmnt -R /mnt/netmover).
-MountFlags=shared
-# /usr, /boot und /etc schreibgeschützt; /mnt, /opt, /srv, /var bleiben schreibbar
-# (lokale Ziele wie /opt/paperless/consume funktionieren also).
-ProtectSystem=full
-PrivateTmp=yes
+# WICHTIG: Keine Optionen, die einen eigenen Mount-Namespace erzeugen
+# (ProtectSystem=, ProtectHome=, PrivateTmp=, ProtectControlGroups=,
+# ReadOnlyPaths=, BindPaths= …). Sonst landen die Mounts im Namespace des
+# Dienstes: das System und andere Programme (Paperless!) sähen sie nicht, und
+# jeder Neustart des Dienstes würde sie verwerfen. MountFlags=shared hilft dagegen
+# nicht – systemd setzt den Namespace als „slave“ auf, Mounts fließen nur hinein.
+# Auf dem Testsystem nachgewiesen; prüfen mit: findmnt -l | grep /mnt/netmover
 NoNewPrivileges=yes
-ProtectControlGroups=yes
 LockPersonality=yes
 RestrictRealtime=yes
+RestrictSUIDSGID=yes
 UMask=0022

 [Install]
@@ -0,0 +1,153 @@
+#!/bin/sh
+# NetMover aktualisieren (als root). Wird von install.sh als
+# /usr/local/sbin/netmover-update installiert.
+#
+#   netmover-update            # auf die neueste Version (neuester Tag vX.Y.Z)
+#   netmover-update v0.2.0     # auf eine bestimmte Version (auch zurück)
+#   netmover-update --list     # verfügbare Versionen anzeigen
+#
+# Ablauf: Tags holen → Datenbank und Schlüssel sichern → Version auschecken →
+# install.sh (installiert, migriert beim Start, startet den Dienst neu) →
+# Gesundheit prüfen. Die Mounts bleiben dabei eingehängt.
+set -eu
+
+SRC="${NETMOVER_SRC:-/opt/netmover/src}"
+VENV=/opt/netmover/venv
+ENV_FILE=/etc/netmover/netmover.env
+BACKUP_ROOT=/var/backups/netmover
+KEEP_BACKUPS=10
+
+if [ "$(id -u)" -ne 0 ]; then
+    echo "Bitte als root ausführen." >&2
+    exit 1
+fi
+if [ ! -d "$SRC/.git" ]; then
+    echo "Kein Git-Klon unter $SRC. Einmalig einrichten:" >&2
+    echo "  git clone https://git.wilde-server.de/florian.wilde/netmover.git $SRC" >&2
+    exit 1
+fi
+
+# Einstellungen des Dienstes (Port, Datenverzeichnis)
+NETMOVER_PORT=8080
+NETMOVER_DATA_DIR=/var/lib/netmover
+# shellcheck disable=SC1090
+[ -f "$ENV_FILE" ] && . "$ENV_FILE"
+
+cd "$SRC"
+git fetch --tags --quiet origin
+
+if [ "${1:-}" = "--list" ]; then
+    git tag -l 'v*' --sort=-v:refname
+    exit 0
+fi
+
+TARGET="${1:-$(git tag -l 'v*' --sort=-v:refname | head -n 1)}"
+if ! git rev-parse -q --verify "refs/tags/$TARGET" >/dev/null; then
+    echo "Version $TARGET gibt es nicht. Verfügbar:" >&2
+    git tag -l 'v*' --sort=-v:refname | head -n 10 >&2
+    exit 1
+fi
+CURRENT="v$("$VENV/bin/netmover" version 2>/dev/null || echo "?")"
+echo "Installiert: $CURRENT"
+echo "Ziel:        $TARGET"
+if [ "$CURRENT" = "$TARGET" ] && [ "${FORCE:-0}" != "1" ]; then
+    echo "Bereits auf dem gewünschten Stand (FORCE=1 erzwingt eine Neuinstallation)."
+    exit 0
+fi
+
+NEWEST="$(printf '%s\n%s\n' "$CURRENT" "$TARGET" | sort -V | tail -n 1)"
+if [ "$NEWEST" = "$CURRENT" ] && [ "$CURRENT" != "$TARGET" ]; then
+    echo
+    echo "!! Zurückstufen auf eine ältere Version: Wurde die Datenbank inzwischen migriert,"
+    echo "   startet die alte Version nicht. Dann vorher die Sicherung von *vor* dem Update"
+    echo "   zurückspielen (siehe $BACKUP_ROOT, Anleitung im README)."
+    printf "   Trotzdem fortfahren? [j/N] "
+    read -r answer
+    [ "$answer" = "j" ] || [ "$answer" = "J" ] || exit 1
+fi
+
+if [ "$NEWEST" = "$TARGET" ]; then
+echo
+echo "==> Änderungen laut Changelog"
+git show "$TARGET:CHANGELOG.md" | awk -v cur="${CURRENT#v}" '
+    /^## \[/ { if (index($0, "[" cur "]")) exit; show = ($0 !~ /Unreleased/) }
+    show' | head -n 60
+fi
+
+echo
+echo "==> Sicherung"
+STAMP="$(date +%Y%m%d-%H%M%S)"
+BACKUP="$BACKUP_ROOT/$STAMP-$CURRENT"
+install -d -m 0700 "$BACKUP_ROOT" "$BACKUP"
+# Konsistente Kopie auch bei laufendem Dienst (SQLite-Online-Backup)
+"$VENV/bin/python" - "$NETMOVER_DATA_DIR/netmover.db" "$BACKUP/netmover.db" <<'EOF'
+import sqlite3, sys
+src, dst = sqlite3.connect(sys.argv[1]), sqlite3.connect(sys.argv[2])
+with dst:
+    src.backup(dst)
+src.close(); dst.close()
+EOF
+for f in secret.key session.key; do
+    [ -f "$NETMOVER_DATA_DIR/$f" ] && cp -p "$NETMOVER_DATA_DIR/$f" "$BACKUP/"
+done
+[ -f "$ENV_FILE" ] && cp -p "$ENV_FILE" "$BACKUP/"
+chmod 0600 "$BACKUP"/*
+echo "    $BACKUP"
+# alte Sicherungen aufräumen
+find "$BACKUP_ROOT" -mindepth 1 -maxdepth 1 -type d -print | sort \
+    | head -n "-$KEEP_BACKUPS" | xargs -r rm -rf --
+
+echo
+echo "==> Version $TARGET auschecken und installieren"
+git -c advice.detachedHead=false checkout --quiet "$TARGET"
+"$SRC/deploy/install.sh" "$SRC" >/tmp/netmover-update.log 2>&1 || {
+    echo "install.sh ist fehlgeschlagen – Ausgabe: /tmp/netmover-update.log" >&2
+    tail -n 20 /tmp/netmover-update.log >&2
+    FAILED=1
+}
+
+echo
+echo "==> Prüfung"
+OK=0
+if [ "${FAILED:-0}" != "1" ]; then
+    i=0
+    while [ $i -lt 30 ]; do
+        if "$VENV/bin/python" - "$NETMOVER_PORT" <<'EOF'
+import json, sys, urllib.error, urllib.request
+url = f"http://127.0.0.1:{sys.argv[1]}/healthz"
+try:
+    body = urllib.request.urlopen(url, timeout=3).read()
+except urllib.error.HTTPError as exc:  # 503 = läuft, meldet aber Probleme
+    body = exc.read()
+except OSError:
+    sys.exit(1)
+data = json.loads(body)
+print(f"    Gesundheit: {data['status']}")
+for p in data.get("problems", []):
+    print(f"    – {p}")
+EOF
+        then
+            OK=1
+            break
+        fi
+        i=$((i + 1))
+        sleep 1
+    done
+fi
+
+if [ "$OK" = "1" ] && systemctl is-active --quiet netmover; then
+    echo "    Dienst läuft: $("$VENV/bin/netmover" version)"
+    echo
+    echo "Fertig. Sicherung: $BACKUP"
+    exit 0
+fi
+
+echo
+echo "!! Der Dienst läuft nach dem Update nicht richtig." >&2
+echo "   Log:    journalctl -u netmover -n 50" >&2
+echo "   Zurück auf $CURRENT (Datenbank aus der Sicherung, weil sie migriert sein kann):" >&2
+echo "     systemctl stop netmover" >&2
+echo "     cp $BACKUP/netmover.db $NETMOVER_DATA_DIR/netmover.db" >&2
+echo "     rm -f $NETMOVER_DATA_DIR/netmover.db-wal $NETMOVER_DATA_DIR/netmover.db-shm" >&2
+echo "     netmover-update $CURRENT" >&2
+exit 1
@@ -33,6 +33,7 @@ dev = [
    "ruff>=0.6",
    "mypy>=1.11",
    "types-paramiko",
+    "shellcheck-py",
 ]

 [project.scripts]
@@ -1,3 +1,3 @@
 """NetMover – NFS/SMB-Mounts verwalten und Dateien zeitgesteuert verschieben."""

-__version__ = "0.1.0"
+__version__ = "0.2.1"
@@ -84,6 +84,9 @@ def _int(
 # -- Anbindungen ------------------------------------------------------------------------


+NEW_KEY = "new"
+
+
@dataclass
 class MountInput:
    name: str = ""
@@ -95,6 +98,9 @@ class MountInput:
    password: str = ""  # leer = unverändert
    domain: str = ""
    auth: CredentialKind = CredentialKind.PASSWORD  # nur sftp: Schlüssel oder Passwort
+    # nur sftp + Schlüssel: "new" = eigener Schlüssel nur für diese Anbindung,
+    # sonst ID eines Schlüssels aus der Schlüsselverwaltung
+    key_id: str = NEW_KEY
    uid: int | None = None
    gid: int | None = None
    file_mode: str | None = None
@@ -126,9 +132,10 @@ def mount_input_from_model(m: Mount) -> MountInput:
        server=m.server,
        share=m.share,
        port=m.port,
-        username=c.username if c else "",
+        username=m.username or (c.username if c else ""),
        domain=(c.domain or "") if c else "",
        auth=c.kind if c else CredentialKind.PASSWORD,
+        key_id=str(c.id) if c is not None and c.managed else NEW_KEY,
        uid=m.uid,
        gid=m.gid,
        file_mode=m.file_mode,
@@ -151,7 +158,11 @@ def parse_mount_form(form: Mapping[str, str]) -> tuple[MountInput, Errors]:
        extra_options=(form.get("extra_options") or "").strip(),
        auto_mount=_bool(form, "auto_mount"),
        enabled=_bool(form, "enabled"),
+        key_id=(form.get("key_id") or NEW_KEY).strip(),
    )
+    if data.key_id != NEW_KEY and not data.key_id.isdigit():
+        errors["key_id"] = "Ungültige Schlüsselauswahl."
+        data.key_id = NEW_KEY
    try:
        data.type = MountType(form.get("type", "cifs"))
    except ValueError:
@@ -203,17 +214,27 @@ def parse_mount_form(form: Mapping[str, str]) -> tuple[MountInput, Errors]:
        errors["username"] = "SFTP braucht einen Benutzernamen."
    if data.type is not MountType.SFTP:
        data.auth = CredentialKind.PASSWORD
+    if data.auth is not CredentialKind.SSH_KEY:
+        data.key_id = NEW_KEY
    return data, errors


 def credential_for_test(
-    data: MountInput, existing: Mount | None, secrets: SecretBox
+    data: MountInput, existing: Mount | None, secrets: SecretBox, s: Session | None = None
 ) -> CredentialData | None:
-    """Zugangsdaten für „Testen“ aus dem Formular – leeres Passwort = gespeichertes."""
+    """Zugangsdaten für „Testen“ aus dem Formular – leeres Passwort = gespeichertes,
+    gewählter Schlüssel aus der Schlüsselverwaltung."""
    if data.type in (MountType.NFS3, MountType.NFS4) or not data.username:
        return None
+    if data.auth is CredentialKind.SSH_KEY and data.key_id != NEW_KEY and s is not None:
+        key = s.get(Credential, int(data.key_id))
+        if key is None or not key.managed:
+            return None
+        return CredentialData(data.auth, data.username, secrets.decrypt(key.secret_enc))
    secret = data.password
    stored = existing.credential if existing is not None else None
+    if stored is not None and stored.managed:
+        stored = None  # eigener Schlüssel gewählt, gespeicherter ist nicht gemeint
    if not secret and stored is not None and stored.kind is data.auth:
        secret = secrets.decrypt(stored.secret_enc)
    if not secret:
@@ -296,20 +317,32 @@ def save_mount(
    if not data.type.is_kernel_mount:
        m.auto_mount = False

-    # Zugangsdaten: jede Anbindung pflegt ihre eigenen.
-    cred = m.credential
+    # Zugangsdaten: entweder ein gespeicherter Schlüssel aus der Schlüsselverwaltung
+    # (geteilt, wird hier nie verändert) oder eigene Zugangsdaten nur dieser Anbindung.
+    current = m.credential
+    own = current if current is not None and not current.managed else None
    needs_cred = data.type is MountType.SFTP or (
        data.type is MountType.CIFS and bool(data.username)
    )
+    use_managed = (
+        data.type is MountType.SFTP
+        and data.auth is CredentialKind.SSH_KEY
+        and data.key_id != NEW_KEY
+    )
    if not needs_cred:
-        if cred is not None:
-            m.credential = None
-            s.flush()
-            if not cred.mounts:
-                s.delete(cred)
+        m.credential = None
+        m.username = None
+    elif use_managed:
+        key = s.get(Credential, int(data.key_id))
+        if key is None or not key.managed or key.kind is not CredentialKind.SSH_KEY:
+            s.rollback()
+            return None, {"key_id": "Schlüssel existiert nicht."}
+        m.credential = key
+        m.username = data.username
    else:
-        kind_changed = cred is not None and cred.kind is not data.auth
-        if cred is None or kind_changed:
+        m.username = None
+        cred = own
+        if cred is None or cred.kind is not data.auth:
            if data.auth is CredentialKind.SSH_KEY:
                private, public = generate_ssh_keypair(f"netmover@{m.slug}")
                secret, pub = private, public
@@ -320,9 +353,8 @@ def save_mount(
                    return None, errors
                secret, pub = data.password, None
            if cred is None:
-                cred = Credential(name=f"mount:{m.slug}")
+                cred = Credential(name=f"mount:{m.slug}", managed=False)
                s.add(cred)
-                m.credential = cred
            cred.kind = data.auth
            cred.secret_enc = secrets.encrypt(secret)
            cred.public_key = pub
@@ -330,6 +362,12 @@ def save_mount(
            cred.secret_enc = secrets.encrypt(data.password)
        cred.username = data.username
        cred.domain = data.domain or None
+        m.credential = cred
+    # Eigene Zugangsdaten, die nicht mehr gebraucht werden, entfernen.
+    if own is not None and m.credential is not own:
+        s.flush()
+        if not own.mounts:
+            s.delete(own)
    try:
        s.flush()
    except IntegrityError:
@@ -353,7 +391,8 @@ def delete_mount(s: Session, mounts: MountManager, mount_id: int) -> None:
    cred = m.credential
    s.delete(m)
    s.flush()
-    if cred is not None and not cred.mounts:
+    # Eigene Zugangsdaten gehen mit; Schlüssel aus der Schlüsselverwaltung bleiben.
+    if cred is not None and not cred.managed and not cred.mounts:
        s.delete(cred)


@@ -58,7 +58,9 @@ class NetMover:
        )
        self.runner = RuleRunner(self.session_factory, self.mounts)
        self.runs = RunService(self.session_factory, self.runner, self.notifier)
-        self.scheduler = RuleScheduler(self.session_factory, self.runs)
+        self.scheduler = RuleScheduler(
+            self.session_factory, self.runs, retry_mounts=self.mounts.retry_pending
+        )
        self.started_at: datetime = utcnow()
        self.restore_results: list[RestoreResult] = []

@@ -33,6 +33,35 @@ def make_engine(url: str) -> Engine:
    return engine


+def make_migration_engine(url: str) -> Engine:
+    """Verbindung nur für Migrationen.
+
+    * Fremdschlüssel AUS: SQLite baut Tabellen bei Änderungen neu auf (Alembic
+      „batch mode“) und löscht dabei die alte Tabelle. Mit eingeschalteter Prüfung
+      scheitert das, sobald andere Tabellen darauf verweisen (Praxisbefund beim
+      Update auf 0.2.0). Die Integrität prüft ``PRAGMA foreign_key_check`` danach.
+    * Echte Transaktion: pysqlite eigene Transaktionssteuerung abnehmen und selbst
+      ``BEGIN`` senden. So wird eine abgebrochene Migration vollständig
+      zurückgerollt, statt einen halben Zustand zu hinterlassen.
+    """
+    engine = create_engine(url, connect_args={"check_same_thread": False})
+    if url.startswith("sqlite"):
+
+        def on_connect(dbapi_conn: Any, _record: Any) -> None:
+            dbapi_conn.isolation_level = None
+            cur = dbapi_conn.cursor()
+            cur.execute("PRAGMA foreign_keys=OFF")  # außerhalb einer Transaktion setzen
+            cur.execute("PRAGMA busy_timeout=5000")
+            cur.close()
+
+        def on_begin(conn: Any) -> None:
+            conn.exec_driver_sql("BEGIN IMMEDIATE")
+
+        event.listen(engine, "connect", on_connect)
+        event.listen(engine, "begin", on_begin)
+    return engine
+
+
 def make_session_factory(engine: Engine) -> sessionmaker[Session]:
    return sessionmaker(bind=engine, expire_on_commit=False)

@@ -0,0 +1,197 @@
+"""Schlüsselverwaltung: gespeicherte SSH-Schlüssel für SFTP-Anbindungen.
+
+* Erzeugen (Ed25519) oder Importieren (Ed25519, ECDSA, RSA ≥ 2048 Bit; OpenSSH-
+  oder PEM-Format, optional mit Passphrase). Eine Passphrase wird beim Import
+  einmal benutzt; gespeichert wird der Schlüssel ohne Passphrase, aber mit
+  Fernet verschlüsselt – wie alle Geheimnisse.
+* Der private Schlüssel verlässt NetMover nie: Die Oberfläche zeigt nur den
+  öffentlichen Schlüssel und den Fingerabdruck.
+* Ein Schlüssel kann von mehreren Anbindungen genutzt werden; den Benutzernamen
+  legt jede Anbindung selbst fest. Löschen geht nur, solange ihn keine nutzt.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+from dataclasses import dataclass, field
+from datetime import datetime
+
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import ec, ed25519, rsa
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from netmover.admin import AdminError
+from netmover.crypto import SecretBox
+from netmover.models import Credential, CredentialKind, Mount
+
+MAX_KEY_BYTES = 16 * 1024
+MIN_RSA_BITS = 2048
+SFTP_ONLY_PREFIX = 'restrict,command="/usr/lib/openssh/sftp-server" '
+
+
+@dataclass
+class KeyInfo:
+    id: int
+    name: str
+    key_type: str
+    fingerprint: str
+    public_key: str
+    created_at: datetime
+    used_by: list[str] = field(default_factory=list)
+
+    @property
+    def authorized_keys_line(self) -> str:
+        """Zeile für ~/.ssh/authorized_keys, auf SFTP beschränkt."""
+        return SFTP_ONLY_PREFIX + self.public_key
+
+
+def fingerprint(public_key: str) -> str:
+    """SHA256-Fingerabdruck wie ``ssh-keygen -lf``."""
+    blob = base64.b64decode(public_key.split()[1])
+    return "SHA256:" + base64.b64encode(hashlib.sha256(blob).digest()).decode().rstrip("=")
+
+
+def _validate_name(s: Session, name: str, exclude_id: int | None = None) -> str:
+    name = name.strip()
+    if not name:
+        raise AdminError("Name fehlt.")
+    if len(name) > 100:
+        raise AdminError("Name höchstens 100 Zeichen.")
+    if name.startswith("mount:"):
+        raise AdminError("Namen mit „mount:“ sind für NetMover reserviert.")
+    dup = s.scalar(select(Credential.id).where(Credential.name == name))
+    if dup is not None and dup != exclude_id:
+        raise AdminError(f"Ein Schlüssel „{name}“ existiert bereits.")
+    return name
+
+
+def _comment(name: str) -> str:
+    return "netmover:" + "".join(c if c.isalnum() or c in "-_." else "-" for c in name)
+
+
+PrivateKey = ed25519.Ed25519PrivateKey | ec.EllipticCurvePrivateKey | rsa.RSAPrivateKey
+
+
+def _store(s: Session, secrets: SecretBox, name: str, key: PrivateKey) -> Credential:
+    private = key.private_bytes(
+        serialization.Encoding.PEM,
+        serialization.PrivateFormat.OpenSSH,
+        serialization.NoEncryption(),
+    ).decode()
+    public = (
+        key.public_key()
+        .public_bytes(serialization.Encoding.OpenSSH, serialization.PublicFormat.OpenSSH)
+        .decode()
+    )
+    cred = Credential(
+        name=name,
+        kind=CredentialKind.SSH_KEY,
+        username="",
+        secret_enc=secrets.encrypt(private),
+        public_key=f"{public} {_comment(name)}",
+        managed=True,
+    )
+    s.add(cred)
+    s.flush()
+    return cred
+
+
+def generate_key(s: Session, secrets: SecretBox, name: str) -> Credential:
+    return _store(s, secrets, _validate_name(s, name), ed25519.Ed25519PrivateKey.generate())
+
+
+def import_key(
+    s: Session, secrets: SecretBox, name: str, private_key: str, passphrase: str = ""
+) -> Credential:
+    name = _validate_name(s, name)
+    data = private_key.strip().encode()
+    if not data:
+        raise AdminError("Privaten Schlüssel einfügen.")
+    if len(data) > MAX_KEY_BYTES:
+        raise AdminError("Schlüssel ist zu groß.")
+    if b"PUBLIC KEY" in data or data.startswith((b"ssh-", b"ecdsa-")):
+        raise AdminError("Das ist ein öffentlicher Schlüssel – benötigt wird der private.")
+    password = passphrase.encode() if passphrase else None
+    loaders = (
+        [serialization.load_ssh_private_key]
+        if b"OPENSSH PRIVATE KEY" in data
+        else [serialization.load_pem_private_key]
+    )
+    try:
+        key = loaders[0](data, password)
+    except TypeError:
+        raise AdminError(
+            "Der Schlüssel ist mit einer Passphrase geschützt – bitte Passphrase angeben."
+            if password is None
+            else "Der Schlüssel hat keine Passphrase – Feld bitte leer lassen."
+        ) from None
+    except ValueError as exc:
+        msg = str(exc).lower()
+        if password is not None or "password" in msg or "decrypt" in msg:
+            # Bei OpenSSH-Schlüsseln meldet cryptography eine falsche Passphrase
+            # als „Corrupt data“ – beides lässt sich nicht unterscheiden.
+            raise AdminError("Passphrase falsch (oder Schlüssel beschädigt).") from None
+        raise AdminError(
+            "Kein lesbarer privater Schlüssel (erwartet OpenSSH- oder PEM-Format)."
+        ) from None
+    except Exception:  # unbekannte Formate/Algorithmen sauber melden
+        raise AdminError("Schlüsselformat wird nicht unterstützt.") from None
+    if not isinstance(
+        key, ed25519.Ed25519PrivateKey | ec.EllipticCurvePrivateKey | rsa.RSAPrivateKey
+    ):
+        raise AdminError("Unterstützt werden Ed25519, ECDSA und RSA.")
+    if isinstance(key, rsa.RSAPrivateKey) and key.key_size < MIN_RSA_BITS:
+        raise AdminError(f"RSA-Schlüssel mit {key.key_size} Bit ist zu schwach (mind. 2048).")
+    return _store(s, secrets, name, key)
+
+
+def _users(s: Session, key_id: int) -> list[str]:
+    # Direkt abfragen statt key.mounts: die Beziehung ist nach dem Löschen von
+    # Anbindungen in derselben Session veraltet (passive_deletes).
+    return sorted(s.scalars(select(Mount.name).where(Mount.cred_id == key_id)))
+
+
+def list_keys(s: Session) -> list[KeyInfo]:
+    keys = s.scalars(
+        select(Credential).where(Credential.managed.is_(True)).order_by(Credential.name)
+    ).all()
+    result = []
+    for k in keys:
+        pub = k.public_key or ""
+        result.append(
+            KeyInfo(
+                id=k.id,
+                name=k.name,
+                key_type=pub.split()[0] if pub else "?",
+                fingerprint=fingerprint(pub) if pub else "?",
+                public_key=pub,
+                created_at=k.created_at,
+                used_by=_users(s, k.id),
+            )
+        )
+    return result
+
+
+def managed_key(s: Session, key_id: int) -> Credential:
+    key = s.get(Credential, key_id)
+    if key is None or not key.managed or key.kind is not CredentialKind.SSH_KEY:
+        raise AdminError("Schlüssel existiert nicht.")
+    return key
+
+
+def rename_key(s: Session, key_id: int, name: str) -> None:
+    key = managed_key(s, key_id)
+    key.name = _validate_name(s, name, exclude_id=key_id)
+
+
+def delete_key(s: Session, key_id: int) -> str:
+    key = managed_key(s, key_id)
+    users = _users(s, key_id)
+    if users:
+        raise AdminError(f"Schlüssel „{key.name}“ wird noch benutzt von: {', '.join(users)}")
+    name = key.name
+    s.delete(key)
+    s.flush()
+    return name
@@ -7,7 +7,7 @@ from logging.config import fileConfig
 from alembic import context

 from netmover.config import get_settings
-from netmover.db import make_engine
+from netmover.db import make_migration_engine
 from netmover.models import Base

 config = context.config
@@ -33,16 +33,27 @@ def run_migrations_offline() -> None:


 def run_migrations_online() -> None:
-    engine = make_engine(_url())
+    url = _url()
+    engine = make_migration_engine(url)
    with engine.connect() as connection:
        context.configure(
            connection=connection,
            target_metadata=target_metadata,
            render_as_batch=True,
            compare_type=True,
+            # alles oder nichts: auch SQLite kann DDL in einer Transaktion
+            transactional_ddl=True,
        )
        with context.begin_transaction():
            context.run_migrations()
+            if url.startswith("sqlite"):
+                # Fremdschlüssel waren während der Migration aus – vor dem Commit prüfen.
+                bad = connection.exec_driver_sql("PRAGMA foreign_key_check").fetchall()
+                if bad:
+                    raise RuntimeError(
+                        f"Migration verletzt Fremdschlüssel ({len(bad)} Zeilen), "
+                        f"zurückgerollt: {bad[:5]}"
+                    )
    engine.dispose()


@@ -0,0 +1,34 @@
+"""key management
+
+Revision ID: 0002
+Revises: 0001
+Create Date: 2026-10-10
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "0002"
+down_revision: str | None = "0001"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    with op.batch_alter_table("credentials", schema=None) as batch_op:
+        batch_op.add_column(
+            sa.Column("managed", sa.Boolean(), server_default=sa.text("0"), nullable=False)
+        )
+
+    with op.batch_alter_table("mounts", schema=None) as batch_op:
+        batch_op.add_column(sa.Column("username", sa.String(length=255), nullable=True))
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("mounts", schema=None) as batch_op:
+        batch_op.drop_column("username")
+
+    with op.batch_alter_table("credentials", schema=None) as batch_op:
+        batch_op.drop_column("managed")
@@ -7,6 +7,9 @@ Abweichungen bzw. Ergänzungen gegenüber dem Mindestumfang aus der Spezifikatio
  (beim ersten Test festgehaltener Hostschlüssel, danach verbindlich).
 * ``credentials.kind`` (``password`` | ``ssh_key``) und ``credentials.public_key``.
 * ``credentials.domain`` – Windows-/AD-Freigaben brauchen oft eine Domäne.
+* ``credentials.managed`` + ``mounts.username`` (Migration 0002) –
+  Schlüsselverwaltung: gespeicherte SSH-Schlüssel, die mehrere Anbindungen mit
+  jeweils eigenem Benutzernamen nutzen.
 * ``mounts.state_since`` – für „hängt seit …“ / „gestört seit …“ auf der Statusseite.
 * ``mounts.write_ok`` / ``mounts.root_squash`` / ``mounts.last_test_*`` – Ergebnis
  des letzten Mount-Tests; ``root_squash`` entscheidet, ob ``chown`` auf NFS-Zielen
@@ -38,6 +41,7 @@ from sqlalchemy import (
    TypeDecorator,
    UniqueConstraint,
 )
+from sqlalchemy import false as sa_false
 from sqlalchemy.engine import Dialect
 from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship

@@ -166,6 +170,9 @@ class Credential(Base):
    domain: Mapped[str | None] = mapped_column(String(255))
    secret_enc: Mapped[str] = mapped_column(Text)  # Passwort bzw. privater Schlüssel (Fernet)
    public_key: Mapped[str | None] = mapped_column(Text)  # nur ssh_key, OpenSSH-Format
+    # True: in der Schlüsselverwaltung gepflegt, von mehreren Anbindungen nutzbar.
+    # False: gehört genau einer Anbindung und wird mit ihr gelöscht.
+    managed: Mapped[bool] = mapped_column(Boolean, default=False, server_default=sa_false())
    created_at: Mapped[datetime] = mapped_column(UTCDateTime, default=utcnow)

    # passive_deletes="all": das ORM soll cred_id nicht still auf NULL setzen,
@@ -183,6 +190,9 @@ class Mount(Base):
    server: Mapped[str] = mapped_column(String(255))
    share: Mapped[str] = mapped_column(String(1024))
    port: Mapped[int | None] = mapped_column(Integer)  # nur sftp
+    # Benutzer für die Anmeldung; überschreibt credentials.username. Nötig, weil ein
+    # gespeicherter SSH-Schlüssel für verschiedene Server/Benutzer gelten kann.
+    username: Mapped[str | None] = mapped_column(String(255))
    host_key: Mapped[str | None] = mapped_column(Text)  # nur sftp, "<typ> <base64>"
    mountpoint: Mapped[str | None] = mapped_column(String(1024), unique=True)  # NULL bei sftp
    cred_id: Mapped[int | None] = mapped_column(ForeignKey("credentials.id", ondelete="RESTRICT"))
@@ -8,7 +8,9 @@ Optionszeile – die stünde sonst in der Prozessliste.

 from __future__ import annotations

+import contextlib
 import os
+import signal
 import subprocess
 import uuid
 from collections.abc import Callable, Sequence
@@ -24,6 +26,28 @@ log = get_logger(__name__)

 Runner = Callable[..., "subprocess.CompletedProcess[str]"]

+
+def run_process_group(argv: list[str], **kwargs: Any) -> subprocess.CompletedProcess[str]:
+    """Wie ``subprocess.run``, aber in eigener Prozessgruppe: Bei Zeitüberschreitung
+    wird die ganze Gruppe beendet. ``mount`` startet Hilfsprogramme wie
+    ``mount.nfs``; würde nur ``mount`` beendet, liefe ``mount.nfs`` weiter und
+    hängte womöglich Minuten später doch noch ein (auf der Test-VM beobachtet)."""
+    timeout = kwargs.pop("timeout", None)
+    kwargs.pop("check", None)
+    capture = kwargs.pop("capture_output", False)
+    if capture:
+        kwargs["stdout"] = kwargs["stderr"] = subprocess.PIPE
+    with subprocess.Popen(argv, start_new_session=True, **kwargs) as proc:
+        try:
+            out, err = proc.communicate(timeout=timeout)
+        except subprocess.TimeoutExpired:
+            with contextlib.suppress(ProcessLookupError):
+                os.killpg(proc.pid, signal.SIGKILL)
+            proc.communicate()
+            raise
+    return subprocess.CompletedProcess(argv, proc.returncode, out, err)
+
+
 _ENV = {"LC_ALL": "C", "PATH": "/usr/sbin:/usr/bin:/sbin:/bin"}


@@ -34,6 +58,13 @@ def explain_mount_error(fstype: str, message: str) -> str:
    if "helper program" in low or "unknown filesystem type" in low:
        pkg = "cifs-utils" if fstype == "cifs" else "nfs-common"
        hint = f"Das Paket „{pkg}“ fehlt: apt install {pkg}"
+    elif fstype == "cifs" and ("error(95)" in low or "operation not supported" in low):
+        hint = (
+            "Server und Client finden keine gemeinsame SMB-Version. Am besten am NAS "
+            "SMB2/SMB3 erlauben (Synology: Systemsteuerung → Dateidienste → SMB → "
+            "Erweiterte Einstellungen → Maximales SMB-Protokoll: SMB3). Alternativ "
+            "Zusatzoption vers=2.0 – vers=1.0 nur im Notfall, SMB1 ist unsicher."
+        )
    elif "permission denied" in low and fstype == "cifs":
        hint = "Benutzername/Passwort falsch oder der Benutzer hat keine Rechte auf die Freigabe."
    elif "permission denied" in low or "access denied by server" in low:
@@ -60,7 +91,7 @@ class LinuxMountBackend(MountBackend):
        self,
        run_dir: Path,
        mountinfo_path: Path = MOUNTINFO,
-        runner: Runner = subprocess.run,
+        runner: Runner = run_process_group,
    ) -> None:
        self.run_dir = run_dir
        self.mountinfo_path = mountinfo_path
@@ -15,7 +15,9 @@ Fallstricke:

 from __future__ import annotations

+import contextlib
 import errno
+import math
 import os
 import threading
 import time
@@ -104,6 +106,13 @@ class RestoreResult:
    message: str


+def _redact_output(message: str, secrets: Sequence[str]) -> str:
+    """Schwärzt nur die Ausgabe von ``mount``, nicht den angehängten Hinweistext
+    (sonst würde z. B. das Passwort „falsch“ auch im Hinweis geschwärzt)."""
+    output, sep, hint = message.partition("\n→ ")
+    return redact(output, secrets) + sep + hint
+
+
 def build_spec(cfg: MountConfig, mountpoint: Path, cred: CredentialData | None) -> MountSpec:
    """Baut den ``mount``-Aufruf. Validiert erneut (Verteidigung in der Tiefe) –
    auch Daten aus der Datenbank laufen hier noch einmal durch die Prüfung."""
@@ -166,6 +175,8 @@ class MountManager:
        sleep: Callable[[float], None] = time.sleep,
        euid: Callable[[], int] = os.geteuid,
        notifier: Notifier | None = None,
+        retry_interval: float = 60,
+        clock: Callable[[], float] = time.monotonic,
    ) -> None:
        self.session_factory = session_factory
        self.backend = backend
@@ -177,6 +188,12 @@ class MountManager:
        self._sleep = sleep
        self._euid = euid
        self._notifier = notifier
+        self.retry_interval = retry_interval
+        self._clock = clock
+        # Mounts, die NetMover nach gescheiterter Wiederherstellung selbst ausgehängt
+        # hat: nächster erlaubter Versuch (monotone Zeit). Nur diese werden
+        # automatisch neu eingehängt – von außen ausgehängte nie (Fallstrick 2).
+        self._retry_at: dict[int, float] = {}
        self._locks: dict[int, threading.RLock] = {}
        self._locks_guard = threading.Lock()

@@ -211,7 +228,7 @@ class MountManager:
            if m.credential is not None:
                c = m.credential
                cred = CredentialData(
-                    c.kind, c.username, self.secrets.decrypt(c.secret_enc), c.domain
+                    c.kind, m.username or c.username, self.secrets.decrypt(c.secret_enc), c.domain
                )
            s.expunge(m)
            return m, cred
@@ -267,6 +284,7 @@ class MountManager:

    def mount(self, mount_id: int) -> None:
        with self._lock(mount_id):
+            self._retry_at.pop(mount_id, None)
            m, cred = self._load(mount_id)
            if not m.type.is_kernel_mount:
                raise MountError("SFTP-Anbindungen werden nicht eingehängt, nur getestet")
@@ -292,6 +310,7 @@ class MountManager:

    def unmount(self, mount_id: int) -> None:
        with self._lock(mount_id):
+            self._retry_at.pop(mount_id, None)
            m, _ = self._load(mount_id)
            if not m.type.is_kernel_mount:
                self._set_state(mount_id, MountState.UNMOUNTED)
@@ -325,6 +344,8 @@ class MountManager:
                self.mount(mount_id)
                results.append(RestoreResult(name, True, "eingehängt"))
            except (MountError, ValidationError, LookupError) as exc:
+                # z. B. Stromausfall: die VM bootet schneller als das NAS
+                self._retry_at[mount_id] = self._clock() + self.retry_interval
                results.append(RestoreResult(name, False, str(exc)))
                self._notify("mount.restore_failed", name, str(exc))
        for r in results:
@@ -391,7 +412,7 @@ class MountManager:
                self.backend.mount(build_spec(cfg, temp, cred), timeout=self.mount_timeout)
            except (MountError, ValidationError) as exc:
                self._remove_mountpoint(temp)
-                report.step("mount", False, redact(str(exc), secrets))
+                report.step("mount", False, _redact_output(str(exc), secrets))
                report.step("read", None)
                report.step("write", None)
                return report
@@ -486,6 +507,11 @@ class MountManager:
            if cfg.type is MountType.SFTP and m.host_key is None and report.can_read:
                m.host_key = report.host_key
                event(log, "sftp.host_key_pinned", mount=m.name, fp=report.host_key_fingerprint)
+            # SFTP hat keinen Mount-Zustand – ein erfolgreicher Test heißt „erreichbar“.
+            if cfg.type is MountType.SFTP and report.ok and m.state is not MountState.MOUNTED:
+                m.state = MountState.MOUNTED
+                m.state_since = utcnow()
+                m.last_error = None

    # -- Lebenszeichen und Wiederherstellung --------------------------------------

@@ -501,6 +527,9 @@ class MountManager:
                return None
            mp = self.mountpoint_for(m.slug)
            if not self.backend.is_mounted(mp):
+                if mount_id in self._retry_at:
+                    self._retry_mount(mount_id, m, cred, mp)
+                    return mp
                msg = f"„{m.name}“ ist nicht eingehängt – Lauf abgebrochen, nichts angefasst."
                self._set_state(mount_id, MountState.ERROR, msg)
                raise MountUnavailable(msg)
@@ -568,10 +597,74 @@ class MountManager:
            f"„{m.name}“ gestört ({reason}); Neu-Einhängen nach "
            f"{len(self.recover_backoff)} Versuchen gescheitert: {last}"
        )
+        if m.auto_mount:
+            self._retry_at[mount_id] = self._clock() + self.retry_interval
+            msg += f"\n→ Neuer Versuch automatisch alle {self.retry_interval:g} s."
        self._set_state(mount_id, MountState.ERROR, msg)
        self._notify("mount.error", m.name, msg)
        raise MountUnavailable(msg)

+    def retry_pending(self) -> list[str]:
+        """Fällige Neuversuche ausführen (Scheduler-Job, jede Minute) – auch für
+        Anbindungen, die gerade keine Regel benutzt. Liefert die zurückgeholten Namen."""
+        recovered: list[str] = []
+        for mount_id in list(self._retry_at):
+            if self._retry_at.get(mount_id, float("inf")) > self._clock():
+                continue
+            with self._lock(mount_id):
+                if mount_id not in self._retry_at:
+                    continue
+                try:
+                    m, cred = self._load(mount_id)
+                except LookupError:
+                    self._retry_at.pop(mount_id, None)
+                    continue
+                if not (m.enabled and m.auto_mount and m.type.is_kernel_mount):
+                    self._retry_at.pop(mount_id, None)
+                    continue
+                mp = self.mountpoint_for(m.slug)
+                if self.backend.is_mounted(mp):
+                    self._retry_at.pop(mount_id, None)
+                    continue
+                try:
+                    self._retry_mount(mount_id, m, cred, mp)
+                    recovered.append(m.name)
+                except MountUnavailable:
+                    pass
+        return recovered
+
+    def _retry_mount(self, mount_id: int, m: Mount, cred: CredentialData | None, mp: Path) -> None:
+        """Ein Versuch, einen von NetMover selbst ausgehängten Mount zurückzuholen –
+        höchstens einmal pro ``retry_interval``, damit kein Lauf alle 10 s hängt."""
+        wait = self._retry_at[mount_id] - self._clock()
+        if wait > 0:
+            raise MountUnavailable(
+                f"„{m.name}“ nicht verfügbar – nächster Versuch, neu einzuhängen, "
+                f"in {math.ceil(wait)} s. Lauf abgebrochen, nichts angefasst."
+            )
+        try:
+            self._prepare_mountpoint(mp)
+            self.backend.mount(
+                build_spec(MountConfig.from_model(m), mp, cred), timeout=self.mount_timeout
+            )
+            self._probe(m.name, mp)
+        except (MountError, OSError, OperationTimeout, ValidationError) as exc:
+            if self.backend.is_mounted(mp):
+                with contextlib.suppress(MountError):
+                    self.backend.unmount(mp, lazy=True, timeout=self.mount_timeout)
+            self._retry_at[mount_id] = self._clock() + self.retry_interval
+            msg = (
+                f"„{m.name}“ weiterhin nicht verfügbar: {exc}\n"
+                f"→ Neuer Versuch in {self.retry_interval:g} s."
+            )
+            self._set_state(mount_id, MountState.ERROR, msg)
+            event(log, "mount.retry_failed", level=30, mount=m.name, error=str(exc))
+            raise MountUnavailable(msg) from None
+        del self._retry_at[mount_id]
+        self._set_state(mount_id, MountState.MOUNTED, mounted=True)
+        event(log, "mount.recovered", mount=m.name, attempt="retry")
+        self._notify("mount.recovered", m.name, f"„{m.name}“ ist wieder eingehängt.")
+
    def usage(self, mount_id: int, timeout: float | None = None) -> tuple[int, int] | None:
        """(gesamt, frei) in Bytes – nur bei eingehängten Kernel-Mounts."""
        m, _ = self._load(mount_id)
@@ -13,6 +13,7 @@ Reihenfolge pro Lauf:

 from __future__ import annotations

+import dataclasses
 import errno
 import os
 import stat
@@ -39,7 +40,7 @@ from netmover.mover.destinations import (
 )
 from netmover.mover.ledger import FailureInfo, Ledger
 from netmover.mover.naming import collision_candidates
-from netmover.mover.scan import Candidate, FileState, Matcher, current_state, scan
+from netmover.mover.scan import BUSY, Candidate, FileState, Matcher, current_state, scan
 from netmover.timeouts import Cancelled, CancelToken

 log = get_logger(__name__)
@@ -222,26 +223,32 @@ class Engine:
            else:
                pending.append(c)

-        # Stabilität (Fallstrick 1): zweite Messung nach dem Stabilitätsfenster.
+        # Stabilität (Fallstrick 1): zwei frische Messungen (öffnen + fstat, nicht
+        # der Verzeichnis-Cache) im Abstand des Stabilitätsfensters.
+        first: dict[str, FileState | None] = {c.relpath: current_state(c.path) for c in pending}
        if pending and rule.stability_seconds > 0:
            self._sleep(rule.stability_seconds)
            token.check()
        stable: list[Candidate] = []
        for c in pending:
-            st = current_state(c.path)
-            if st is None:
+            before, st = first[c.relpath], current_state(c.path)
+            if before is None or st is None:
                continue  # inzwischen verschwunden – nichts zu tun
-            if st != c.state:
+            if st != before or st == BUSY:
                result.add(
                    ItemResult(
                        c.relpath,
                        ItemStatus.SKIPPED,
-                        size=st.size,
-                        message="wird noch geschrieben (Größe/Zeit geändert)",
+                        size=max(st.size, 0),
+                        message="wird noch geschrieben (Größe/Zeit geändert)"
+                        if st != BUSY
+                        else "Datei ist gerade in Benutzung",
                    )
                )
                continue
-            stable.append(c)
+            # ab hier gilt der frisch gemessene Zustand (für Prüfung vor dem Umbenennen
+            # und für die Kopier-Buchführung)
+            stable.append(dataclasses.replace(c, state=st))

        failures = self.ledger.failures(rule.id)
        for c in stable:
@@ -10,6 +10,7 @@

 from __future__ import annotations

+import errno
 import fnmatch
 import os
 import re
@@ -100,11 +101,31 @@ def scan(
    yield from walk(root, "")


+# Datei ist geöffnet, aber gerade nicht lesbar (z. B. exklusiv vom Schreiber
+# gesperrt): gilt als „noch nicht fertig“ – gleicht nie einem echten Zustand.
+BUSY = FileState(-1, -1)
+
+
 def current_state(path: Path) -> FileState | None:
+    """Aktuelle Größe und mtime – **frisch vom Server**.
+
+    ``stat()`` beantworten CIFS- und NFS-Clients aus ihrem Attribut-Cache; im
+    Praxistest lieferte CIFS so sekundenlang eine veraltete Größe, während die
+    Datei noch wuchs. Erst ``open()`` erzwingt frische Attribute (NFS:
+    Close-to-open-Konsistenz, SMB: Antwort auf CREATE). Darum öffnen + ``fstat``.
+    """
    try:
-        st = os.stat(path, follow_symlinks=False)
+        fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK)
    except FileNotFoundError:
        return None
+    except OSError as exc:
+        if exc.errno in (errno.ELOOP, errno.ENOTDIR):
+            return None  # Symlink oder kein Pfad mehr
+        return BUSY
+    try:
+        st = os.fstat(fd)
+    finally:
+        os.close(fd)
    if not stat.S_ISREG(st.st_mode):
        return None
    return FileState(st.st_size, st.st_mtime_ns)
@@ -125,4 +125,9 @@ class Notifier:

    def mount_event(self, kind: str, mount: str, message: str) -> None:
        """Passt zur ``Notifier``-Signatur des :class:`MountManager`."""
-        self.send(Notification(kind, f"NetMover: Anbindung „{mount}“ gestört", message))
+        title = (
+            f"NetMover: Anbindung „{mount}“ wieder verfügbar"
+            if kind == "mount.recovered"
+            else f"NetMover: Anbindung „{mount}“ gestört"
+        )
+        self.send(Notification(kind, title, message))
@@ -13,6 +13,7 @@ from __future__ import annotations

 import asyncio
 import random
+from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor
 from datetime import UTC, datetime, timedelta

@@ -31,6 +32,7 @@ log = get_logger(__name__)
 MAX_START_OFFSET = 10.0
 HEARTBEAT_SECONDS = 30
 CLEANUP_SECONDS = 3600
+RETRY_SECONDS = 60


 def _job_id(rule_id: int) -> str:
@@ -43,11 +45,13 @@ class RuleScheduler:
        session_factory: sessionmaker[Session],
        service: RunService,
        *,
+        retry_mounts: Callable[[], object] | None = None,
        rng: random.Random | None = None,
        workers: int = 8,
    ) -> None:
        self.session_factory = session_factory
        self.service = service
+        self._retry_mounts = retry_mounts
        self._rng = rng or random.Random()  # noqa: S311 – nur Startversatz
        self._executor = ThreadPoolExecutor(max_workers=workers, thread_name_prefix="nm-run")
        self.scheduler = AsyncIOScheduler(
@@ -70,6 +74,10 @@ class RuleScheduler:
            IntervalTrigger(seconds=CLEANUP_SECONDS, start_date=utcnow() + timedelta(minutes=1)),
            id="cleanup",
        )
+        if self._retry_mounts is not None:
+            self.scheduler.add_job(
+                self._retry, IntervalTrigger(seconds=RETRY_SECONDS), id="mount-retry"
+            )
        self.sync()
        event(log, "scheduler.started", rules=len(self._intervals))

@@ -141,6 +149,11 @@ class RuleScheduler:
            self._executor, self.service.execute, rule_id, RunTrigger.MANUAL, dry_run
        )

+    async def _retry(self) -> None:
+        if self._retry_mounts is not None:
+            loop = asyncio.get_running_loop()
+            await loop.run_in_executor(self._executor, self._retry_mounts)
+
    async def _cleanup(self) -> None:
        loop = asyncio.get_running_loop()
        await loop.run_in_executor(self._executor, cleanup, self.session_factory)
@@ -45,6 +45,7 @@ from netmover.admin import (
 from netmover.app_state import NetMover
 from netmover.config import Settings, get_settings
 from netmover.db import session_scope
+from netmover.keys import delete_key, generate_key, import_key, list_keys, rename_key
 from netmover.logging_setup import event, get_logger
 from netmover.models import (
    CollisionPolicy,
@@ -392,10 +393,21 @@ async def mounts_page(request: Request) -> Response:
        pubkeys = {
            m.id: m.credential.public_key
            for m in mounts
-            if m.credential is not None and m.credential.public_key
+            if m.credential is not None and m.credential.public_key and not m.credential.managed
+        }
+        key_names = {
+            m.id: m.credential.name
+            for m in mounts
+            if m.credential is not None and m.credential.managed
        }
        return render(
-            request, "mounts.html", active="mounts", mounts=mounts, reports=reports, pubkeys=pubkeys
+            request,
+            "mounts.html",
+            active="mounts",
+            mounts=mounts,
+            reports=reports,
+            pubkeys=pubkeys,
+            key_names=key_names,
        )


@@ -409,6 +421,15 @@ def _report_data(raw: str | None) -> dict[str, Any]:
    return data


+def _key_options(request: Request) -> list[tuple[str, str]]:
+    with nm(request).session_factory() as s:
+        keys = list_keys(s)
+    return [("new", "neuer Schlüssel nur für diese Anbindung")] + [
+        (str(k.id), f"{k.name} ({k.key_type.removeprefix('ssh-')}, {k.fingerprint[7:19]}…)")
+        for k in keys
+    ]
+
+
 def _mount_form(
    request: Request,
    data: MountInput,
@@ -416,7 +437,11 @@ def _mount_form(
    mount: Mount | None = None,
    status_code: int = 200,
 ) -> Response:
-    pub = mount.credential.public_key if mount is not None and mount.credential else None
+    pub = (
+        mount.credential.public_key
+        if mount is not None and mount.credential and not mount.credential.managed
+        else None
+    )
    return render(
        request,
        "mount_form.html",
@@ -426,7 +451,10 @@ def _mount_form(
        errors=errors,
        mount=mount,
        public_key=pub,
-        has_secret=bool(mount is not None and mount.credential is not None),
+        has_secret=bool(
+            mount is not None and mount.credential is not None and not mount.credential.managed
+        ),
+        key_options=_key_options(request),
    )


@@ -487,7 +515,7 @@ async def mount_test_form(request: Request) -> Response:
    existing_id = int(form["mount_id"]) if form.get("mount_id", "").isdigit() else None
    with state.session_factory() as s:
        existing = s.get(Mount, existing_id) if existing_id else None
-        cred = credential_for_test(data, existing, state.secrets)
+        cred = credential_for_test(data, existing, state.secrets, s)
    cfg = data.config()
    if data.type is MountType.SFTP and existing is not None:
        cfg = dataclasses.replace(cfg, host_key=existing.host_key)
@@ -503,7 +531,7 @@ async def mount_test(request: Request, mount_id: int) -> Response:
        if m is None:
            return HTMLResponse("Anbindung existiert nicht.", status_code=404)
        data = mount_input_from_model(m)
-        cred = credential_for_test(data, m, state.secrets)
+        cred = credential_for_test(data, m, state.secrets, s)
        from netmover.mounting.manager import MountConfig

        cfg = MountConfig.from_model(m)
@@ -563,6 +591,74 @@ async def mount_reset_hostkey(request: Request, mount_id: int) -> Response:
    return redirect(f"/mounts#mount-{mount_id}")


+# -- Schlüsselverwaltung ----------------------------------------------------------------------
+
+
+@protected.get("/keys", response_class=HTMLResponse)
+async def keys_page(request: Request) -> Response:
+    with nm(request).session_factory() as s:
+        return render(request, "keys.html", active="keys", keys=list_keys(s))
+
+
+async def _key_action(request: Request, work: Callable[[Any], str]) -> Response:
+    state = nm(request)
+    try:
+        with session_scope(state.session_factory) as s:
+            flash(request, work(s))
+    except AdminError as exc:
+        flash(request, str(exc), "error")
+    return redirect("/keys")
+
+
+@protected.post("/keys/generate")
+async def key_generate(request: Request) -> Response:
+    form = _form_dict(await request.form())
+    secrets = nm(request).secrets
+
+    def work(s: Any) -> str:
+        key = generate_key(s, secrets, form.get("name", ""))
+        return f"Schlüssel „{key.name}“ erzeugt."
+
+    return await _key_action(request, work)
+
+
+@protected.post("/keys/import")
+async def key_import(request: Request) -> Response:
+    form = _form_dict(await request.form())
+    secrets = nm(request).secrets
+
+    def work(s: Any) -> str:
+        key = import_key(
+            s,
+            secrets,
+            form.get("name", ""),
+            form.get("private_key", ""),
+            form.get("passphrase", ""),
+        )
+        return f"Schlüssel „{key.name}“ importiert."
+
+    return await _key_action(request, work)
+
+
+@protected.post("/keys/{key_id}/rename")
+async def key_rename(request: Request, key_id: int) -> Response:
+    form = _form_dict(await request.form())
+
+    def work(s: Any) -> str:
+        rename_key(s, key_id, form.get("name", ""))
+        return "Schlüssel umbenannt."
+
+    return await _key_action(request, work)
+
+
+@protected.post("/keys/{key_id}/delete")
+async def key_delete(request: Request, key_id: int) -> Response:
+    def work(s: Any) -> str:
+        return f"Schlüssel „{delete_key(s, key_id)}“ gelöscht."
+
+    return await _key_action(request, work)
+
+
 # -- Regeln -----------------------------------------------------------------------------------


@@ -17,6 +17,7 @@
  <nav class="main">
    <a href="/" class="{{ 'active' if active == 'status' }}">Status</a>
    <a href="/mounts" class="{{ 'active' if active == 'mounts' }}">Anbindungen</a>
+    <a href="/keys" class="{{ 'active' if active == 'keys' }}">Schlüssel</a>
    <a href="/rules" class="{{ 'active' if active == 'rules' }}">Regeln</a>
    <a href="/log" class="{{ 'active' if active == 'log' }}">Protokoll</a>
    <a href="/settings" class="{{ 'active' if active == 'settings' }}">Einstellungen</a>
@@ -0,0 +1,56 @@
+{% extends "base.html" %}
+{% from "macros.html" import csrf_field %}
+{% block title %}Schlüssel{% endblock %}
+{% block content %}
+<h1>SSH-Schlüssel</h1>
+<p class="muted small">Gespeicherte Schlüssel für SFTP-Anbindungen. Ein Schlüssel kann von mehreren
+  Anbindungen benutzt werden; den Benutzernamen legt jede Anbindung selbst fest. Private Schlüssel
+  liegen verschlüsselt in der Datenbank und werden nie angezeigt.</p>
+
+{% if not keys %}<p class="muted">Noch keine Schlüssel gespeichert.</p>{% endif %}
+<div class="stack">
+{% for k in keys %}
+<div class="card" id="key-{{ k.id }}">
+  <div class="row spread">
+    <div><strong>{{ k.name }}</strong> <span class="badge">{{ k.key_type.removeprefix('ssh-') }}</span>
+      {% if k.used_by %}<span class="badge ok">benutzt von {{ k.used_by|join(', ') }}</span>{% else %}<span class="badge">unbenutzt</span>{% endif %}</div>
+    <div class="row">
+      <form class="inline row" method="post" action="/keys/{{ k.id }}/rename">{{ csrf_field(csrf) }}
+        <input type="text" name="name" value="{{ k.name }}" aria-label="Neuer Name" required maxlength="100">
+        <button class="small">Umbenennen</button></form>
+      <form class="inline" method="post" action="/keys/{{ k.id }}/delete" data-confirm="Schlüssel „{{ k.name }}“ löschen?">{{ csrf_field(csrf) }}
+        <button class="small danger" {{ 'disabled' if k.used_by }}>Löschen</button></form>
+    </div>
+  </div>
+  <div class="small muted">Fingerabdruck <span class="mono">{{ k.fingerprint }}</span> · angelegt {{ k.created_at|localdt }}</div>
+  <details class="small"><summary>Öffentlicher Schlüssel / authorized_keys</summary>
+    <div class="field"><label>Zeile für <code>~/.ssh/authorized_keys</code> (nur SFTP erlaubt, empfohlen)</label>
+      <pre class="mono card" id="auth-{{ k.id }}">{{ k.authorized_keys_line }}</pre>
+      <button class="small" type="button" data-copy="auth-{{ k.id }}">kopieren</button></div>
+    <div class="field"><label>Öffentlicher Schlüssel</label>
+      <pre class="mono card" id="pub-{{ k.id }}">{{ k.public_key }}</pre>
+      <button class="small" type="button" data-copy="pub-{{ k.id }}">kopieren</button></div>
+  </details>
+</div>
+{% endfor %}
+</div>
+
+<h2>Neuen Schlüssel erzeugen</h2>
+<form class="form card row" method="post" action="/keys/generate">{{ csrf_field(csrf) }}
+  <input type="text" name="name" placeholder="Name, z. B. paperless-lxc" aria-label="Name" required maxlength="100">
+  <button class="primary">Ed25519-Schlüssel erzeugen</button>
+</form>
+
+<h2>Vorhandenen Schlüssel importieren</h2>
+<form class="form card stack" method="post" action="/keys/import">{{ csrf_field(csrf) }}
+  <div class="fields">
+    <div class="field"><label for="k-name">Name</label><input id="k-name" type="text" name="name" required maxlength="100"></div>
+    <div class="field"><label for="k-pass">Passphrase (falls vorhanden)</label><input id="k-pass" type="password" name="passphrase" autocomplete="off"></div>
+    <div class="field wide"><label for="k-priv">Privater Schlüssel</label>
+      <textarea id="k-priv" name="private_key" class="mono" rows="8" autocomplete="off" spellcheck="false"
+        placeholder="-----BEGIN OPENSSH PRIVATE KEY-----&#10;…&#10;-----END OPENSSH PRIVATE KEY-----" required></textarea>
+      <span class="hint">Ed25519, ECDSA oder RSA (mind. 2048 Bit), OpenSSH- oder PEM-Format. Eine Passphrase wird nur zum Entschlüsseln benutzt.</span></div>
+  </div>
+  <button>Importieren</button>
+</form>
+{% endblock %}
@@ -23,7 +23,10 @@
  </div></fieldset>

  <fieldset data-show-for="type:cifs sftp"><legend>Anmeldung</legend><div class="fields">
-    <div data-show-for="type:sftp">{{ select('auth', 'Anmeldeart', [('ssh_key', 'SSH-Schlüssel (NetMover erzeugt ihn)'), ('password', 'Passwort')], d.auth.value, errors=errors) }}</div>
+    <div data-show-for="type:sftp">{{ select('auth', 'Anmeldeart', [('ssh_key', 'SSH-Schlüssel'), ('password', 'Passwort')], d.auth.value, errors=errors) }}</div>
+    <div data-show-for="type:sftp"><div data-show-for="auth:ssh_key">
+      {{ select('key_id', 'Schlüssel', key_options, d.key_id, errors=errors, hint='Gespeicherte Schlüssel verwalten unter „Schlüssel“.') }}
+    </div></div>
    {{ field('username', 'Benutzername', d.username, errors=errors, attrs='autocomplete="off"', hint='Bei CIFS leer lassen für Gastzugang') }}
    <div data-show-for="type:cifs">{{ field('domain', 'Domäne (optional)', d.domain, errors=errors) }}</div>
    <div class="field{{ ' has-error' if errors.get('password') }}" id="pw-field">
@@ -33,7 +36,7 @@
      <span class="hint">{{ 'Leer lassen = unverändert. ' if has_secret }}Bei SFTP mit Schlüssel leer lassen.</span>
    </div>
  </div>
-  {% if public_key %}<div class="field wide"><label>Öffentlicher Schlüssel (in ~/.ssh/authorized_keys des Zielbenutzers eintragen)</label>
+  {% if public_key %}<div class="field wide"><label>Öffentlicher Schlüssel dieser Anbindung (in ~/.ssh/authorized_keys des Zielbenutzers eintragen)</label>
    <pre class="mono card" id="pubkey">{{ public_key }}</pre><button class="small" type="button" data-copy="pubkey">kopieren</button></div>{% endif %}
  </fieldset>

@@ -32,6 +32,9 @@
    <div class="small">Hostschlüssel: {% if m.host_key %}<span class="mono">{{ m.host_key.split()[0] }}</span> festgehalten
      <form class="inline" method="post" action="/mounts/{{ m.id }}/reset-hostkey" data-confirm="Hostschlüssel zurücksetzen? Nur tun, wenn der Server neu aufgesetzt wurde.">{{ csrf_field(csrf) }}<button class="small">zurücksetzen</button></form>
      {% else %}<span class="text-warn">noch nicht bestätigt – bitte „Testen“</span>{% endif %}</div>
+    {% if key_names.get(m.id) %}
+    <div class="small">Anmeldung mit gespeichertem Schlüssel <a href="/keys">„{{ key_names[m.id] }}“</a></div>
+    {% endif %}
    {% if pubkeys.get(m.id) %}
    <details class="small"><summary>Öffentlicher Schlüssel für authorized_keys</summary>
      <pre class="mono" id="pub-{{ m.id }}">{{ pubkeys[m.id] }}</pre>
@@ -730,3 +730,52 @@ def test_final_step_is_a_real_rename_when_possible(
    assert (dst / "a.pdf").read_text() == "alt" and (dst / "a-1.pdf").read_text() == "neu"
    assert bool(links) is not supported
    assert [p.name for p in dst.iterdir() if p.name.endswith(".part")] == []
+
+
+# -- Praxisbefund: veralteter Attribut-Cache (CIFS/NFS) -------------------------------------
+
+
+def test_stability_uses_fresh_attributes_not_stat_cache(
+    engine: Engine,
+    rule_id: int,
+    src: Path,
+    dst: Path,
+    hooks: list[Callable[[], None]],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Auf dem Testhost lieferte CIFS per stat() sekundenlang eine veraltete Größe,
+    während die Datei wuchs. Simuliert: os.stat liefert für die Datei immer den
+    alten Stand (Cache), nur öffnen + fstat sieht die Wahrheit."""
+    growing = write(src / "langsam.pdf", "a" * 10)
+    stale = os.stat(growing)
+    real_stat = os.stat
+
+    def cached_stat(path: object, *a: object, **kw: object) -> os.stat_result:
+        if str(path) == str(growing):
+            return stale
+        return real_stat(path, *a, **kw)  # type: ignore[arg-type]
+
+    monkeypatch.setattr(os, "stat", cached_stat)
+    hooks.append(lambda: growing.write_text("a" * 20))
+    result = run(engine, snap(rule_id), src, dst)
+    assert statuses(result) == {"langsam.pdf": ItemStatus.SKIPPED}
+    assert "wird noch geschrieben" in (result.items[0].message or "")
+    assert growing.exists() and not (dst / "langsam.pdf").exists()
+
+
+def test_locked_file_counts_as_in_use(
+    engine: Engine, rule_id: int, src: Path, dst: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    f = write(src / "gesperrt.pdf")
+    real_open = os.open
+
+    def locked(path: object, flags: int, *a: object, **kw: object) -> int:
+        if str(path) == str(f):
+            raise PermissionError(errno.EACCES, "Permission denied", str(path))
+        return real_open(path, flags, *a, **kw)  # type: ignore[arg-type]
+
+    monkeypatch.setattr("netmover.mover.scan.os.open", locked)
+    result = run(engine, snap(rule_id), src, dst)
+    assert statuses(result) == {"gesperrt.pdf": ItemStatus.SKIPPED}
+    assert result.items[0].message == "Datei ist gerade in Benutzung"
+    assert f.exists()
@@ -0,0 +1,277 @@
+"""Schlüsselverwaltung: erzeugen, importieren, auswählen, schützen."""
+
+from __future__ import annotations
+
+import subprocess
+from collections.abc import Iterator
+from pathlib import Path
+
+import pytest
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import ec, rsa
+from sqlalchemy import select
+from sqlalchemy.orm import Session, sessionmaker
+
+from netmover.admin import AdminError, MountInput, delete_mount, save_mount
+from netmover.crypto import SecretBox, generate_ssh_keypair
+from netmover.db import session_scope
+from netmover.keys import delete_key, fingerprint, generate_key, import_key, list_keys, rename_key
+from netmover.models import Credential, CredentialKind, Mount, MountType
+from netmover.mounting.manager import MountConfig, MountManager
+from tests.sftp_stub import StubSFTPServer
+
+
+def _sftp_input(**kw: object) -> MountInput:
+    data: dict[str, object] = {
+        "name": "paperless",
+        "type": MountType.SFTP,
+        "server": "127.0.0.1",
+        "share": "/consume",
+        "port": 22,
+        "username": "paperless",
+        "auth": CredentialKind.SSH_KEY,
+    }
+    data.update(kw)
+    return MountInput(**data)  # type: ignore[arg-type]
+
+
+# -- Modul --------------------------------------------------------------------------------------
+
+
+def test_generate_key(session: Session, secretbox: SecretBox) -> None:
+    key = generate_key(session, secretbox, "paperless-lxc")
+    assert key.managed and key.kind is CredentialKind.SSH_KEY
+    assert key.public_key and key.public_key.startswith("ssh-ed25519 ")
+    assert key.public_key.endswith(" netmover:paperless-lxc")
+    assert "PRIVATE" not in key.public_key
+    assert "OPENSSH PRIVATE KEY" in secretbox.decrypt(key.secret_enc)
+    info = list_keys(session)[0]
+    assert info.fingerprint.startswith("SHA256:") and info.used_by == []
+    assert info.authorized_keys_line.startswith(
+        'restrict,command="/usr/lib/openssh/sftp-server" ssh-ed25519 '
+    )
+
+
+def test_fingerprint_matches_ssh_keygen(tmp_path: Path) -> None:
+    _, pub = generate_ssh_keypair("x")
+    f = tmp_path / "k.pub"
+    f.write_text(pub + "\n")
+    try:
+        out = subprocess.run(
+            ["ssh-keygen", "-lf", str(f)],  # noqa: S607 – Abgleich mit OpenSSH
+            capture_output=True,
+            text=True,
+            check=True,
+        ).stdout
+    except FileNotFoundError:
+        pytest.skip("ssh-keygen nicht installiert")
+    assert fingerprint(pub) == out.split()[1]
+
+
+@pytest.mark.parametrize(
+    "kind", ["ed25519-openssh-pass", "rsa-pem", "ecdsa-pem-pass", "rsa-openssh"]
+)
+def test_import_formats(session: Session, secretbox: SecretBox, kind: str) -> None:
+    from cryptography.hazmat.primitives.asymmetric import ed25519
+
+    if kind.startswith("ed25519"):
+        key = ed25519.Ed25519PrivateKey.generate()
+    elif kind.startswith("rsa"):
+        key = rsa.generate_private_key(public_exponent=65537, key_size=2048)  # type: ignore[assignment]
+    else:
+        key = ec.generate_private_key(ec.SECP256R1())  # type: ignore[assignment]
+    enc = (
+        serialization.BestAvailableEncryption(b"geheim")
+        if kind.endswith("pass")
+        else serialization.NoEncryption()
+    )
+    fmt = (
+        serialization.PrivateFormat.OpenSSH
+        if "openssh" in kind
+        else serialization.PrivateFormat.PKCS8
+    )
+    pem = key.private_bytes(serialization.Encoding.PEM, fmt, enc).decode()
+    cred = import_key(session, secretbox, kind, pem, "geheim" if kind.endswith("pass") else "")
+    expected_pub = (
+        key.public_key()
+        .public_bytes(serialization.Encoding.OpenSSH, serialization.PublicFormat.OpenSSH)
+        .decode()
+    )
+    assert cred.public_key is not None and cred.public_key.startswith(expected_pub)
+    stored = secretbox.decrypt(cred.secret_enc)
+    assert "OPENSSH PRIVATE KEY" in stored
+    # ohne Passphrase gespeichert → von paramiko direkt nutzbar
+    from netmover.mounting.sftp import load_private_key
+
+    assert load_private_key(stored).get_base64() == expected_pub.split()[1]
+
+
+def test_import_errors(session: Session, secretbox: SecretBox) -> None:
+    from cryptography.hazmat.primitives.asymmetric import ed25519
+
+    key = ed25519.Ed25519PrivateKey.generate()
+    protected = key.private_bytes(
+        serialization.Encoding.PEM,
+        serialization.PrivateFormat.OpenSSH,
+        serialization.BestAvailableEncryption(b"richtig"),
+    ).decode()
+    with pytest.raises(AdminError, match="Passphrase angeben"):
+        import_key(session, secretbox, "a", protected, "")
+    with pytest.raises(AdminError, match="Passphrase falsch"):
+        import_key(session, secretbox, "a", protected, "falsch")
+    _, pub = generate_ssh_keypair()
+    with pytest.raises(AdminError, match="öffentlicher Schlüssel"):
+        import_key(session, secretbox, "a", pub)
+    with pytest.raises(AdminError, match="Kein lesbarer"):
+        import_key(
+            session, secretbox, "a", "-----BEGIN PRIVATE KEY-----\nMüll\n-----END PRIVATE KEY-----"
+        )
+    weak = (
+        rsa.generate_private_key(public_exponent=65537, key_size=1024)  # noqa: S505 – absichtlich schwach
+        .private_bytes(
+            serialization.Encoding.PEM,
+            serialization.PrivateFormat.PKCS8,
+            serialization.NoEncryption(),
+        )
+        .decode()
+    )
+    with pytest.raises(AdminError, match="zu schwach"):
+        import_key(session, secretbox, "a", weak)
+    assert list_keys(session) == []
+
+
+def test_names(session: Session, secretbox: SecretBox) -> None:
+    generate_key(session, secretbox, "eins")
+    with pytest.raises(AdminError, match="existiert bereits"):
+        generate_key(session, secretbox, "eins")
+    with pytest.raises(AdminError, match="reserviert"):
+        generate_key(session, secretbox, "mount:x")
+    zwei = generate_key(session, secretbox, "zwei")
+    rename_key(session, zwei.id, "drei")
+    assert [k.name for k in list_keys(session)] == ["drei", "eins"]
+    with pytest.raises(AdminError):
+        rename_key(session, zwei.id, "eins")
+
+
+# -- Zusammenspiel mit Anbindungen ----------------------------------------------------------
+
+
+def test_mount_uses_shared_key_with_own_username(
+    session: Session, secretbox: SecretBox, manager: MountManager
+) -> None:
+    key = generate_key(session, secretbox, "lxc")
+    a, err = save_mount(session, secretbox, manager, _sftp_input(key_id=str(key.id)))
+    assert not err and a is not None
+    b, err = save_mount(
+        session,
+        secretbox,
+        manager,
+        _sftp_input(name="anderer", server="10.0.0.9", username="root", key_id=str(key.id)),
+    )
+    assert not err and b is not None
+    assert a.credential is key and b.credential is key
+    assert (a.username, b.username) == ("paperless", "root")
+    assert key.username == ""  # der Schlüssel selbst bleibt unverändert
+    assert list_keys(session)[0].used_by == ["anderer", "paperless"]
+
+    # Schlüssel in Benutzung → nicht löschbar
+    with pytest.raises(AdminError, match="noch benutzt"):
+        delete_key(session, key.id)
+    # Anbindung löschen lässt den gespeicherten Schlüssel stehen
+    delete_mount(session, manager, a.id)
+    delete_mount(session, manager, b.id)
+    assert session.get(Credential, key.id) is not None
+    delete_key(session, key.id)
+    assert session.get(Credential, key.id) is None
+
+
+def test_switching_between_own_and_shared_key(
+    session: Session, secretbox: SecretBox, manager: MountManager
+) -> None:
+    m, _ = save_mount(session, secretbox, manager, _sftp_input())  # eigener Schlüssel
+    assert m is not None and m.credential is not None and not m.credential.managed
+    own_id = m.credential.id
+    key = generate_key(session, secretbox, "geteilt")
+    m, _ = save_mount(session, secretbox, manager, _sftp_input(key_id=str(key.id)), m.id)
+    assert m is not None and m.credential is key
+    assert session.get(Credential, own_id) is None  # eigener Schlüssel aufgeräumt
+    # Wechsel auf Passwort darf den gespeicherten Schlüssel nicht verändern
+    secret_before = key.secret_enc
+    m, _ = save_mount(
+        session,
+        secretbox,
+        manager,
+        _sftp_input(auth=CredentialKind.PASSWORD, password="pw123"),
+        m.id,
+    )
+    assert m is not None and m.credential is not None and m.credential is not key
+    assert not m.credential.managed and m.credential.username == "paperless"
+    assert m.username is None
+    assert key.secret_enc == secret_before and key.kind is CredentialKind.SSH_KEY
+
+
+def test_unknown_or_foreign_key_id_is_rejected(
+    session: Session, secretbox: SecretBox, manager: MountManager
+) -> None:
+    own, _ = save_mount(session, secretbox, manager, _sftp_input(name="a"))
+    assert own is not None and own.credential is not None
+    for bad in ("4711", str(own.credential.id)):  # nicht vorhanden / kein gespeicherter Schlüssel
+        m, err = save_mount(session, secretbox, manager, _sftp_input(name="b", key_id=bad))
+        assert m is None and "key_id" in err
+
+
+@pytest.fixture
+def server(tmp_path: Path) -> Iterator[StubSFTPServer]:
+    root = tmp_path / "sftp-root"
+    (root / "consume").mkdir(parents=True)
+    srv = StubSFTPServer(root, username="paperless").start()
+    yield srv
+    srv.stop()
+
+
+def test_manager_connects_with_shared_key_and_mount_username(
+    server: StubSFTPServer,
+    session_factory: sessionmaker[Session],
+    secretbox: SecretBox,
+    manager: MountManager,
+) -> None:
+    with session_scope(session_factory) as s:
+        key = import_key(s, secretbox, "lxc", server.client_private_key)
+        m, err = save_mount(
+            s, secretbox, manager, _sftp_input(port=server.port, key_id=str(key.id))
+        )
+        assert not err and m is not None
+        mid = m.id
+    with session_factory() as s:
+        mm = s.get(Mount, mid)
+        assert mm is not None
+        cfg = MountConfig.from_model(mm)
+    from netmover.admin import credential_for_test, mount_input_from_model
+
+    with session_factory() as s:
+        mm = s.get(Mount, mid)
+        assert mm is not None
+        data = mount_input_from_model(mm)
+        assert data.key_id == str(mm.cred_id) and data.username == "paperless"
+        cred = credential_for_test(data, mm, secretbox, s)
+    assert cred is not None and cred.username == "paperless"
+    assert manager.check(cfg, cred, mount_id=mid).ok
+    assert manager.check_alive(mid) is None  # Regellauf-Weg: Benutzer der Anbindung
+
+    # Gegenprobe: falscher Benutzer an der Anbindung → Anmeldung abgelehnt
+    with session_scope(session_factory) as s:
+        mm = s.get(Mount, mid)
+        assert mm is not None
+        mm.username = "jemand"
+    from netmover.mounting.manager import MountUnavailable
+
+    with pytest.raises(MountUnavailable, match="Anmeldung abgelehnt"):
+        manager.check_alive(mid)
+
+
+def test_list_keys_ignores_per_mount_credentials(
+    session: Session, secretbox: SecretBox, manager: MountManager
+) -> None:
+    save_mount(session, secretbox, manager, _sftp_input())
+    assert list_keys(session) == []
+    assert session.scalars(select(Credential)).one().managed is False
@@ -110,8 +110,49 @@ def test_is_mounted_reads_mountinfo(tmp_path: Path) -> None:
        ),
        ("nfs4", "mount.nfs4: access denied by server while mounting nas:/x", "NFS-Berechtigungen"),
        ("cifs", "mount error(112): Host is down", "nicht erreichbar"),
+        # Praxisfall: Synology mit „Maximales SMB-Protokoll: SMB2“
+        (
+            "cifs",
+            "mount error(95): Operation not supported\nRefer to the mount.cifs(8) manual page",
+            "vers=2.0",
+        ),
        ("cifs", "mount: only root can do that", "CAP_SYS_ADMIN"),
    ],
 )
 def test_explain(fstype: str, msg: str, expect: str) -> None:
    assert expect in explain_mount_error(fstype, msg)
+
+
+def _alive(pid: int) -> bool:
+    try:
+        with open(f"/proc/{pid}/stat") as fh:
+            return fh.read().split(")")[-1].split()[0] != "Z"
+    except (FileNotFoundError, ProcessLookupError):  # verschwindet beim Lesen → ESRCH
+        return False
+
+
+def test_timeout_kills_whole_process_group(tmp_path: Path) -> None:
+    """mount startet Helfer (mount.nfs) – die dürfen nach dem Zeitlimit nicht weiterlaufen."""
+    from netmover.mounting.linux import run_process_group
+
+    pidfile = tmp_path / "helper.pid"
+    script = f"sleep 30 & echo $! > {pidfile}; wait"
+    with pytest.raises(subprocess.TimeoutExpired):
+        run_process_group(["sh", "-c", script], capture_output=True, text=True, timeout=0.5)
+    helper = int(pidfile.read_text())
+    for _ in range(20):
+        if not _alive(helper):
+            break
+        import time
+
+        time.sleep(0.05)
+    assert not _alive(helper)
+
+
+def test_process_group_runner_returns_output() -> None:
+    from netmover.mounting.linux import run_process_group
+
+    r = run_process_group(
+        ["sh", "-c", "echo out; echo err >&2; exit 3"], capture_output=True, text=True, timeout=5
+    )
+    assert (r.returncode, r.stdout, r.stderr) == (3, "out\n", "err\n")
@@ -367,3 +367,159 @@ def test_usage(
    manager.mount(mid)
    usage = manager.usage(mid)
    assert usage is not None and usage[0] >= usage[1] > 0
+
+
+# -- Praxisbefund: NAS-Neustart dauert länger als die Wiederherstellung ----------------------
+
+
+class Clock:
+    def __init__(self) -> None:
+        self.now = 1000.0
+
+    def __call__(self) -> float:
+        return self.now
+
+
+@pytest.fixture
+def clock() -> Clock:
+    return Clock()
+
+
+@pytest.fixture
+def retry_manager(
+    session_factory: sessionmaker[Session],
+    fake_backend: FakeMountBackend,
+    secretbox: object,
+    mount_base: Path,
+    notifications: list[tuple[str, str, str]],
+    clock: Clock,
+) -> MountManager:
+    return MountManager(
+        session_factory,
+        fake_backend,
+        secretbox,
+        mount_base,  # type: ignore[arg-type]
+        probe_timeout=0.5,
+        recover_backoff=(0, 0, 0),
+        sleep=lambda _: None,
+        notifier=lambda *a: notifications.append(a),
+        retry_interval=60,
+        clock=clock,
+    )
+
+
+def test_failed_recovery_retries_every_interval_until_nas_is_back(
+    retry_manager: MountManager,
+    fake_backend: FakeMountBackend,
+    make_mount: MountFactory,
+    session_factory: sessionmaker[Session],
+    notifications: list[tuple[str, str, str]],
+    clock: Clock,
+) -> None:
+    fake_backend.export("nas", "scans")
+    mid = make_mount()
+    retry_manager.mount(mid)
+    mp = retry_manager.mountpoint_for("scans")
+    fake_backend.inject_fault(mp, errno.ESTALE)
+    fake_backend.fail_next_mount(times=3)  # NAS startet neu
+    with pytest.raises(MountUnavailable, match="alle 60 s"):
+        retry_manager.check_alive(mid)
+    assert not fake_backend.is_mounted(mp)
+
+    mounts_before = sum(1 for c in fake_backend.calls if c.action == "mount")
+    clock.now += 30  # zu früh: kein Versuch, Lauf abgebrochen
+    with pytest.raises(MountUnavailable, match="in 30 s"):
+        retry_manager.check_alive(mid)
+    assert sum(1 for c in fake_backend.calls if c.action == "mount") == mounts_before
+
+    clock.now += 30  # NAS noch nicht zurück
+    fake_backend.fail_next_mount()
+    with pytest.raises(MountUnavailable, match="weiterhin nicht verfügbar"):
+        retry_manager.check_alive(mid)
+
+    clock.now += 60  # NAS wieder da
+    assert retry_manager.check_alive(mid) == mp
+    assert fake_backend.is_mounted(mp)
+    assert _state(session_factory, mid).state is MountState.MOUNTED
+    assert notifications[-1][0] == "mount.recovered"
+
+
+def test_no_retry_without_auto_mount(
+    retry_manager: MountManager,
+    fake_backend: FakeMountBackend,
+    make_mount: MountFactory,
+    clock: Clock,
+) -> None:
+    fake_backend.export("nas", "scans")
+    mid = make_mount(auto_mount=False)
+    retry_manager.mount(mid)
+    fake_backend.inject_fault(retry_manager.mountpoint_for("scans"), errno.ESTALE)
+    fake_backend.fail_next_mount(times=3)
+    with pytest.raises(MountUnavailable):
+        retry_manager.check_alive(mid)
+    clock.now += 600
+    with pytest.raises(MountUnavailable, match="nicht eingehängt"):
+        retry_manager.check_alive(mid)
+
+
+def test_externally_unmounted_is_still_never_remounted(
+    retry_manager: MountManager,
+    fake_backend: FakeMountBackend,
+    make_mount: MountFactory,
+    clock: Clock,
+) -> None:
+    fake_backend.export("nas", "scans")
+    mid = make_mount()
+    retry_manager.mount(mid)
+    fake_backend.vanish(retry_manager.mountpoint_for("scans"))
+    clock.now += 600
+    with pytest.raises(MountUnavailable, match="nicht eingehängt"):
+        retry_manager.check_alive(mid)
+    assert [c.action for c in fake_backend.calls] == ["mount"]
+
+
+def test_hint_text_is_not_redacted() -> None:
+    from netmover.mounting.manager import _redact_output
+
+    msg = "mount error(13): Permission denied falsch\n→ Benutzername/Passwort falsch oder …"
+    out = _redact_output(msg, ["falsch"])
+    assert out.startswith("mount error(13): Permission denied ••••••")
+    assert out.endswith("→ Benutzername/Passwort falsch oder …")
+
+
+def test_restore_failure_at_boot_is_retried_by_background_job(
+    retry_manager: MountManager,
+    fake_backend: FakeMountBackend,
+    make_mount: MountFactory,
+    session_factory: sessionmaker[Session],
+    notifications: list[tuple[str, str, str]],
+    clock: Clock,
+) -> None:
+    """Stromausfall: die VM bootet schneller als das NAS."""
+    fake_backend.export("nas", "scans")
+    mid = make_mount()  # keine Regel benutzt die Anbindung
+    fake_backend.fail_next_mount()
+    assert [r.ok for r in retry_manager.restore_all()] == [False]
+    assert retry_manager.retry_pending() == []  # noch nicht fällig
+    clock.now += 60
+    assert retry_manager.retry_pending() == ["scans"]
+    assert fake_backend.is_mounted(retry_manager.mountpoint_for("scans"))
+    assert _state(session_factory, mid).state is MountState.MOUNTED
+    assert notifications[-1][0] == "mount.recovered"
+    clock.now += 60
+    assert retry_manager.retry_pending() == []  # erledigt
+
+
+def test_manual_unmount_stops_retrying(
+    retry_manager: MountManager,
+    fake_backend: FakeMountBackend,
+    make_mount: MountFactory,
+    clock: Clock,
+) -> None:
+    mid = make_mount()  # nicht exportiert → Wiederherstellung scheitert
+    retry_manager.restore_all()
+    retry_manager.unmount(mid)
+    fake_backend.export("nas", "scans")
+    clock.now += 120
+    assert retry_manager.retry_pending() == []
+    assert not fake_backend.mounted
@@ -0,0 +1,136 @@
+"""Migrationen auf Datenbanken MIT Daten.
+
+Praxisbefund beim Update 0.1.1 → 0.2.0: Migration 0002 baut auf SQLite Tabellen neu
+auf (batch mode) und löscht dafür die alte Tabelle. Mit eingeschalteter
+Fremdschlüsselprüfung scheiterte das, sobald Anbindungen auf Zugangsdaten
+verwiesen – die Tests liefen bis dahin nur auf leeren Datenbanken. Und weil die
+Migration nicht in einer Transaktion lief, blieb ein halber Zustand zurück.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+
+import pytest
+from alembic import command
+
+from netmover.db import alembic_config, upgrade
+
+
+def _seed(db: Path) -> None:
+    """Datenbank auf Stand 0001 mit verknüpften Daten, wie auf einem echten System."""
+    c = sqlite3.connect(db)
+    c.execute("PRAGMA foreign_keys=ON")
+    c.executescript(
+        """
+        INSERT INTO credentials (id, name, kind, username, secret_enc, created_at)
+            VALUES (1, 'mount:nas', 'password', 'scanner', 'gAAAA-x', '2026-10-10 20:00:00'),
+                   (2, 'mount:paperless', 'ssh_key', 'root', 'gAAAA-y', '2026-10-10 20:00:00');
+        INSERT INTO mounts (id, name, slug, type, server, share, mountpoint, cred_id,
+                            extra_options, auto_mount, enabled, state)
+            VALUES (1, 'NAS', 'nas', 'cifs', '10.0.10.6', 'Scans', '/mnt/netmover/nas', 1,
+                    '', 1, 1, 'mounted'),
+                   (2, 'paperless', 'paperless', 'sftp', '10.0.10.17', '/consume', NULL, 2,
+                    '', 0, 1, 'mounted');
+        INSERT INTO rules (id, name, enabled, src_mount_id, src_subpath, dst_mount_id, dst_path,
+                           pattern, pattern_type, recursive, interval_seconds, stability_seconds,
+                           min_age_seconds, op_timeout_seconds, action, on_collision, dry_run,
+                           quarantine_after, consecutive_failures, created_at)
+            VALUES (1, 'Scans → Paperless', 0, 1, '', 2, '', '*.pdf', 'glob', 0, 30, 5, 0, 120,
+                    'move', 'rename', 0, 3, 0, '2026-10-10 20:00:00');
+        INSERT INTO runs (id, rule_id, started_at, status, "trigger", dry_run, seen, moved,
+                          skipped, failed)
+            VALUES (1, 1, '2026-10-10 20:00:00', 'ok', 'manual', 1, 3, 3, 0, 0);
+        INSERT INTO run_items (run_id, src, status) VALUES (1, 'a.pdf', 'planned');
+        """
+    )
+    c.commit()
+    c.close()
+
+
+@pytest.fixture
+def db_0001(tmp_path: Path) -> tuple[str, Path]:
+    db = tmp_path / "alt.db"
+    url = f"sqlite:///{db}"
+    upgrade(url, "0001")
+    _seed(db)
+    return url, db
+
+
+def _state(db: Path) -> dict[str, object]:
+    c = sqlite3.connect(db)
+    try:
+        return {
+            "version": c.execute("SELECT version_num FROM alembic_version").fetchone()[0],
+            "tmp_tables": c.execute(
+                "SELECT name FROM sqlite_master WHERE name LIKE '_alembic_tmp%'"
+            ).fetchall(),
+            "cred_columns": [r[1] for r in c.execute("PRAGMA table_info(credentials)")],
+            "mounts": c.execute("SELECT name, cred_id FROM mounts ORDER BY id").fetchall(),
+            "rules": c.execute("SELECT name, src_mount_id, dst_mount_id FROM rules").fetchall(),
+            "run_items": c.execute("SELECT COUNT(*) FROM run_items").fetchone()[0],
+            "fk_violations": c.execute("PRAGMA foreign_key_check").fetchall(),
+        }
+    finally:
+        c.close()
+
+
+def test_upgrade_with_linked_data(db_0001: tuple[str, Path]) -> None:
+    url, db = db_0001
+    upgrade(url)
+    st = _state(db)
+    assert st["version"] == "0002"
+    assert st["tmp_tables"] == [] and st["fk_violations"] == []
+    assert "managed" in st["cred_columns"]  # type: ignore[operator]
+    assert st["mounts"] == [("NAS", 1), ("paperless", 2)]
+    assert st["rules"] == [("Scans → Paperless", 1, 2)]
+    assert st["run_items"] == 1
+    c = sqlite3.connect(db)
+    assert c.execute("SELECT managed FROM credentials ORDER BY id").fetchall() == [(0,), (0,)]
+    assert c.execute("SELECT username FROM mounts ORDER BY id").fetchall() == [(None,), (None,)]
+    c.close()
+
+
+def test_downgrade_with_linked_data(db_0001: tuple[str, Path]) -> None:
+    url, db = db_0001
+    upgrade(url)
+    command.downgrade(alembic_config(url), "0001")
+    st = _state(db)
+    assert st["version"] == "0001" and st["fk_violations"] == []
+    assert st["mounts"] == [("NAS", 1), ("paperless", 2)]
+
+
+def test_failed_migration_leaves_database_untouched(
+    db_0001: tuple[str, Path], monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Bricht eine Migration mittendrin ab, muss alles beim Alten bleiben – keine
+    halb umgebauten Tabellen, kein _alembic_tmp-Rest, Version unverändert."""
+    from alembic.ddl.impl import DefaultImpl
+
+    url, db = db_0001
+    before = _state(db)
+    real_drop = DefaultImpl.drop_table
+
+    def boom(self: DefaultImpl, *a: object, **kw: object) -> None:
+        raise RuntimeError("Absturz mitten in der Migration")
+
+    monkeypatch.setattr(DefaultImpl, "drop_table", boom)
+    with pytest.raises(RuntimeError, match="Absturz"):
+        upgrade(url)
+    assert _state(db) == before
+
+    monkeypatch.setattr(DefaultImpl, "drop_table", real_drop)
+    upgrade(url)  # danach klappt es ohne Handarbeit
+    assert _state(db)["version"] == "0002"
+
+
+def test_app_engine_still_enforces_foreign_keys(db_url: str) -> None:
+    from sqlalchemy import text
+
+    from netmover.db import make_engine
+
+    engine = make_engine(db_url)
+    with engine.connect() as conn:
+        assert conn.execute(text("PRAGMA foreign_keys")).scalar() == 1
+    engine.dispose()
@@ -147,6 +147,8 @@ def test_manager_pins_host_key_and_checks_alive(
    with session_factory() as s:
        mm = s.get(Mount, mid)
        assert mm is not None and mm.host_key == server.host_key_string
+        # Praxisbefund: nach erfolgreichem Test „erreichbar“ statt „nicht geprüft“
+        assert mm.state is MountState.MOUNTED

    assert manager.check_alive(mid) is None
    with session_factory() as s:
@@ -154,7 +154,16 @@ def test_security_headers(client: TestClient) -> None:


 def test_no_inline_scripts_or_styles(client: TestClient) -> None:
-    for url in ("/", "/mounts", "/mounts/new", "/rules", "/rules/new", "/log", "/settings"):
+    for url in (
+        "/",
+        "/mounts",
+        "/mounts/new",
+        "/keys",
+        "/rules",
+        "/rules/new",
+        "/log",
+        "/settings",
+    ):
        html = client.get(url).text
        assert "style=" not in html, url
        assert not re.search(r"<script(?![^>]*\bsrc=)", html), url
@@ -555,3 +564,60 @@ def test_export_excludes_secrets_and_import_roundtrip(
            files={"file": ("export.json", text, "application/json")},
        )
        assert "Übersprungen" in c2.get("/settings").text
+
+
+# -- Schlüsselverwaltung -------------------------------------------------------------------
+
+
+def test_keys_page_generate_import_select_delete(client: TestClient, state: NetMover) -> None:
+    from netmover.crypto import generate_ssh_keypair
+
+    r = post(client, "/keys/generate", {"name": "paperless-lxc"})
+    assert r.status_code == 303
+    private, public = generate_ssh_keypair()
+    r = post(client, "/keys/import", {"name": "alt", "private_key": private, "passphrase": ""})
+    assert r.status_code == 303
+    page = client.get("/keys").text
+    assert "paperless-lxc" in page and "alt" in page
+    assert public.split()[1] in page  # öffentlicher Teil sichtbar
+    for line in private.splitlines()[1:-1]:  # keine Zeile des privaten Schlüssels
+        assert line not in page
+    assert "restrict,command=&#34;/usr/lib/openssh/sftp-server&#34;" in page
+
+    with state.session_factory() as s:
+        key_id = s.scalar(select(Credential.id).where(Credential.name == "alt"))
+    form = client.get("/mounts/new").text
+    assert f'value="{key_id}"' in form and "neuer Schlüssel nur für diese Anbindung" in form
+
+    r = post(
+        client,
+        "/mounts/new",
+        {
+            "name": "paperless",
+            "type": "sftp",
+            "server": "10.0.0.5",
+            "share": "/consume",
+            "port": "22",
+            "auth": "ssh_key",
+            "key_id": str(key_id),
+            "username": "root",
+            "enabled": "on",
+        },
+    )
+    assert r.status_code == 303, r.text
+    mounts = client.get("/mounts").text
+    assert "gespeichertem Schlüssel" in mounts and "„alt“" in mounts
+    edit = client.get(f"/mounts/{_mount_id(state, 'paperless')}/edit").text
+    assert f'<option value="{key_id}" selected>' in edit and 'value="root"' in edit
+
+    post(client, f"/keys/{key_id}/delete")
+    assert "noch benutzt" in client.get("/keys").text
+    post(client, f"/mounts/{_mount_id(state, 'paperless')}/delete")
+    post(client, f"/keys/{key_id}/delete")
+    page = client.get("/keys").text
+    assert "gelöscht" in page and ">alt<" not in page
+
+
+def test_key_import_error_is_shown(client: TestClient) -> None:
+    post(client, "/keys/import", {"name": "x", "private_key": "kein schlüssel", "passphrase": ""})
+    assert "Kein lesbarer privater Schlüssel" in client.get("/keys").text
Author	SHA1	Message	Date
Florian WildeandClaude Opus 5.5	a7930c8721	chore(release): 0.2.1 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-10 23:53:07 +02:00
Florian WildeandClaude Opus 5.5	d06bbc6e53	fix(db): Migrationen ohne Fremdschlüsselprüfung und in einer Transaktion Migration 0002 scheiterte auf einer Datenbank mit verknüpften Daten (FOREIGN KEY constraint failed beim Neuaufbau von credentials) und hinterließ einen halben Zustand, weil SQLite-DDL nicht transaktional lief. Eigene Migrationsverbindung: foreign_keys=OFF, BEGIN IMMEDIATE, transactional_ddl, foreign_key_check vor dem Commit. Tests mit echten, verknüpften Daten und mit Abbruch mitten in der Migration. update.sh: beim Zurückstufen keinen Changelog-Auszug. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-10 23:51:15 +02:00
Florian WildeandClaude Opus 5.5	fef90fc059	chore(release): 0.2.0 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-10 23:43:40 +02:00
Florian WildeandClaude Opus 5.5	d46b1ba5c5	test: Wettlauf beim Lesen von /proc/<pid>/stat abfangen Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-10 23:43:40 +02:00
Florian WildeandClaude Opus 5.5	ce5bef8306	feat(deploy): netmover-update mit Sicherung, Changelog-Auszug und Healthcheck Installation als Git-Klon unter /opt/netmover/src; install.sh installiert git und das Update-Skript. Skripte mit shellcheck geprüft. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-10 23:43:40 +02:00
Florian WildeandClaude Opus 5.5	fb975f1eae	feat(web): Seite „Schlüssel“ und Schlüsselauswahl in der Anbindung Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-10 23:43:40 +02:00
Florian WildeandClaude Opus 5.5	686542ff6f	feat: Schlüsselverwaltung für SFTP-Anbindungen Gespeicherte SSH-Schlüssel (erzeugen oder importieren, auch mit Passphrase), von mehreren Anbindungen nutzbar; der Benutzername gehört zur Anbindung. Migration 0002: credentials.managed, mounts.username. Gespeicherte Schlüssel werden beim Löschen einer Anbindung nie mitgelöscht. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-10 23:43:40 +02:00
Florian WildeandClaude Opus 5.5	4369faf144	fix(sftp): nach erfolgreichem Test als erreichbar anzeigen Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-10 22:54:46 +02:00
Florian WildeandClaude Opus 5.5	0a317e2aa9	feat(mounts): Klartext-Hinweis bei mount error(95) – keine gemeinsame SMB-Version Aufgefallen beim echten Synology-NAS (Maximales SMB-Protokoll: SMB2). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-10 22:50:19 +02:00
Florian WildeandClaude Opus 5.5	2d2238ce4e	chore(release): 0.1.1 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-10 22:03:27 +02:00
Florian WildeandClaude Opus 5.5	4f9c5bdc1d	fix(mounts): bei Zeitüberschreitung ganze Prozessgruppe von mount beenden Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-10 21:56:18 +02:00
Florian WildeandClaude Opus 5.5	1bf0fae2fc	fix(mounts): gescheiterte Start-Wiederherstellung ebenfalls minütlich neu versuchen Bootet die VM schneller als das NAS (Stromausfall), käme die Freigabe sonst nie zurück. Ein Scheduler-Job prüft fällige Neuversuche jede Minute, auch für Anbindungen ohne Regel. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-10 21:51:58 +02:00
Florian WildeandClaude Opus 5.5	ea50eacc9d	docs: Unit-Härtung, Neuversuch und install.sh ohne debconf-Warnungen Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-10 21:50:06 +02:00
Florian WildeandClaude Opus 5.5	c836f58189	fix(mounts): nach gescheiterter Wiederherstellung minütlich neu versuchen Ein NAS-Neustart dauert länger als die drei Wiederherstellungsversuche. Von NetMover selbst ausgehängte Mounts mit auto_mount werden höchstens einmal pro Minute erneut eingehängt, mit Entwarnung per Webhook. Von außen ausgehängte bleiben unangetastet. Hinweistexte werden nicht mehr mitgeschwärzt. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-10 21:50:06 +02:00
Florian WildeandClaude Opus 5.5	8276ce2afb	fix(mover): Stabilität mit frischen Attributen (open + fstat) CIFS lieferte per stat() sekundenlang eine veraltete Größe einer noch wachsenden Datei; erst open() erzwingt frische Attribute. Gesperrte Dateien gelten als in Benutzung. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-10 21:50:06 +02:00
Florian WildeandClaude Opus 5.5	48a52c5290	fix(deploy): systemd-Unit ohne eigenen Mount-Namespace ProtectSystem/PrivateTmp/ProtectControlGroups erzeugen einen Namespace als slave; Mounts blieben dort gefangen (auf der Test-VM nachgewiesen) und verschwanden bei jedem Neustart. MountFlags=shared hilft nicht. Nur noch Härtungen ohne Namespace. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-10 21:50:06 +02:00