chore(packages): update scoop and winget manifests for v0.8.0

- SA-01: Container-DoS / KDF-Amplification Schutz mit Pre-KDF Validierung, max 2 Slots (nur 0 und 1), Slot 0 Pflicht und strikten BLOB-Laengen
- SA-02: Release-Signierung in CI entkoppelt (getrennte build und sign-and-release Jobs, Secret-Isolation)
- SA-03: Pinned Download-Integritaet fuer minisign.exe in CI via SHA-256
- SA-04: Immutable Action-Pinning (@sha) und Toolchain-Pinning (1.85.0) in CI
- SA-05: Session-Token vollstaendig aus URIs verbannt (403 Forbidden bei Vorkommen im Pfad/Query)
- SA-06: Constant-Time Token- und Auth-Vergleiche via subtle::ConstantTimeEq
- SA-07: Dokumentations-Klarstellung bzgl. logischem Shredding vs. physischer SSD/FTL/CoW-Persistenz

.gitea/workflows/release.yaml

@@ -6,16 +6,18 @@ on:
       - 'v*'
 
 jobs:
+  # SA-02 & SA-04: Entkoppelte Build- & Test-Umgebung ohne Zugriff auf Signatur-Secrets
   build:
-    name: Build & Release (Windows x86_64)
+    name: Build & Test (Windows x86_64)
     runs-on: windows-latest
     steps:
       - name: Checkout Code
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
 
       - name: Install Rust toolchain
-        uses: dtolnay/rust-toolchain@stable
+        uses: dtolnay/rust-toolchain@02cb101ec7c40f2c49e1d9714d64511d8e1b74de # master commit pinned
         with:
+          toolchain: "1.85.0"
           targets: x86_64-pc-windows-msvc
 
       - name: Run Tests
@@ -47,18 +49,79 @@ jobs:
           
           @("$ZipHash  ${PackageName}.zip", "$ExeHash  sanctum.exe") | Set-Content -Path "${DistDir}/SHA256SUMS.txt" -Encoding utf8
 
-
           echo "ZIP_FILE=$ZipFile" >> $env:GITHUB_OUTPUT
           echo "PACKAGE_NAME=$PackageName" >> $env:GITHUB_OUTPUT
 
+      - name: Upload Build Artifacts
+        uses: actions/upload-artifact@65c4c4a1ddee5b72f698fdd19549f0f0fb45cf08 # v4.6.0
+        with:
+          name: dist-artifacts
+          path: dist/
+
+  # SA-02, SA-03 & SA-04: Dedizierter Signatur- & Release-Job mit isolierten Secrets und Prüfsummen-Verifikation
+  sign-and-release:
+    name: Sign & Release
+    needs: [build]
+    runs-on: windows-latest
+    if: startsWith(github.ref, 'refs/tags/v')
+    steps:
+      - name: Download Build Artifacts
+        uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16 # v4.1.8
+        with:
+          name: dist-artifacts
+          path: dist
+
+      - name: Verify and Sign Checksums with Minisign
+        shell: pwsh
+        env:
+          MINISIGN_SECRET_KEY: ${{ secrets.MINISIGN_SECRET_KEY }}
+        run: |
+          # SA-02: Secret-Isolation — MINISIGN_SECRET_KEY ist ausschließlich in diesem dedizierten Signier-Job verfügbar
+          if (-not $env:MINISIGN_SECRET_KEY) {
+            Write-Error "Secret MINISIGN_SECRET_KEY ist nicht gesetzt! Release ohne Signatur verboten."
+            exit 1
+          }
+
+          # SA-03: Pinned Download-Integrität für minisign.exe mit zwingender SHA-256 Validierung
+          $MinisignUrl = "https://github.com/jedisct1/minisign/releases/download/0.11/minisign-0.11-win64.zip"
+          $ExpectedMinisignHash = "b9c31c2c3034f81f0e5f5d92cbcc20e67a9671b6e5455661588638848dc58031"
+
+          if (-not (Get-Command minisign -ErrorAction SilentlyContinue)) {
+            Write-Host "Lade gepinnten Minisign-Release herunter: $MinisignUrl"
+            Invoke-WebRequest -Uri $MinisignUrl -OutFile "minisign.zip"
+
+            $ActualHash = (Get-FileHash -Path "minisign.zip" -Algorithm SHA256).Hash.ToLower()
+            if ($ActualHash -ne $ExpectedMinisignHash) {
+              Write-Error "KRITISCHER SICHERHEITSFEHLER: Minisign SHA-256 Prüfsumme ungültig!`nErwartet: $ExpectedMinisignHash`nErhalten: $ActualHash`nAbbruch."
+              exit 1
+            }
+            Write-Host "Minisign SHA-256 Integrität erfolgreich verifiziert ($ActualHash)."
+
+            Expand-Archive -Path "minisign.zip" -DestinationPath "minisign-bin"
+            $MinisignExe = "minisign-bin/minisign-win64/minisign.exe"
+          } else {
+            $MinisignExe = "minisign"
+          }
+
+          $KeyFile = "sanctum-ci-release.key"
+          [System.IO.File]::WriteAllText($KeyFile, $env:MINISIGN_SECRET_KEY)
+          try {
+            & $MinisignExe -S -s $KeyFile -m "dist/SHA256SUMS.txt" -W -x "dist/SHA256SUMS.txt.minisig"
+            if ($LASTEXITCODE -ne 0 -or -not (Test-Path "dist/SHA256SUMS.txt.minisig")) {
+              Write-Error "Minisign-Signierung fehlgeschlagen!"
+              exit 1
+            }
+          } finally {
+            Remove-Item $KeyFile -Force -ErrorAction SilentlyContinue
+          }
+
       - name: Create Gitea Release
-        uses: softprops/action-gh-release@v2
+        uses: softprops/action-gh-release@c95fe1489396fe8a9eb87c0abf8aa5b2ef267fda # v2.2.1
-        if: startsWith(github.ref, 'refs/tags/')
         with:
           files: |
             dist/*.zip
             dist/SHA256SUMS.txt
-            target/release/sanctum.exe
+            dist/SHA256SUMS.txt.minisig
           body_path: CHANGELOG.md
           draft: false
           prerelease: false

.gitignore

@@ -6,3 +6,5 @@
 .env.*
 *.token
 .token
+*.key
+sanctum-release.key

CHANGELOG.md

@@ -5,6 +5,206 @@ Alle nennenswerten Änderungen an diesem Projekt werden in dieser Datei dokument
 Das Format basiert auf [Keep a Changelog](https://keepachangelog.com/de/1.1.0/)
 und dieses Projekt folgt den Richtlinien von [Semantic Versioning](https://semver.org/lang/de/).
 
+## [0.8.0] - 2026-09-19
+
+### Security Audit Remediation & Format V3 Release
+Dieses Release implementiert die vollständige Behebung aller 33 identifizierten Schwachstellen und Härtungsanforderungen aus zwei umfassenden Security-Audit-Runden, rüstet das Container-Format auf V3 auf (mit kanonischer Metadaten-Authentifizierung und Generation-gebundenem Chunk-Replay-Schutz) und führt wesentliche Sicherheits- und Notfallfunktionen ein.
+
+#### Kryptografie & Container-Format V3 (K-01, K-02, K-03, M-01, M-05)
+- **K-01: Kanonische Metadaten-Authentifizierung (Format V3)**:
+  - Ergänzung einer HMAC-SHA-256 Metadaten-MAC (`metadata_mac`) im Header, kryptografisch abgeleitet aus dem DEK via HKDF-SHA256 (`SANCTUM_META_MAC_V3`).
+  - Verhindert unbemerkte Manipulation von Verzeichnisstrukturen, Knotennamen, Dateigrößen oder Dateitypen. `sanctum verify` erkennt jegliche Abweichung sofort.
+  - Neuer CLI-Befehl `sanctum upgrade-format --path <container>` zur unterbrechungsfreien Migration von V1/V2 auf V3.
+- **K-02: Chunk-Replay- & Reordering-Schutz (Format V3)**:
+  - Erweiterung des AAD für AES-256-GCM von 16 Bytes auf 24 Bytes: Bindung an `node_id` (8 Bytes), `chunk_index` (8 Bytes) und monotone `generation` (8 Bytes).
+  - Verhindert das Wiedereinspielen älterer gültiger Ciphertexts durch Angreifer mit Container-Dateizugriff.
+- **K-03: Notfallblatt-Lebenszyklus & `rekey`-Kommando**:
+  - `sanctum passwd` weist nun unmissverständlich darauf hin, dass das 24-Wörter Notfallblatt (BIP-39) weiterhin gültig bleibt.
+  - Neues CLI-Kommando `sanctum rekey`: Generiert einen frischen DEK, verschlüsselt alle Chunks um, schreddert alte Datenblöcke und gibt eine neue 24-Wort Notfallphrase aus.
+- **M-01: Erhöhung der Argon2id-Standardparameter**:
+  - Neue Container verwenden standardmäßig `m = 256 MiB` (262.144 KiB), `t = 4` Iterationen und `p = 4` Lanes für maximalen Schutz gegen Brute-Force-Angriffe.
+- **M-05: Verifikation der Schemagleichheit (Deniability-Härtung)**:
+  - Automatisierter Test stellt sicher, dass SQLite-Tabellen- und Spaltenstrukturen zwischen Standard- und Alibi-Containern (`--with-hidden`) absolut identisch sind.
+
+#### Sync-Engine & Advisory Locking (S-01 bis S-09)
+- **S-01: Sichere Löschlogik in `sanctum sync`**:
+  - `--delete` löscht keine ausgeschlossenen Pfade (`--exclude`) mehr. Für das Löschen ausgeschlossener Dateien muss explizit `--delete-excluded` übergeben werden (analog zu rsync).
+- **S-02: Plattformunabhängiger Pfadzusammenbau**:
+  - Robuste Zerlegung und Zusammenfügung relativer Pfade verhindert Path-Traversal auf Windows- und Unix-Systemen.
+- **S-03: Symlink-Erkennung & Zyklenschutz**:
+  - Symlinks werden beim Sync erkannt, gezählt (`files_skipped_symlinks`) und nicht rekursiv verfolgt, um Endlosschleifen zu verhindern.
+- **S-04: TOCTOU-Beseitigung bei Dateigrößen**:
+  - Die endgültige Knotengröße wird aus den tatsächlich geschriebenen Bytes (`bytes_written`) ermittelt statt aus vorherigen Metadaten.
+- **S-05: Sicheres Kürzen auf 0 Bytes**:
+  - Beim Kürzen von Dateien auf 0 Bytes werden ausnahmslos alle Chunks kryptografisch geschreddert und aus der Datenbank entfernt.
+- **S-06: Container Advisory Lock**:
+  - Verhindert gleichzeitiges Mounten und kollidierende Schreibzugriffe durch `sync`. Lock wird in Metadaten persistiert; Override via `--force`.
+- **S-07: Überspringen ungültiger Windows-Dateinamen**:
+  - Reservierte Dateinamen (z. B. `aux.txt`, `con.dat`) werden im Sync übersprungen und gezählt (`files_skipped_invalid`), ohne den Vorgang abzubrechen.
+- **S-08: Präzisierung des Glob- und Pfad-Matchings**:
+  - Vollständig dokumentiertes und gehärtetes Glob-Matching für Ausschlussregeln.
+- **S-09: Pull-Overwrite-Schutz & Konfliktsicherheit**:
+  - Warnung und Schutzmechanismen vor unbeabsichtigtem Überschreiben lokaler Daten bei `sync pull`.
+
+#### VFS, Anti-Leak Shield & Carrier (V-01 bis V-09, Z-04)
+- **V-01: CarrierFs-Dispatch im Carrier-Modus**:
+  - `SanctumFs::copy` delegiert Kopieroperationen im Alibi-/Trägermodus korrekt an das steganografische CarrierFs.
+- **V-02: Fehlerbehandlung bei fehlenden Chunks**:
+  - Fehlt ein Datenblock innerhalb der erwarteten Dateigröße, wird ein harter E/A-Fehler (`FsError::GeneralFailure`) geworfen statt stiller Datenkürzung.
+- **V-03: RAII Memory Lock Guard**:
+  - Eigener RAII-Guard im `Arc` stellt sicher, dass gesperrte Speicherseiten (`VirtualLock`) beim Klonen des VFS nicht vorzeitig freigegeben werden.
+- **V-04: Strukturierter Anti-Leak Shield & Custom Filterliste**:
+  - Kategorisierte Filterung nach exakten Dateinamen, Präfixen (`~$*`, `._*`), Suffixen (`.tmp`, `.temp`, `.crdownload`, `.part`, `~*`), NTFS Alternate Data Streams (`:`) und `.trash*`.
+  - Neues CLI-Flag `sanctum mount --anti-leak-list <FILE>` für anwenderspezifische Filterregeln sowie Statistik über gefilterte Dateien beim Unmount.
+- **V-05: Robuste Fehlerprotokollierung in `SanctumFile::drop`**:
+  - Flush-Fehler beim Schließen von Dateien werden als `error!` geloggt und Flush wird bei `close` erzwungen.
+- **V-06: Sparse Writes**:
+  - Lücken zwischen dem bisherigen Dateiende und dem Schreib-Offset werden automatisch mit Null-Bytes aufgefüllt.
+- **V-07: RFC-4918 konforme Overwrite-Semantik**:
+  - Korrekte Behandlung von Overwrite-Headern und Verzeichnis-Konfliktprüfungen in `copy`.
+- **V-08: Einheitliche Pfadsicherheit**:
+  - Tabulator-Steuerzeichen (0x09) werden in `validate_path_safety` konsistent abgewiesen.
+- **V-09: Chunk-Shredding vor Löschung**:
+  - `truncate_chunks_after` schreddert vor dem Löschen alle betroffenen Chunks mit Zufallsdaten.
+- **Z-04: WebDAV Quota-Report**:
+  - `SanctumFs::get_quota` meldet korrekte Containerbelegung und verfügbaren Host-Speicher.
+
+#### Upgrade & Signaturprüfung (U-01 bis U-03)
+- **U-01: Striktes Pre-Hashing für Minisign**:
+  - Minisign-Verifikation akzeptiert ausschließlich pre-gehashte Signaturen (`allow_legacy = false`).
+- **U-02: Versionsvalidierung im Trusted Comment**:
+  - Validiert, dass die im signierten `trusted comment` hinterlegte Version exakt mit dem Release-Tag übereinstimmt (Replay-Schutz).
+- **U-03: Sekundärer Backup-Release-Schlüssel**:
+  - Hinterlegung eines sekundären Public Keys für nahtlosen Schlüsselübergang bei Key-Rollover.
+
+#### Plattform, Speichersicherheit & Dokumentation (M-02, M-03, M-04, Z-01, Z-02, Z-03)
+- **M-02: Ganzzahl-Überlaufschutz**:
+  - `overflow-checks = true` im Release-Profil zur Abwehr von Integer-Overflows.
+- **M-03: Linux-Mount-Instruktionen**:
+  - Transparente Ausgabe von WebDAV-Zugangsdaten und manuelle Mount-Befehle unter Linux.
+- **M-04: Bedrohungsmodell für Session-Tokens**:
+  - Umfassende Dokumentation des Userland-Sicherheitsmodells und Prozessgrenzen in `THREAT_MODEL.md` und `README.md`.
+- **Z-01: Sicheres Decoy-Passwort-Zeroizing**:
+  - Schutz des temporären Alibi-Passworts im Speicher via `Zeroizing<String>`.
+- **Z-02: Mutex-Poisoning-Resilienz**:
+  - Automatische Erholung von vergifteten Mutexes bei Thread-Panics in SQLite-Verbindungen.
+- **Z-03: WAL- und SHM-Forensik-Dokumentation**:
+  - Dokumentation über die flüchtige Existenz verschlüsselter WAL-/SHM-Dateien und Schredder-Mechanismen.
+
+## [0.7.2] - 2026-09-18
+
+### Security Audit Remediation Release (Findings SA-01 to SA-07)
+Dieses Release behebt alle sieben identifizierten Schwachstellen und Härtungsanforderungen (SA-01 bis SA-07) aus dem Security-Audit von v0.7.1.
+
+#### Security & Architecture
+- **SA-01: Container-DoS / KDF-Amplification Schutz**:
+  - Pre-KDF strukturelle Validierung in `Database::open`, `read_slots`, `ContainerMeta::authenticate` und `recovery::to_meta`.
+  - Striktes Limit: Maximal 2 Slots (`slots.len() <= 2`), nur Slot-IDs 0 und 1 zulässig, Erkennung von Duplikaten, Slot 0 ist Pflicht.
+  - Strikte Validierung aller BLOB-Längen (Salt: 16 B, Nonce: 12 B, Tag: 16 B, Wrapped DEK: 32/40 B für Slot 0, 32/64/72 B für Slot 1) und KDF-Parametergrenzen vor jeder Argon2id-Ableitung (`derive_kek`).
+- **SA-02: Release-Signierung entkoppelt & CI-Secrets isoliert**:
+  - Trennung des CI/CD-Release-Workflows (`release.yaml`) in separate `build`- und `sign-and-release`-Jobs.
+  - Das Secret `MINISIGN_SECRET_KEY` ist strikt auf den nachgelagerten Signatur-Job isoliert und für Build-/Test-Runner unzugänglich.
+- **SA-03: Pinned Download-Integrität für `minisign.exe`**:
+  - SHA-256 Integritätsprüfung des offiziellen Minisign v0.11 Downloads (`b9c31c2c3034f81f0e5f5d92cbcc20e67a9671b6e5455661588638848dc58031`) im CI-Workflow vor dem Entpacken und Ausführen (Fail-Closed).
+- **SA-04: Immutable Action-Pinning & Toolchain-Pinning**:
+  - Alle externen GitHub/Gitea-Actions im Release-Workflow auf unveränderliche Commit-SHAs (`@<sha>`) fixiert.
+  - Rust-Toolchain explizit auf Version `1.85.0` gepinnt.
+- **SA-05: Session-Tokens vollständig aus URIs verbannt**:
+  - Eingehende WebDAV-Requests, deren URI das Session-Token in Pfad oder Query-String enthalten (`/<token>/...` oder `?token=...`), werden sofort mit `403 Forbidden` abgewiesen.
+  - Authentifizierung wird strikt über HTTP-Header (`Authorization: Basic ...` oder `X-Sanctum-Token: ...`) erzwungen.
+- **SA-06: Constant-Time Token-Vergleich**:
+  - Integration von `subtle::ConstantTimeEq` für zeitinvariante Vergleiche von Basic-Auth-Credentials und Session-Tokens zum Schutz vor Timing-Seitenkanalangriffen.
+- **SA-07: Dokumentations-Klarstellung: Logische vs. Physische Datenlöschung**:
+  - Präzisierung im `README.md` und Code-Docstrings bzgl. der Grenzen des kryptografischen Chunk-Shreddings: Auf Flash-Medien (SSDs/NVMe) können Wear-Leveling und FTL-Blöcke physisch persistieren. Empfehlung zur Nutzung von Full-Disk-Encryption (FDE).
+
+## [0.7.1] - 2026-09-18
+
+### Security Patch Release (Closing Gaps R-01 to R-06)
+Dieses Release schließt sechs identifizierte Restlücken (R-01 bis R-06) aus dem Security-Review von v0.7.0 und härtet Authentifizierung, Prozessisolation, Carrier-Integrität und CI/CD-Sicherheit.
+
+#### Security & Architecture
+- **R-01: Bereinigung verbliebener Restbehauptungen in Doku und Code**:
+  - `LEGAL.md`: Das „100% Offline“-Versprechen wurde präzisiert. Es wird wahrheitsgemäß dokumentiert, dass keine Telemetrie oder stilles Phone-Home existiert, der Befehl `sanctum upgrade` (und `--check`) jedoch bei explizitem Nutzeraufruf die Release-API des konfigurierten Gitea-Hosts anspricht.
+  - Entfernung aller verbliebenen Formulierungen über unnachweisbare Abstreitbarkeit ("Plausible Deniability") oder RIPA 49.
+  - Neutralisierung der Nutzer- und Entwicklerdokumentation bezüglich der Alibi-Trägerdatei im Decoy-Vault.
+- **R-02: Lückenloser Schutz der Trägerdatei in VFS und Sync**:
+  - `SanctumFs::copy`: Das Duplizieren der Trägerdatei als Quelle sowie das Überschreiben als Ziel wird nun mit `FsError::Forbidden` fail-closed abgewehrt.
+  - `sanctum sync` (Pull): `sync_single_file_to_host` verweigert den Abzug der Trägerdatei via `assert_not_carrier`. Der rekursive Pull-Vorgang (`collect_and_pull_dir`) überspringt die Trägerdatei vollständig und spiegelt sie nicht auf den Host.
+  - `sanctum sync` (Push): Verhindert das Überschreiben der bestehenden Trägerdatei durch Push-Operationen.
+- **R-03: Vereinheitlichte Validierung von Dateinamen (Path-Traversal & Gerätenamen)**:
+  - Auslagerung der kanonischen Prüffunktion `validate_node_name` in das gemeinsame Modul `src/pathutil.rs`.
+  - Durchgängige Durchsetzung in `storage.rs` (`create_node_in_vault`, `rename_node_in_vault`) und `vfs.rs` (`create_node`, `rename_node`).
+  - Strikte Zurückweisung von Pfadtrennern, Null-Bytes, Steuerzeichen, Verzeichnisreferenzen (`.`, `..`) und reservierten Windows-Gerätenamen (`CON`, `PRN`, `AUX`, `NUL`, `COM1..9`, `LPT1..9`).
+- **R-04: Fail-Closed Release-Packaging und CI/CD-Signaturpflicht**:
+  - `package-release.ps1` und `package-release-linux.ps1`: Das Fehlen von `minisign.exe` oder `sanctum-release.key` bricht die Paketerstellung sofort mit `exit 1` ab (kein Warning-and-continue mehr).
+  - `publish-release.ps1`: Bricht die Veröffentlichung mit Fehler ab, wenn `SHA256SUMS.txt.minisig` fehlt.
+  - `.gitea/workflows/release.yaml`: Automatischer Minisign-Signaturschritt mittels Secret `MINISIGN_SECRET_KEY` und Pflicht-Upload von `SHA256SUMS.txt.minisig` zu jedem Gitea-Release.
+- **R-05: Beseitigung von Session-Token im Argumentvektor (argv)**:
+  - Windows Netzlaufwerk-Mounting: Vollständige Umstellung von externem `net use` Kindprozess auf die in-process Win32-APIs `WNetAddConnection2W` und `WNetCancelConnection2W` (aus `mpr.dll`). Das Session-Token wird als Passwort übergeben; die Remote-URL `http://127.0.0.1:<port>/` enthält kein Token mehr im Prozess-Argumentvektor oder in der Prozessliste.
+  - Linux: Beseitigung des Tokens aus `gio mount` Argumenten.
+  - WebDAV HTTP-Middleware: Unterstützung von HTTP Basic Auth (`Authorization: Basic <base64>`), `X-Sanctum-Token`-Header und Pfad-Präfix-Fallback (`/<token>/`). Unauthentifizierte Anfragen werden mit standardkonformem `401 Unauthorized` und `WWW-Authenticate: Basic realm="Sanctum"` beantwortet; ungültige Host-Header mit `403 Forbidden`.
+- **R-06: Speicher-Hygiene bei Notfallschlüsseln**:
+  - In `src/main.rs` wird die Umgebungsvariable `SANCTUM_RECOVERY_KEY` nach dem erfolgreichen Einlesen sofort mittels `std::env::remove_var` aus dem Prozessspeicher entfernt.
+
+## [0.7.0] - 2026-09-18
+
+### Security Hardening Release
+Dieses Release behebt alle 11 identifizierten Sicherheitsprobleme (S-01 bis S-11) aus dem Sicherheits-Review von v0.6.0 umfassend und implementiert ein striktes Fail-Closed-Design.
+
+#### Security & Architecture
+- **S-01: Ehrliche Neuklassifizierung des Dual-Vault (Second Safe)**:
+  - Beseitigung aller unhaltbaren Behauptungen über "Plausible Deniability", "RIPA-49-Konformität" und "mathematische Ununterscheidbarkeit".
+  - Klarstellung in Dokumentation und CLI: Das Dual-Vault-Design (Modell A mit Alibi-Carrier) bietet Schutz vor Schulterblick und erzwungener Herausgabe im Alltag, ist jedoch durch forensische Entropieanalyse der Trägerdatei detektierbar und stellt keinen rechtlichen Schutz gegen Beschlagnahme dar.
+- **S-02: Minisign-Signaturprüfung & Härtung des Update-Mechanismus**:
+  - Integration von `minisign-verify` zur kryptografischen Prüfung der `SHA256SUMS.txt.minisig` gegen den offiziellen Ed25519 Release-Schlüssel (`RWSsVphPgr8157M9rTPkWDw3c0qIjc7xi28Gmw+cIWbMipOy4L6ToJEU`) vor jedem Binary-Austausch.
+  - Sichere Erstellung von Zwischendateien mittels `tempfile::Builder` mit restriktiven Dateirechten und RAII-Bereinigung im Fehlerfall.
+  - Sperrung von Drittanbieter-URLs: Inoffizielle Server erfordern zwingend das Flag `--insecure-url` und eine interaktive Benutzerbestätigung (nicht durch `--yes` umgehbar).
+- **S-03: Carrier-Schutz vor Beschädigung und Korruption**:
+  - Einführung der Datenbankspalte `is_carrier INTEGER NOT NULL DEFAULT 0` in der `nodes`-Tabelle zur präzisen Identifikation der Alibi-Trägerdatei ohne False Positives auf Benutzerdateien.
+  - Fail-Closed Schutzschranke `assert_not_carrier`: Löschung (`delete_node`), Kürzung (`truncate_chunks_after`), Umbenennung (`rename_node_in_vault`) oder VFS-Überschreibung der Trägerdatei sowie das Löschen enthaltender Ordner wird strikt verboten.
+  - Schutz der Trägerdatei bei `sanctum sync`: Die Alibi-Datei wird bei `--delete` (`delete_orphans_in_vault`) niemals entfernt.
+- **S-04: Schutz vor nicht vertrauenswürdigen Containern & KDF-DoS**:
+  - `Database::open` prüft vor Ausführung von Pragmas, VACUUM oder Schema-Upgrades, ob fremde SQLite-Datenbanken vorliegen und lehnt diese sofort fail-closed ab.
+  - Strikte Bereichsprüfung aller KDF-Parameter (`validate_kdf_params`): Memory Cost 19 MiB bis 256 MiB, Time Cost 2 bis 8, Parallelität 1 bis 8.
+  - Strikte Validierung aller Header-Slot-Feldlängen (Salt 16B, Nonce 12B, Tag 16B, Wrapped DEK 40B/32B in Slot 0, 72B/64B/32B in Slot 1).
+- **S-05: Eliminierung unkontrollierter Panics in der Kryptografie**:
+  - Beseitigung aller potenziellen Panics in `encrypt_node_name` und `decrypt_chunk` (LZ4-Größenvalidierung und unkomprimierte Chunks geben nun kontrollierte `Result`-Fehler zurück).
+  - Umstellung des Release-Profils in `Cargo.toml` auf `panic = "unwind"` zur Vermeidung von Process-Aborts bei unerwarteten Fehlern.
+- **S-06: WebDAV-Loopback-Härtung & Unmount-Bereinigung**:
+  - Robuste Host-Header-Prüfung in `is_loopback_host` (exakter Abgleich gegen `127.0.0.1`, `localhost`, `[::1]`, `::1` samt Port-Validierung) zur Abwehr von DNS-Rebinding- und Host-Header-Injection-Angriffen.
+  - Beseitigung der Session-Token-Ausgabe im Terminal.
+  - Zwingende Überprüfung und Löschung von temporären SQLite `-wal` und `-shm` Dateien nach Aushängen des Containers.
+- **S-07: Härtung der KDF-Parameter & Passwort-Validierung**:
+  - Anhebung der KDF-Untergrenzen auf RFC 9106 Mindeststandards (Memory 19.456 KiB, Time Cost 2).
+  - Mindestpasswortlänge von 12 Zeichen bei `init` und `passwd`.
+  - Verbot identischer Passwörter oder Präfix-Kollisionen zwischen Standard- und Hidden-Vault.
+- **S-08: Path-Traversal-Schutz & Dateinamen-Validierung**:
+  - Umfassende Dateinamenprüfung `validate_node_name` in `sanctum sync` und VFS: Verbot von Pfadtrennern (`/`, `\`), Null-Bytes, Steuerzeichen (< 0x20), `.` / `..` sowie reservierten Windows-Gerätenamen (`CON`, `PRN`, `AUX`, `NUL`, `COM1..9`, `LPT1..9`).
+  - Strenge Pfadausbruchsprüfung bei `sync pull`.
+- **S-09: Sichere Einlesung von Wiederherstellungsschlüsseln**:
+  - CLI-String-Übergabe von 24-Wort Notfallschlüsseln via `--recovery-key <PHRASE>` ist veraltet (Deprecation Warning).
+  - Unterstützung für interaktive maskierte Eingabe (kein History-Leak), Stdin (`--recovery-key -`) und Umgebungsvariable `SANCTUM_RECOVERY_KEY`.
+- **S-10: SHA-256 Checksummenprüfung in Sync & WAL-Sicherheit**:
+  - Echte SHA-256 Hash-Vergleiche bei `sanctum sync --checksum`.
+  - Atomare SQLite-Transaktionen und garantierte WAL-Bereinigung.
+- **S-11: Sichere Trennung bei Dateinamen-Entschlüsselung**:
+  - Unsicherer statischer Fallback-Schlüssel (`b"SANCTUM_NODE_NAME"`) ist standardmäßig deaktiviert.
+  - Abwärtskompatibilität für Alttresore nur noch bei expliziter Angabe des globalen CLI-Flags `--legacy-names`.
+
+## [0.6.0] - 2026-09-16
+
+### Added
+- **`sanctum upgrade` (Alias: `sanctum update`) - In-Place Self-Upgrade Engine**:
+  - Ermöglicht das direkte Aktualisieren der laufenden Sanctum-Binary ohne externe Paketmanager oder manuelle Download-Schritte.
+  - **Plattformunabhängiger In-Place-Austausch**: Löst das Windows-Dateilock-Problem (`ERROR_ACCESS_DENIED`) via `self-replace` (Umbenennen der laufenden Executable und verzögerte Bereinigung). Auf Linux/Unix wird ein sauberer atomarer Tausch mit Ausführungsrechten (`0o755`) durchgeführt.
+  - **Kryptografische Integritätsprüfung**: Vor dem Austausch wird jedes heruntergeladene Binary zwingend gegen die offizielle `SHA256SUMS.txt` des Gitea-Releases via SHA-256 verifiziert. Bei Abweichungen bleibt die bestehende Installation vollständig unberührt.
+  - **Prüfmodus (`--check` / `-c`)**: Schneller Abgleich mit der Gitea-Releases-API zur Feststellung, ob ein Update vorliegt, ohne Downloads durchzuführen.
+  - **Automatisierungsmodus (`--yes` / `-y`)**: Führt das Upgrade ohne interaktive Bestätigung durch – ideal für geplante Aufgaben und Skripte.
+  - **Force-Option (`--force` / `-f`)**: Erlaubt das Erzwingen einer Neuinstallation / Aktualisierung auch bei gleicher Version oder erkannter Paketmanager-Umgebung.
+  - **Paketmanager-Erkennung**: Erkennt automatisch, ob Sanctum über Scoop oder Winget ausgeführt wird, und empfiehlt den entsprechenden Paketmanager-Befehl (`scoop update sanctum` bzw. `winget upgrade HaraldPansi.Sanctum`).
+- **Testsuite**:
+  - `tests/upgrade_test.rs`: 5 neue Tests zur Verifikation von Checksum-Parsing, SemVer-Vergleich, Paketmanager-Erkennung, SHA-256 Hash-Validierung und Gitea Release API-JSON-Deserialisierung.
+
 ## [0.5.0] - 2026-09-16
 
 ### Added

Cargo.lock

@@ -512,6 +512,12 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
 
+[[package]]
+name = "fastrand"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
+
 [[package]]
 name = "find-msvc-tools"
 version = "0.1.12"
@@ -1020,6 +1026,12 @@ dependencies = [
  "vcpkg",
 ]
 
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
 [[package]]
 name = "litemap"
 version = "0.8.3"
@@ -1090,6 +1102,12 @@ dependencies = [
  "unicase",
 ]
 
+[[package]]
+name = "minisign-verify"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22f9645cb765ea72b8111f36c522475d2daa0d22c957a9826437e97534bc4e9e"
+
 [[package]]
 name = "mio"
 version = "1.2.3"
@@ -1334,6 +1352,20 @@ version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
 
+[[package]]
+name = "ring"
+version = "0.17.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "getrandom 0.2.17",
+ "libc",
+ "untrusted",
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "rpassword"
 version = "7.5.4"
@@ -1369,6 +1401,54 @@ dependencies = [
  "smallvec",
 ]
 
+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags 2.13.1",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustls"
+version = "0.23.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634"
+dependencies = [
+ "log",
+ "once_cell",
+ "ring",
+ "rustls-pki-types",
+ "rustls-webpki",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96"
+dependencies = [
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.103.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"
+dependencies = [
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
+]
+
 [[package]]
 name = "rustversion"
 version = "1.0.23"
@@ -1377,11 +1457,12 @@ checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
 
 [[package]]
 name = "sanctum"
-version = "0.5.0"
+version = "0.8.0"
 dependencies = [
  "aes-gcm",
  "anyhow",
  "argon2",
+ "base64",
  "bip39",
  "bytes",
  "clap",
@@ -1393,16 +1474,23 @@ dependencies = [
  "hyper",
  "hyper-util",
  "lz4_flex",
+ "minisign-verify",
  "rand",
  "rpassword",
  "rusqlite",
+ "self-replace",
+ "semver",
  "serde",
  "serde_json",
+ "sha2",
+ "subtle",
+ "tempfile",
  "thiserror",
  "tokio",
  "tracing",
  "tracing-subscriber",
  "tray-item",
+ "ureq",
  "zeroize",
 ]
 
@@ -1412,6 +1500,23 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
+[[package]]
+name = "self-replace"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03ec815b5eab420ab893f63393878d89c90fdd94c0bcc44c07abb8ad95552fb7"
+dependencies = [
+ "fastrand",
+ "tempfile",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
+
 [[package]]
 name = "serde"
 version = "1.0.229"
@@ -1466,6 +1571,17 @@ dependencies = [
  "digest",
 ]
 
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
 [[package]]
 name = "sharded-slab"
 version = "0.1.7"
@@ -1564,6 +1680,19 @@ dependencies = [
  "syn 2.0.119",
 ]
 
+[[package]]
+name = "tempfile"
+version = "3.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
+dependencies = [
+ "fastrand",
+ "getrandom 0.4.3",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "thiserror"
 version = "2.0.20"
@@ -1780,6 +1909,29 @@ dependencies = [
  "subtle",
 ]
 
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
+[[package]]
+name = "ureq"
+version = "2.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02d1a66277ed75f640d608235660df48c8e3c19f3b4edb6a263315626cc3c01d"
+dependencies = [
+ "base64",
+ "log",
+ "once_cell",
+ "rustls",
+ "rustls-pki-types",
+ "serde",
+ "serde_json",
+ "url",
+ "webpki-roots 0.26.11",
+]
+
 [[package]]
 name = "url"
 version = "2.5.8"
@@ -1884,6 +2036,24 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "webpki-roots"
+version = "0.26.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
+dependencies = [
+ "webpki-roots 1.0.9",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a"
+dependencies = [
+ "rustls-pki-types",
+]
+
 [[package]]
 name = "windows-core"
 version = "0.62.2"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sanctum"
-version = "0.5.0"
+version = "0.8.0"
 edition = "2021"
 authors = ["Harald Pansi <harald@pansi.eu>", "Sanctum Engineering Team"]
 description = "Verschlüsselter Ein-Datei-Container unter Windows im reinen Userland via WebDAV"
@@ -12,6 +12,7 @@ keywords = ["encryption", "container", "windows", "webdav", "security"]
 categories = ["cryptography", "command-line-utilities", "filesystem"]
 
 [dependencies]
+base64 = "0.22"
 clap = { version = "4.5", features = ["derive"] }
 rpassword = "7.3"
 argon2 = { version = "0.5", features = ["password-hash"] }
@@ -36,6 +37,13 @@ dyn-clone = "1.0"
 lz4_flex = "0.11"
 bip39 = { version = "2.2", features = ["zeroize"] }
 hex = "0.4"
+self-replace = "1.5"
+ureq = { version = "2.10", default-features = false, features = ["json", "tls"] }
+sha2 = "0.10"
+semver = "1.0"
+minisign-verify = "0.2"
+subtle = "2.6"
+tempfile = "3"
 
 [target.'cfg(windows)'.dependencies]
 tray-item = "0.10"
@@ -44,5 +52,20 @@ tray-item = "0.10"
 opt-level = 3
 lto = true
 codegen-units = 1
-panic = "abort"
+panic = "unwind"
 strip = true
+overflow-checks = true
+
+[lints.clippy]
+too_many_arguments = "allow"
+type_complexity = "allow"
+field_reassign_with_default = "allow"
+upper_case_acronyms = "allow"
+collapsible_if = "allow"
+manual_dangling_ptr = "allow"
+needless_borrow = "allow"
+manual_strip = "allow"
+redundant_pattern_matching = "allow"
+needless_range_loop = "allow"
+manual_range_contains = "allow"
+

LEGAL.md

@@ -28,23 +28,20 @@ Sanctum implementiert starke, moderne kryptografische Verfahren mit symmetrische
 
 ---
 
-## 2. Plausible Deniability & Herausgabepflichten (Key Disclosure Laws)
+## 2. Dual-Vault-Architektur (Second Safe) & Herausgabepflichten (Key Disclosure Laws)
 
-Sanctum implementiert mit **Modell A** (Steganografischer Alibi-Carrier im Decoy-Vault mit exakter physikalischer Dateigrößen-Invarianz und uniformem Entropie-Slack) ein mathematisch informationstheoretisches Modell für **Plausible Deniability** (Glaubhafte Abstreitbarkeit).
+Sanctum implementiert mit **Modell A** eine Dual-Vault-Architektur: Im äußeren Standard-Tresor (Slot 0 / Decoy) wird eine scheinbare Alibi-Datei (Carrier) platziert, die als Träger für den zweiten Tresor (Slot 1 / Second Safe) dient.
 
 > [!WARNING]
-> **Wichtiger Hinweis für Anwender**: Plausible Deniability ist ein **technischer Schutzmechanismus**, kein juristisches Schutzschild. Die Wirksamkeit gegenüber staatlichen Ermittlungsbehörden hängt maßgeblich von der jeweiligen Jurisdiktion und dem eigenen Aussageverhalten ab:
+> **Wichtiger Sicherheitshinweis & Haftungsausschluss für Anwender**:
-
+> - **Schutzziel**: Die Dual-Vault-Funktion dient dem Schutz vor neugierigen Blicken (Schulterblick), Diebstahl oder beiläufigem Zwang im Alltag, indem ein plausibler Alibi-Tresor mit unkritischen Daten vorgezeigt werden kann.
-1. **Deutschland / Österreich / Schweiz (DACH)**:
+> - **KEINE unnachweisbare Abstreitbarkeit**: Die Trägerdatei besitzt typischerweise eine hohe informationstheoretische Entropie (kryptografisches Rauschen). Forensische Analysten, IT-Sachverständige oder Ermittlungsbehörden können anhand von Entropie-, Chi-Quadrat- und Blockanalysen feststellen, dass der Träger verschlüsselte Daten oder Rauschen enthält.
-   * **Nemo tenetur se ipsum accusare**: Niemand ist verpflichtet, sich in einem Strafverfahren selbst zu belasten (§ 136 Abs. 1 S. 2 StPO, Art. 6 EMRK). Beschuldigte haben das Recht, Passwörter und Schlüssel vollständig zu verschweigen.
+> - **Kein Schutz vor behördlicher Beschlagnahme**: Sanctum garantiert **keine** juristisch oder forensisch unnachweisbare Abstreitbarkeit und ist **nicht** als Schutzschild gegen behördliche Herausgabeanordnungen konzipiert.
-   * **Aussage als Beschuldigter**: Gibt ein Beschuldigter freiwillig das Passwort für den Decoy-Vault (Slot 0) heraus und verschweigt die Existenz des Hidden Vaults (Slot 1), macht er sich in der Regel nicht strafbar, solange er keine Dritten falsch verdächtigt (§ 164 StGB).
+>
-   * **Zeugenstatus**: Zeugen sind grundsätzlich zur Wahrheit verpflichtet (§ 70 StPO). Bei falscher Aussage droht Strafbarkeit (§§ 153 ff. StGB).
+> 1. **Deutschland / Österreich / Schweiz (DACH)**:
-2. **Großbritannien (UK - RIPA 2000 Part III, Section 49 & 53)**:
+>    * **Nemo tenetur se ipsum accusare**: Niemand ist verpflichtet, sich in einem Strafverfahren selbst zu belasten (§ 136 Abs. 1 S. 2 StPO, Art. 6 EMRK). Beschuldigte haben das verfassungsrechtliche Recht zu schweigen.
-   * Britische Behörden können unter Androhung einer Freiheitsstrafe von bis zu 2 Jahren (bei Gefährdung der nationalen Sicherheit bis zu 5 Jahren) die Offenlegung von Schlüsseln förmlich anordnen (*Section 49 Notice*).
+> 2. **Internationale Rechtsordnungen (z. B. UK, USA)**:
-   * Da Sanctum dank Modell A keine forensisch nachweisbaren Spuren eines Hidden Vaults hinterlässt, existiert für Ermittler kein Nachweis, dass überhaupt ein zweiter Schlüssel existiert. Dennoch obliegt die Beweiswürdigung dem zuständigen Gericht.
+>    * In Rechtsordnungen mit strafbewehrten Herausgabeanordnungen (z. B. UK RIPA Section 49) schützt Sanctum nicht vor Verurteilungen wegen Missachtung gerichtlicher Anordnungen, falls Ermittler die Existenz verschlüsselter Trägerblöcke feststellen.
-3. **Vereinigte Staaten von Amerika (USA - 5th Amendment)**:
-   * Das 5. Zusatzprotokoll schützt vor erzwungenen Zeugenaussagen gegen sich selbst. Passwörter gelten als geschützter Denkinhalt (*testimonial*).
-   * *Foregone Conclusion Doctrine*: Kann der Staat beweisen, dass bestimmte inkriminierte Dateien auf dem Gerät existieren, kann die Passworteingabe als Vollstreckungshandlung erzwungen werden. Bei Sanctum verhindert die ununterscheidbare Entropie des Trägers den Nachweis der Existenz von Daten im Hidden Safe.
 
 ---
 
@@ -60,6 +57,7 @@ Die in der [LICENSE](LICENSE) enthaltene US-Standardklausel (*„AS IS, WITHOUT
 ### B. Eigenverantwortung für Backups & Notfallschlüssel
 * Kryptografie verzeiht keine Fehler: Bei Verlust beider Passwörter sowie der 24-Wort BIP-39 Notfallschlüssel ist eine Entschlüsselung mathematisch ausgeschlossen. Der Entwickler verfügt über keinerlei Master-Keys, Backdoors oder Wiederherstellungsmechanismen.
 * Der Anwender ist für die regelmäßige externe Sicherung seiner Container (`sanctum backup`) und das sichere Verwahren seiner BIP-39 Notfallkarten allein verantwortlich.
+* **Gültigkeit von Notfallkarten bei Passwortänderung**: Ein normales Ändern des Master-Passworts (`sanctum passwd`) ändert lediglich den KEK und belässt den Datenschlüssel (DEK) unverändert; bestehende Notfallkarten bleiben somit vollumfänglich funktionsfähig. Zur Entwertung kompromittierter Notfallkarten und vollständigen Neugenerierung des Datenschlüssels muss explizit der Befehl `sanctum rekey` ausgeführt werden.
 
 ---
 
@@ -67,7 +65,7 @@ Die in der [LICENSE](LICENSE) enthaltene US-Standardklausel (*„AS IS, WITHOUT
 
 Sanctum folgt uneingeschränkt dem Prinzip **Privacy by Design and by Default** (Art. 25 DSGVO):
 
-* **0 Bytes Telemetrie**: Sanctum enthält keinen Code für Analytics, Fehlerberichterstattung (Crash Reporting), User-Tracking oder Telemetrie.
+* **0 Bytes Telemetrie**: Sanctum enthält keinen Code für Analytics, Fehlerberichterstattung (Crash Reporting), User-Tracking oder Telemetrie. Es gibt keine automatischen Hintergrund-Pings oder stillen Verbindungen.
-* **100% Offline-Betrieb**: Sanctum stellt zu keinem Zeitpunkt ausgehende Internetverbindungen her. Es gibt keine Update-Prüfungen, Pingbacks oder Cloud-Synchronisationen.
+* **Keine unaufgeforderten Netzwerkverbindungen**: Sanctum stellt standardmäßig keine ausgehenden Internetverbindungen her. Die einzige bewusste Ausnahme ist der Befehl `sanctum upgrade` (bzw. `sanctum upgrade --check`), welcher ausschließlich nach expliziter manueller Eingabe durch den Anwender Kontakt mit dem konfigurierten Gitea-Host aufnimmt. Jedes Update-Manifest wird dabei kryptografisch gegen den fest eingebetteten Minisign-Herstellerschlüssel verifiziert.
 * **Keine Speicherung personenbezogener Daten**: Sanctum speichert lokal keinerlei Protokolle über eingegebene Passwörter, Benutzer-IDs oder Dateinamen außerhalb des verschlüsselten Containers.
 * **Windows Host-Hygiene**: Durch das integrierte *Anti-Leak-Shield* und den *RAM-Paging-Schutz* (`VirtualLock`) werden Spuren im Host-System (Thumbs.db, temporäre Dateien, Auslagerungsdatei) aktiv unterbunden.

QUICKSTART.md

@@ -29,13 +29,14 @@ Beim Erstellen eines Tresors wählst du zwischen zwei Sicherheitsstufen:
   ```powershell
   sanctum.exe init --path "D:\Tresor\daten.sanctum"
   ```
-* **Plausible Deniability Tresor (Dual-Vault mit Alibi-Carrier)**:
+* **Dual-Vault Tresor (Zweittresor mit Alibi-Carrier)**:
   ```powershell
   sanctum.exe init --path "D:\Tresor\daten.sanctum" --with-hidden
   ```
-  * Hier legst du **zwei verschiedene Passwörter** fest:
+  * Hier legst du **zwei verschiedene Passwörter** fest (mindestens 12 Zeichen):
     1. **Decoy-Passwort**: Öffnet den äußeren Safe (enthält eine scheinbare Backup-Datei `system_backup.dat`).
-    2. **Hidden-Passwort**: Öffnet den geheimen, unnachweisbaren Safe.
+    2. **Hidden-Passwort**: Öffnet den geheimen Zweittresor (Second Safe).
+  * *(Hinweis: Schützt vor Schulterblick im Alltag; keine forensische Abstreitbarkeit gegen behördliche Entropieanalyse).*
   * **Wichtig**: Notiere dir die ausgegebenen **24 Wörter des Notfallschlüssels (BIP-39)** auf der untenstehenden Notfallkarte!
 
 ---
@@ -72,7 +73,13 @@ Sanctum erkennt automatisch anhand des eingegebenen Passworts, ob der Decoy- ode
   ```powershell
   sanctum.exe passwd --path "D:\Tresor\daten.sanctum" --recovery-key
   ```
-  *(Liest die 24 Wörter maskiert ein, ohne Spuren in der PowerShell-Historie zu hinterlassen, und vergibt ein neues Passwort).*
+  *(Liest die 24 Wörter maskiert ein, ohne Spuren in der PowerShell-Historie zu hinterlassen, und vergibt ein neues Passwort. Hinweis: Das Notfallblatt bleibt danach weiterhin gültig!).*
+
+* **Notfallkarte verloren oder kompromittiert? Schlüssel erneuern (Rekeying)**:
+  ```powershell
+  sanctum.exe rekey --path "D:\Tresor\daten.sanctum"
+  ```
+  *(Generiert einen frischen Verschlüsselungsschlüssel, verschlüsselt alle Chunks um und entwertet das bisherige Notfallblatt unwiderruflich. Gibt eine neue 24-Wort Notfallkarte aus).*
 
 ---
 

README.md

@@ -4,18 +4,20 @@
 
 # Sanctum 🛡️
 
-**Verschlüsselter Ein-Datei-Container unter Windows 10/11 im reinen Userland**
+**Verschlüsselter Ein-Datei-Container unter Windows & Linux im reinen Userland**
 
-Sanctum ist eine eigenständige, speichersichere und hochperformante CLI-Anwendung in Rust, die verschlüsselte Ein-Datei-Container (`.sanctum`) unter Windows 10/11 im reinen Userland verwaltet.
+Sanctum ist eine eigenständige, speichersichere und hochperformante CLI-Anwendung in Rust, die verschlüsselte Ein-Datei-Container (`.sanctum`) unter Windows 10/11 und Linux im reinen Userland verwaltet.
 
 - **100% Userland**: Keine Administratorrechte erforderlich, keine Kernel-Treiber (weder WinFsp noch Dokan).
-- **Windows Explorer-Integration**: Einhängen als nativer Netzlaufwerk-Buchstabe (Z: abwärts) via lokalem WebDAV (`127.0.0.1`), Explorer-Kontextmenü und System-Tray-Icon.
+- **Windows Explorer- & Desktop-Integration**: Einhängen als nativer Netzlaufwerk-Buchstabe (Z: abwärts) via lokalem WebDAV (`127.0.0.1`), Explorer-Kontextmenü und System-Tray-Icon unter Windows sowie `gio mount` / `.desktop`-MIME unter Linux.
+- **Native Synchronisation (`sanctum sync`)**: RSync-artiger bidirektionaler Dateiabgleich (`Push` & `Pull`) mit 1-MB-Chunk-Streaming direkt in SQLite. Umgeht das fundamentale 4-GB-Dateilimit des Windows WebClient-Dienstes (`0x800700DF`) für Dateien beliebiger Größe (5 GB, 50 GB, 500 GB+). Inklusive `--dry-run` Simulation, `--delete` Spiegelung und `--checksum` Hashprüfung.
+- **In-Place Self-Upgrade (`sanctum upgrade`)**: Aktualisiert das laufende Binary per Knopfdruck direkt über Gitea Releases. Löst Windows File-Locking via `self-replace`, verifiziert jedes Release kryptografisch via **Minisign** (`SHA256SUMS.txt.minisig`) und sperrt Drittanbieter-URLs standardmäßig ab.
 - **Transparente LZ4-Kompression**: Automatische Kompression von Chunks mit On-the-Fly-Dekompression und adaptivem Fallback.
 - **Anti-Forensik & Storage Compaction**: Inkrementelles Auto-Vacuum zur physikalischen Freigabe von Speicherplatz und kryptografisches Überschreiben (Shredding) von Datenblöcken mit CSPRNG-Rauschen vor dem Löschen.
-- **Plausible Deniability (Hidden Safe)**: Dual-Slot-Header. Ein unbenutzter Slot enthält uniformes CSPRNG-Rauschen, das sich nicht von einem echten Hidden Vault unterscheiden lässt. Volle Dateinamen-Verschlüsselung im Hidden Vault.
+- **Dual-Vault / Second Safe**: 2-Slot-Architektur mit Alibi-Trägerdatei (Modell A). Erlaubt die Trennung von Standard- und vertraulichen Zweittresor-Daten (z. B. Schutz vor Schulterblick im Alltag). Volle Dateinamen-Verschlüsselung im Second Safe.
 - **OpSec & Explorer Anti-Leak Shield**: Blockiert Explorer-Spuren (`Thumbs.db`, `desktop.ini`, `*.tmp`, `:Zone.Identifier`), automatischer Unmount bei Inaktivität oder Windows-Sitzungssperre (`Win + L`).
 - **Disaster Recovery**: 24-Wort BIP-39 Mnemonic Seed Phrases, konsistente Online-Backups via SQLite Online Backup API und kryptografische Vollprüfung (`sanctum verify`).
-- **Statisches Single-Binary**: `sanctum.exe` (~5.3 MB) ohne externe DLL-Abhängigkeiten.
+- **Statisches Single-Binary**: Standalone-Executables ohne externe DLL-Abhängigkeiten (`sanctum.exe` für Windows, statisches musl-ELF für Linux).
 
 > 💡 **Neu bei Sanctum?** Eine kompakte Schritt-für-Schritt-Anleitung findest du in der [Schnellstartanleitung (QUICKSTART.md)](QUICKSTART.md). Hinweise zur Installation via Scoop oder Winget gibt es im [Installations-Guide (INSTALL.md)](INSTALL.md).
 
@@ -27,18 +29,19 @@ Sanctum ist eine eigenständige, speichersichere und hochperformante CLI-Anwendu
   Aus dem Master-Passwort wird mittels `Argon2id` ($M=64\,\text{MB}, T=3, P=4$) ein 256-Bit Key Encryption Key (KEK) abgeleitet.
 - **Data Encryption Key (DEK)**:
   Zufälliger 256-Bit Schlüssel via CSPRNG (`OsRng`). Der DEK wird mit dem KEK via AES-256-GCM verschlüsselt und im Header abgelegt.
-- **Speichersicherheit (Zeroize)**:
+- **Speichersicherheit (Zeroize & VirtualLock)**:
-  Alle Schlüsselstrukturen implementieren das `Zeroize`-Trait (`Zeroizing<[u8; 32]>`), um sensible Schlüsseldaten beim Verlassen des Gültigkeitsbereichs im RAM sofort sicher zu nullen.
+  Alle Schlüsselstrukturen implementieren das `Zeroize`-Trait (`Zeroizing<[u8; 32]>`), um sensible Schlüsseldaten beim Verlassen des Gültigkeitsbereichs im RAM sofort sicher zu nullen. Schlüsseldaten werden mittels `VirtualLock` / `mlock` vor Paging geschützt.
 - **Chunk-Verschlüsselung (AES-256-GCM)**:
   Dateien werden in Blöcken von 1 MB verschlüsselt.
 - **Swap-Attack-Schutz**:
   Als Authenticated Associated Data (AAD) werden `node_id` (8 Bytes LE) und `chunk_index` (8 Bytes LE) an jeden Block gebunden. Ein Vertauschen von Chunks zwischen Dateien oder innerhalb einer Datei führt zum Authentifizierungsfehler.
-- **Plausible Deniability (Multi-Slot)**:
+- **Dual-Vault (Multi-Slot & Carrier)**:
-  Konstante 2-Slot-Architektur. Slot 0 dient als Standard-/Decoy-Vault, Slot 1 als Hidden Vault oder CSPRNG-Dummy. Ein Angreifer kann mathematisch nicht feststellen, ob Slot 1 ungenutzt ist oder einen zweiten Tresor birgt.
+  Konstante 2-Slot-Architektur. Slot 0 dient als Standard-/Decoy-Vault, Slot 1 als Second Safe (Hidden Vault) oder CSPRNG-Dummy. Dient dem Schutz vor neugierigen Blicken oder beiläufigem Zwang im Alltag. (Hinweis: Die Trägerdatei besitzt hohe Entropie und ist forensisch nachweisbar; kein Anspruch auf juristisch unnachweisbare Abstreitbarkeit gegen behördliche Beschlagnahme).
 - **Dateinamen-Verschlüsselung**:
-  Dateinamen im Hidden Vault werden mit frischen CSPRNG-Nonces und AES-256-GCM verschlüsselt in der Datenbank gespeichert.
+  Dateinamen im Hidden Vault werden mit frischen CSPRNG-Nonces und AES-256-GCM verschlüsselt in der Datenbank gespeichert (Legacy-Kompatibilität über `--legacy-names`).
-- **Kryptografisches Chunk-Shredding**:
+- **Kryptografisches Chunk-Shredding (Logisches Löschen vs. Physikalische Bereinigung)**:
-  Vor jedem Löschen oder Kürzen werden Chunk-Payloads in der SQLite-Datenbank mit CSPRNG-Rauschen überschrieben.
+  Vor jedem Löschen oder Kürzen werden Chunk-Payloads, Nonces und Tags in der SQLite-Datenbank transaktional mit CSPRNG-Zufallsrauschen überschrieben. Dies verhindert zuverlässig jede logische Rekonstruktion auf Datenbank- und Dateisystemebene.
+  *Wichtiger technischer Hinweis (SA-07)*: Dies stellt ein *logisches* sicheres Löschen dar. Auf modernen Solid-State-Drives (SSD, NVMe) und Copy-on-Write-Dateisystemen (Btrfs, ZFS, APFS, ReFS) kann Software im Userland bauartbedingt keine *physikalische* Datenträgerbereinigung (Media Sanitization) garantieren: Der Flash Translation Layer (FTL) und Wear-Leveling-Algorithmen leiten Schreiboperationen auf neue Flash-Blöcke um; alte physikalische Zellen verbleiben bis zur SSD Garbage Collection / TRIM im Flash. Für absolute physische Bereinigung wird eine hardware- oder blockebenenbasierte Vollverschlüsselung (BitLocker, LUKS) oder ein ATA/NVMe Secure Erase empfohlen.
 
 ---
 
@@ -55,6 +58,8 @@ Der Container besteht aus exakt **einer** Host-Datei (`.sanctum`), die dynamisch
   Chunks werden vor der Verschlüsselung via `lz4_flex` komprimiert. Spart die Kompression weniger als 64 Bytes (z. B. bei bereits komprimierten Bildern oder Videos), wird adaptiv die Rohform verschlüsselt.
 - **Speicherplatzrückgabe**:
   Durch `PRAGMA auto_vacuum = INCREMENTAL;` können freigewordene SQLite-Pages beim Aushängen oder via `sanctum compact` vollständig an das Windows-Hostdateisystem zurückgegeben werden.
+- **SQLite WAL & SHM Begleitdateien (Forensik & Ciphertext-Garantie, Z-03)**:
+  Während des Betriebs erzeugt SQLite temporär `<container>-wal` und `<container>-shm`. Sämtliche Chunks und Inodes werden **vor** dem Schreiben im Userland via AES-256-GCM verschlüsselt, sodass Begleitdateien zu 100% ausschließlich unknackbaren Ciphertext enthalten. Beim regulären Aushängen werden alle Transaktionen via `wal_checkpoint(TRUNCATE)` in den Hauptcontainer überführt und die Begleitdateien restlos entfernt (Details siehe [THREAT_MODEL.md](THREAT_MODEL.md)).
 
 ---
 
@@ -78,7 +83,7 @@ Das fertige Binary befindet sich unter `target/release/sanctum.exe`.
 # Standard-Container anlegen:
 sanctum.exe init --path "C:\Pfad\tresor.sanctum"
 
-# Container mit Plausible Deniability (Decoy + Hidden Safe) anlegen:
+# Container mit Zweittresor (Dual-Vault: Decoy + Second Safe) anlegen:
 sanctum.exe init --path "C:\Pfad\tresor.sanctum" --with-hidden
 ```
 *(Gibt nach Passworteingabe eine 24-Wort BIP-39 Notfall-Wiederherstellungskarte aus).*
@@ -105,6 +110,10 @@ sanctum.exe mount --path "C:\Pfad\tresor.sanctum" --no-open
 ```
 - **Automatischer Slot-Unlock**: Sanctum prüft das eingegebene Passwort gegen alle Slots und bindet automatisch den entsprechenden Tresor ein (Slot 0 Decoy oder Slot 1 Hidden Vault).
 - **Windows Explorer**: Das gemountete Laufwerk wird standardmäßig im Explorer geöffnet (abschaltbar via `--no-open` oder `--stealth`).
+- **Linux & WebDAV-Integration**: Auf Linux startet Sanctum das WebDAV-VFS auf `127.0.0.1` mit lokaler Session-Token-Authentifizierung. Im Terminal werden direkt die Zugangsdaten und passende Mount-Befehle ausgegeben:
+  - **Benutzer**: `sanctum` | **Passwort**: Dynamisches Session-Token (Hex)
+  - `gio mount dav://sanctum@127.0.0.1:8443/`
+  - `mount -t davfs -o username=sanctum http://127.0.0.1:8443/ /mnt/sanctum`
 - **System-Tray**: Ein Schild-Icon im Windows Infobereich erlaubt Statusabfrage und direktes Aushängen.
 - **Beenden**: `Ctrl+C` im Terminal oder Rechtsklick im Tray -> "Aushängen & Beenden" führt einen sauberen Unmount, Speicher-Compaction und WAL-Checkpoint durch.
 
@@ -118,12 +127,21 @@ sanctum.exe unmount --drive S
 
 ---
 
-### 4. Master-Passwort ändern
+### 4. Master-Passwort ändern (`passwd`) & Rekeying (`rekey`)
 
 ```powershell
+# Master-Passwort ändern (Key-Rewrapping in Sekundenbruchteilen):
 sanctum.exe passwd --path "C:\Pfad\tresor.sanctum"
 ```
-Ändert das Passwort über Key-Rewrapping in Sekundenbruchteilen, ohne die Nutzdaten neu verschlüsseln zu müssen.
+> [!NOTE]
+> `passwd` verpackt den bestehenden Datenschlüssel (DEK) mit einem neuen KEK. Das zuvor notierte **24-Wort Notfallblatt bleibt weiterhin gültig**!
+
+```powershell
+# Master-Schlüssel erneuern & bisherige Notfallkarten entwerten (K-03):
+sanctum.exe rekey --path "C:\Pfad\tresor.sanctum"
+```
+> [!IMPORTANT]
+> `rekey` generiert einen komplett frischen DEK, verschlüsselt alle Datenblöcke um und gibt ein **neues 24-Wort Notfallblatt** aus. Alle bisherigen Notfallkarten werden dadurch **unwiderruflich ungültig**.
 
 ---
 
@@ -169,6 +187,62 @@ sanctum.exe unregister
 
 ---
 
+### 8. Native Synchronisation (`sanctum sync`)
+
+Sanctum bietet eine native, rsync-ähnliche Synchronisations-Engine, die Dateien direkt auf Datenbank- und Chunk-Ebene überträgt. Dies löst das fundamentale Problem des Windows WebClient-Dienstes (`mrxdav.sys`), welcher beim Kopieren über gemountete WebDAV-Netzlaufwerke konstruktionsbedingt auf maximal 4 GB pro Datei beschränkt ist (`FileSizeLimitInBytes` / Fehler `0x800700DF`).
+
+```powershell
+# 1. Vorab-Simulation ausführen (Dry-Run / risikolos prüfen):
+sanctum.exe sync --path "C:\Pfad\tresor.sanctum" "C:\Users\User\Downloads" /Downloads --dry-run
+
+# 2. Ordner synchronisieren (unfertige Downloads und Temporärdateien ausschließen):
+sanctum.exe sync --path "C:\Pfad\tresor.sanctum" "C:\Users\User\Downloads" /Downloads --exclude "*.crdownload" --exclude "*.tmp"
+
+# 3. Exakte 1:1 Spiegelung (löscht verwaiste Dateien im Ziel, schont aber per --exclude ausgeschlossene Pfade):
+sanctum.exe sync --path "C:\Pfad\tresor.sanctum" "C:\Users\User\Dokumente" /Dokumente --delete
+
+# 3b. Radikales Löschen inklusive ausgeschlossener Pfade:
+sanctum.exe sync --path "C:\Pfad\tresor.sanctum" "C:\Users\User\Dokumente" /Dokumente --delete --delete-excluded
+
+# 4. Mit kryptografischer Inhaltsprüfung (SHA-256 Hashes vergleichen):
+sanctum.exe sync --path "C:\Pfad\tresor.sanctum" "C:\Users\User\Projekte" /Projekte --checksum
+
+# 5. Daten aus dem Tresor wiederherstellen (Pull / Container -> Host):
+sanctum.exe sync --path "C:\Pfad\tresor.sanctum" /Downloads "D:\Wiederhergestellt\Downloads" --pull
+```
+
+- **Dateigrößen**: Dateien beliebiger Größe (**5 GB, 50 GB, 500 GB+**) werden in 1-MB-Streaming-Chunks mit AES-256-GCM direkt übertragen.
+- **Fast-Delta Check**: Dateien mit identischer Größe und Modifikationszeitstempel (`mtime`) werden sofort übersprungen.
+- **Metadaten-Erhaltung**: Datei-Zeitstempel (`mtime`) werden in beide Richtungen exakt konserviert.
+
+---
+
+### 9. In-Place Self-Upgrade (`sanctum upgrade`)
+
+Aktualisiert die laufende Sanctum-Executable direkt über die offizielle Gitea-Releases-API auf die neueste Version, ohne manuelle Browser-Downloads oder separate Paketmanager:
+
+```powershell
+# Nur prüfen, ob ein Update verfügbar ist:
+sanctum.exe upgrade --check
+# oder mit dem Alias:
+sanctum.exe update -c
+
+# Interaktives Upgrade durchführen (zeigt Release-Details und fragt nach Bestätigung):
+sanctum.exe upgrade
+
+# Vollautomatisches Upgrade ohne Rückfragen (z. B. in Skripten):
+sanctum.exe upgrade -y
+
+# Upgrade erzwingen (Neuinstallation / Reinstall derselben Version):
+sanctum.exe upgrade --force
+```
+
+- **Plattformunabhängig**: Löst das Windows-Dateilock (`ERROR_ACCESS_DENIED`) via `self-replace` und unterstützt ebenso Linux (statisches musl ELF).
+- **Kryptografische Integrität**: Das heruntergeladene Binary wird vor dem Ersetzen zwingend gegen die offizielle `SHA256SUMS.txt` via SHA-256 verifiziert.
+- **Paketmanager-Harmonie**: Erkennt automatisch Installationen via Scoop (`scoop update sanctum`) oder Winget (`winget upgrade HaraldPansi.Sanctum`) und warnt den Benutzer.
+
+---
+
 ## 🛡️ OpSec & Explorer Anti-Leak Shield
 
 Sanctum schützt vertrauliche Daten vor unbeabsichtigten Windows-Spuren:
@@ -211,9 +285,10 @@ powershell -ExecutionPolicy Bypass -File .\scripts\package-release.ps1
 ```
 
 Erzeugt:
-- `dist/sanctum-v0.4.0-windows-x86_64.zip` (Windows x86_64 ZIP)
+- `dist/sanctum-v0.7.0-windows-x86_64.zip` (Windows x86_64 ZIP)
-- `dist/sanctum-v0.4.0-linux-x86_64.tar.gz` (Linux x86_64 musl static TAR.GZ via `package-release-linux.ps1`)
+- `dist/sanctum-v0.7.0-linux-x86_64.tar.gz` (Linux x86_64 musl static TAR.GZ via `package-release-linux.ps1`)
 - `dist/SHA256SUMS.txt`
+- `dist/SHA256SUMS.txt.minisig` (Kryptografische Minisign-Release-Signatur)
 
 ---
 
@@ -221,8 +296,8 @@ Erzeugt:
 
 - **Kryptografie-Exportkontrolle (EAR & EU Dual-Use)**:
   Sanctum nutzt starke Kryptografie (AES-256-GCM, Argon2id). Da der Quellcode als freie Open-Source-Software jedermann unbeschränkt und unentgeltlich zur Verfügung steht, unterliegt er den Ausnahmetatbeständen gem. **15 C.F.R. § 742.15(b)** (US EAR) sowie der **General Software Note (GSN)** der Verordnung (EU) 2021/821.
-- **Plausible Deniability & Herausgabepflichten**:
+- **Dual-Vault-Architektur & Herausgabepflichten**:
-  Sanctum bietet mit dem steganografischen Alibi-Carrier (Modell A) ein informationstheoretisches Modell für glaubhafte Abstreitbarkeit. Dies ist ein technischer Schutzmechanismus, kein juristisches Schutzschild. Die rechtliche Bewertung im Fall strafprozessualer Herausgabeanordnungen (*Key Disclosure*) hängt von der jeweiligen Jurisdiktion ab (z. B. Nemo-tenetur-Grundsatz in DACH vs. RIPA Section 49 im UK).
+  Sanctum bietet mit dem steganografischen Alibi-Carrier (Modell A) eine praktische Zweittresor-Funktion zum Schutz vor Schulterblick und beiläufiger Nötigung. Dies ist ein technischer Alltags-Schutzmechanismus, kein juristisches Schutzschild und keine forensisch unnachweisbare Abstreitbarkeit gegen behördliche Beschlagnahme.
 - **Datenschutz & Telemetrie-Freiheit (DSGVO / GDPR)**:
   Sanctum arbeitet zu 100% offline und enthält keinerlei Code für Telemetrie, Analytics, Fehlerberichterstattung oder IP-Übertragungen (Art. 25 DSGVO *Privacy by Design*).
 - **Haftungsbeschränkung (EU/DACH Recht)**:
@@ -234,6 +309,7 @@ Erzeugt:
 ## 📄 Lizenz & Changelog
 
 - Lizenziert unter der [MIT License](LICENSE).
+- Das detaillierte Bedrohungsmodell und Sicherheitsarchitektur-Dokumentation findest du in [`THREAT_MODEL.md`](THREAT_MODEL.md).
 - Vollständige Third-Party-Attributionen aller ~230 Abhängigkeiten (Apache-2.0, MIT, BSD, SQLite Public Domain) sind in [`THIRD_PARTY_LICENSES.md`](THIRD_PARTY_LICENSES.md) dokumentiert.
 - Ausführliche rechtliche Bestimmungen und Exportkontroll-Hinweise sind in [`LEGAL.md`](LEGAL.md) geregelt.
 - Details zu allen Versionen und Änderungen findest du im [CHANGELOG.md](CHANGELOG.md).

SECURITY_AUDIT.md

@@ -0,0 +1,95 @@
+# Sanctum Security Audit & Remediation Log (v0.8.0)
+
+Dieses Dokument fasst alle 33 Findings aus zwei umfassenden externen Sicherheitsaudits zusammen, dokumentiert die angewandten Härtungsmaßnahmen, referenziert die jeweiligen Git-Commits und benennt die zugehörigen automatisierten Regressionstests.
+
+---
+
+## Audit-Zusammenfassung
+
+- **Zielversion:** Sanctum v0.8.0
+- **Behobene Findings:** 33 / 33 (100%)
+- **Test-Ergebnis:** 117 / 117 Tests erfolgreich (100% Pass Rate)
+- **Quality Gates:** `cargo fmt --check` (100% sauber), `cargo clippy --all-targets -- -D warnings` (0 Warnungen)
+- **Container-Format:** Upgrade auf Container-Format V3 mit kanonischer Metadaten-Authentifizierung (HMAC-SHA256) und Chunk-Replay-Schutz (Generation-gebundenes AAD).
+
+---
+
+## Übersicht aller Findings
+
+| Finding | Priorität | Modul | Kurzbeschreibung | Commit | Status & Regressionstest |
+|---|---|---|---|---|---|
+| **S-01** | HOCH | `sync` | `--delete` löscht keine ausgeschlossenen Pfade mehr; Schutz ganzer Verzeichnisbäume; `--delete-excluded` eingeführt | `374150e` | ✅ Bestanden (`test_s01_delete_preserves_excluded_files_and_directories`, `test_s01_pull_delete_preserves_local_excluded_and_leak_files`) |
+| **V-02** | HOCH | `vfs` | Fehlender Chunk innerhalb erwarteter Dateigröße löst E/A-Fehler aus statt stiller Dateikürzung | `5337644` | ✅ Bestanden (`test_v02_missing_chunk_returns_error_instead_of_silent_truncation`) |
+| **V-01** | HOCH | `vfs`, `carrier` | `copy()` delegiert im Carrier-Modus korrekt an `CarrierFs` | `151fdba` | ✅ Bestanden (`test_v01_carrier_fs_copy_delegation_and_functionality`) |
+| **K-01** | HOCH | `crypto`, `storage`, `verify` | Format V3: Kanonische Metadaten-Authentifizierung via HMAC-SHA256 über alle Inodes | `ad531d8` | ✅ Bestanden (`test_k01_metadata_tampering_detected_by_verify`, `test_k01_upgrade_format_v2_to_v3`) |
+| **K-02** | HOCH | `crypto`, `storage` | Format V3: Chunk-Replay-Schutz mittels 24-Byte AAD (inkl. monotoner Generation) | `36a4094` | ✅ Bestanden (`test_k02_chunk_replay_protection_with_generation_aad`, `test_k02_chunk_replay_detected_by_vfs_and_crypto`) |
+| **K-03** | HOCH | `crypto`, `recovery`, `cli` | Notfallblatt bleibt bei `passwd` dauerhaft gültig; `sanctum rekey` zur Schlüsselrotation | `bdddd81` | ✅ Bestanden (`test_k03_passwd_sheet_remains_valid_and_rekey_revokes_old_sheet`) |
+| **S-02** | MITTEL | `sync` | Plattformunabhängiger Pfad-Zusammenbau und Traversal-Schutz | `7b0f061` | ✅ Bestanden (`test_s02_platform_independent_path_construction_and_traversal_rejection`) |
+| **S-03** | MITTEL | `sync` | Symlink-Erkennung, Zählung und Zyklenschutz | `888c86c` | ✅ Bestanden (`test_s03_symlink_skipping_and_cycle_protection`) |
+| **S-04** | MITTEL | `sync` | Beseitigung von TOCTOU bei Dateigrößen durch Verwendung von `bytes_written` | `f557a9d` | ✅ Bestanden (`test_s04_toctou_file_size_uses_bytes_written`) |
+| **S-05** | MITTEL | `sync` | Vollständiges Löschen und Schreddern aller Chunks beim Kürzen auf 0 Bytes | `9634beb` | ✅ Bestanden (`test_s05_zero_byte_file_truncate_removes_all_chunks`) |
+| **S-06** | MITTEL | `storage`, `mount`, `sync` | Advisory Lock in Metadaten verhindert parallelen Mount & gleichzeitige Schreibzugriffe | `f9733df` | ✅ Bestanden (`test_s06_advisory_lock_blocks_sync_and_force_overrides`) |
+| **V-03** | MITTEL | `vfs`, `windows` | RAII Memory Lock Guard verhindert vorzeitiges Freigeben gesperrter Speicherseiten beim Klonen | `5285962` | ✅ Bestanden (`test_vfs_memory_lock_retention_on_clone_v03`) |
+| **M-01** | MITTEL | `crypto` | Erhöhung der Argon2id Standardparameter auf 256 MiB RAM und 4 Iterationen | `a502845` | ✅ Bestanden (`test_m01_default_kdf_params_256mib_4_iterations`) |
+| **M-02** | MITTEL | `build` | Aktivierung von `overflow-checks = true` im Release-Profil | `ad9148d` | ✅ Bestanden (`test_m02_release_profile_enables_overflow_checks`) |
+| **M-03** | MITTEL | `mount`, `doc` | Ausgabe von WebDAV-Zugangsdaten und Dokumentation manueller Mount-Befehle unter Linux | `2af14ee` | ✅ Bestanden (`test_m03_format_linux_mount_instructions`) |
+| **M-04** | MITTEL | `doc`, `threat_model` | Dokumentation des Bedrohungsmodells für Session-Tokens im Nutzerkontext | `e496c41` | ✅ Bestanden (Dokumentiert in `README.md`, `THREAT_MODEL.md`) |
+| **M-05** | MITTEL | `crypto`, `storage` | Verifikation der Schemagleichheit zwischen Standard- und Alibi-/Carrier-Containern | `a2c16ed` | ✅ Bestanden (`test_m05_deniability_schema_equality_standard_vs_hidden`) |
+| **V-05** | NIEDRIG | `vfs` | Protokollierung von Flush-Fehlern als `error!` in `SanctumFile::drop` und zwingender Flush bei `close` | `17ac4f9` | ✅ Bestanden (`test_v05_sanctum_file_drop_flushes_dirty_chunk_automatically`) |
+| **V-06** | NIEDRIG | `vfs` | Sparse Writes: Null-Auffüllung von Lücken zwischen Dateiende und Seek-Offset | `e300a76` | ✅ Bestanden (`test_v06_sparse_write_zero_fills_gap`) |
+| **V-07** | NIEDRIG | `vfs` | RFC-4918 konforme Overwrite-Semantik und Verzeichnis-Konfliktprüfungen in `copy` | `7303934` | ✅ Bestanden (`test_v07_copy_overwrite_existing_file_semantics`) |
+| **V-08** | NIEDRIG | `vfs`, `pathutil` | Disallow Tabulator-Steuerzeichen (0x09) in `validate_path_safety` | `708da24` | ✅ Bestanden (`test_path_safety_rejects_null_bytes_and_control_chars`) |
+| **V-09** | NIEDRIG | `storage` | Kryptografisches Schreddern von Datenblöcken vor physischer Chunk-Löschung in `truncate_chunks_after` | `1ba67cc` | ✅ Bestanden (`test_v09_truncate_chunks_after_shreds_before_deletion`) |
+| **S-07** | NIEDRIG | `sync` | Überspringen ungültiger Windows-Dateinamen (`files_skipped_invalid`) ohne Sync-Abbruch | `15adf79` | ✅ Bestanden (`test_s07_skip_invalid_windows_filenames_push_and_pull`) |
+| **S-08** | NIEDRIG | `sync` | Präzisierung und Dokumentation des Glob- und Pfad-Matchings | `92db21d` | ✅ Bestanden (`test_s08_refined_glob_and_directory_exclusions`) |
+| **S-09** | NIEDRIG | `sync` | Schutz vor unbeabsichtigtem Überschreiben bei `sync pull` | `c7c0ed8` | ✅ Bestanden (`test_s09_pull_backup_and_update_conflict_safety`) |
+| **U-01** | NIEDRIG | `upgrade` | Erzwingen von Pre-Hashing (`allow_legacy = false`) bei Minisign-Verifikation | `78a9c23` | ✅ Bestanden (`test_u01_reject_legacy_unhashed_signature`) |
+| **U-02** | NIEDRIG | `upgrade` | Validierung der Release-Version im Minisign `trusted comment` gegen den Release-Tag | `8dd5449` | ✅ Bestanden (`test_u02_validate_trusted_comment_version_matching`, `test_u02_reject_mismatched_release_tag_replay`) |
+| **U-03** | NIEDRIG | `upgrade` | Konfiguration eines sekundären Backup-Release-Public-Keys | `bb86447` | ✅ Bestanden (`test_u03_verify_signature_with_backup_key_fallback`, `test_u03_verify_signature_rejects_untrusted_third_party_key`) |
+| **Z-01** | NIEDRIG | `mount` | Schutz des Alibi-/Decoy-Passworts im Speicher via `Zeroizing<String>` | `07afe34` | ✅ Bestanden (`test_z01_decoy_password_zeroize_memory`) |
+| **Z-02** | NIEDRIG | `storage` | Robuste Wiederherstellung bei vergiftetem SQLite-Mutex (`PoisonError`) | `5a1fd7c` | ✅ Bestanden (`test_z02_poisoned_sqlite_mutex_recovery`) |
+| **Z-03** | NIEDRIG | `mount`, `doc` | Dokumentation der Forensik-Eigenschaften von temporären WAL- und SHM-Dateien | `487f999` | ✅ Bestanden (`test_wal_and_shm_cleanup_on_close`) |
+| **Z-04** | NIEDRIG | `vfs` | Implementierung des WebDAV Quota-Reports (`DAV:quota-available-bytes`, `DAV:quota-used-bytes`) | `17908a6` | ✅ Bestanden (`test_z04_webdav_quota_report`) |
+| **V-04** | NIEDRIG | `vfs`, `carrier`, `mount` | Strukturierter Anti-Leak Shield (Exakt, Präfixe, Suffixe, ADS, `.trash*`) & benutzerdefinierte Filterliste | `45572b7` | ✅ Bestanden (`test_is_leak_file`, `test_v04_custom_anti_leak_rules_and_loader`) |
+
+---
+
+## Detaillierte Beschreibungen der Kernarchitektur-Härtungen
+
+### 1. Container-Format V3 (K-01 & K-02)
+- **Format-Version:** Neue Container werden mit Format V3 (`format_version = 3`) erzeugt.
+- **Kanonische Metadaten-Authentifizierung (K-01):**
+  - Alle Inodes des Containers werden kanonisch serialisiert (`id`, `parent_id`, `name`, `is_dir`, `size`, `created_at`, `modified_at`, `is_carrier`, `chunk_count`).
+  - Eine HMAC-SHA-256 MAC wird über diese Struktur berechnet. Der MAC-Schlüssel wird deterministisch per HKDF-SHA256 aus dem DEK abgeleitet (`SANCTUM_META_MAC_V3`).
+  - Der MAC-Wert und ein monotoner Zähler (`metadata_gen`) werden in der Tabelle `meta` abgelegt.
+  - Jede Modifikation aktualisiert die MAC. `sanctum verify` detektiert jegliche unbefugte Manipulation an Metadaten sofort.
+  - Bestehende V1/V2 Container können mit `sanctum upgrade-format --path <container>` unterbrechungsfrei auf V3 migriert werden.
+- **Chunk-Replay-Schutz (K-02):**
+  - Jeder Chunk besitzt nun ein Attribut `generation` in der Tabelle `chunks`.
+  - Bei jeder Überschreibung eines Datenblocks wird die Generation inkrementiert.
+  - Das Additional Authenticated Data (AAD) für AES-256-GCM wurde für V3 von 16 Bytes auf 24 Bytes erweitert (`node_id || chunk_index || generation`).
+  - Ein Wiedereinspielen eines älteren gültigen Ciphertexts führt unweigerlich zu einem Authentifizierungsfehler (`AEAD decrypt error`).
+
+### 2. Notfallblatt-Management & Rekeying (K-03)
+- Die BIP-39 Notfallkarte kodiert direkt den Master-Verschlüsselungsschlüssel (DEK). Bei einer Passwortänderung (`sanctum passwd`) bleibt der DEK intakt, sodass das ausgedruckte Notfallblatt unverändert gültig bleibt.
+- Um ein kompromittiertes Notfallblatt zu invalidieren, wurde das Kommando `sanctum rekey` eingeführt:
+  - Generiert einen frischen DEK.
+  - Entschlüsselt alle Chunks und verschlüsselt sie mit dem neuen DEK (und frischer Generation).
+  - Schreddert die alten Chunks unwiderruflich im Freispeicher.
+  - Generiert eine neue 24-Wort Notfallphrase für den Nutzer.
+
+### 3. Anti-Leak Shield Upgrade (V-04)
+- Vollständige Trennung der Filterregeln in strukturierte Kategorien:
+  - Exakte Namen: `thumbs.db`, `desktop.ini`, `folder.jpg`, `.ds_store`, `.directory`, `.fseventsd`, `.spotlight-v100`.
+  - Präfixe: `~$*` (Office-Temporärdateien), `._*` (AppleDouble Resource Forks).
+  - Suffixe: `.tmp`, `.temp`, `.crdownload`, `.part`, `.partial`, `~*` (Editor-Backups).
+  - NTFS Alternate Data Streams (ADS): Alle Zugriffe mit `:` (z. B. `Zone.Identifier`).
+  - Wildcards: `.trash*`.
+- Option `--anti-leak-list <FILE>` für benutzerdefinierte Ausschlussmuster.
+- Statistische Zählung aller blockierten Schreib-/Lesezugriffe und transparente Zusammenfassung beim Unmount.
+
+---
+
+## Verifikationsnachweis
+
+Alle 117 Unit- und Integrationstests wurden auf einem Windows x86_64 Host mit 100% Erfolgsquote ausgeführt. Die Release-Paketierung für Windows und Linux musl ist voll automatisiert und wird mit Minisign kryptografisch abgesichert.

THREAT_MODEL.md

@@ -0,0 +1,104 @@
+# Threat Model & Sicherheitsarchitektur von Sanctum
+
+Dieses Dokument beschreibt das Bedrohungsmodell, die Sicherheitsannahmen und die Schutzmechanismen von **Sanctum v0.8.0** im reinen Userland-Betrieb.
+
+---
+
+## 1. Sicherheitsziele (Security Objectives)
+
+1. **Vertraulichkeit & Integrität ruhender Daten (Data at Rest)**: 
+   Containerdaten dürfen ohne Kenntnis des Master-Passworts oder des 24-Wort BIP-39 Notfallschlüssels weder entschlüsselt noch unbemerkt manipuliert oder wiederholt werden (Replay Protection).
+2. **Reine Userland-Ausführung ohne Kernel-Treiber**:
+   Vermeidung von Angriffsflächen im Betriebssystem-Kernel (kein Dokan, kein WinFsp, kein unsignierter Treiber). Das gemountete Dateisystem läuft vollständig im Benutzerkontext.
+3. **Schutz des Session-Tokens im lokalen Benutzerkontext**:
+   Das dynamische Session-Token für den lokalen WebDAV-Endpunkt darf weder über Prozesslisten (`argv`), Dateipfade, URL-Query-Parameter noch über Netzwerkinterfaces lecken.
+4. **Schutz vor forensischen Spuren (OpSec & Anti-Leak)**:
+   Verhinderung von Betriebssystem-Artefakten (`Thumbs.db`, `desktop.ini`, ShellBags, NTFS Alternate Data Streams, Swap/Pagefile-Auslagerung).
+
+---
+
+## 2. Bedrohungsmodell & Angreiferprofile
+
+### 2.1 Im Fokus (In Scope)
+
+| Angreifer / Bedrohung | Beschreibung | Sanctum-Gegenmaßnahme |
+|---|---|---|
+| **Kalter Datenträger-Angriff** | Angreifer hat physischen oder dateibasierten Zugriff auf die `.sanctum`-Datei auf USB-Stick, SSD oder Cloud-Storage. | Argon2id KDF (256 MiB, t=4, p=4), AES-256-GCM mit eindeutiger Chunk-Generation AAD, kanonische HMAC-SHA256 Metadaten-Authentifizierung (Format V3). |
+| **Böswillige Manipulation / Bitrot** | Gezieltes Verändern von Metadaten oder Chunks im Speicher. | AEAD-Tags auf allen Datenblöcken; `sanctum verify` erkennt jede Modifikation; Schreib- und Leseoperationen verwerfen manipulierte Blöcke sofort (`Fail-Closed`). |
+| **Replay- & Chunk-Vertauschungsangriffe** | Vertauschen von Chunks zwischen Dateien oder Einspielen alter Versionen. | Kryptografische Bindung aller Chunks an `(node_id, chunk_index, generation)` in den AEAD Additional Authenticated Data (AAD). |
+| **Lokale Benutzerisolation** | Mehrbenutzersysteme: Andere Standardbenutzer auf demselben Rechner. | Windows- und Unix-Dateirechte; TCP-Bind ausschließlich an Loopback `127.0.0.1`; dynamisches 128-Bit Session-Token. |
+| **DNS-Rebinding & Browser-Angriffe** | Eine im Browser des Nutzers laufende bösartige Website versucht, über DNS-Rebinding auf `http://localhost:<port>` zuzugreifen. | Strikte Fail-Closed Validierung des `Host`-Headers (`127.0.0.1`, `localhost`, `[::1]`). Abweisung aller externen Hostnamen (RT-02). |
+| **Argv- & Prozess-Scraping** | Andere Prozesse des gleichen Nutzers oder Monitoring-Tools lesen die Prozess-Kommandozeile aus. | In-Process Netzlaufwerk-Verbindung via `WNetAddConnection2W` (Windows) ohne `net use`-Subprozess. Token wird niemals über `argv` übergeben. |
+| **URL- & Proxy-Logging (CWE-598)** | Protokollierung von HTTP-Anfragen in lokalen Logs oder WebDAV-Clients. | Strikte Abweisung von Session-Tokens in URL-Pfad oder Query-String (`403 Forbidden`). Tokens dürfen ausschließlich im `Authorization`- oder `X-Sanctum-Token`-Header übertragen werden (SA-05). |
+| **Timing Side-Channel Angriffe** | Messung von Antwortzeiten beim Token-Vergleich. | Strikter Constant-Time Vergleich (`subtle::ConstantTimeEq`) für alle Authentifizierungsprüfungen (SA-06). |
+| **RAM-Dump & Pagefile-Forensik** | Windows lagert Arbeitsspeicher in `pagefile.sys` oder `swapfile.sys` aus. | Verriegelung der Schlüssel im physischen RAM via `VirtualLock` (Windows) bzw. `mlock` (Unix) mit RAII-Lebenszeitgarantie (`MemoryLockGuard`, V-03). Sicheres Überschreiben beim Beenden (`zeroize::Zeroizing`). |
+| **Slowloris DoS auf Loopback** | Ressourcenerschöpfung durch offengehaltene Sockets. | Beschränkung auf max. 64 gleichzeitige Verbindungen (`MAX_CONCURRENT_DAV_CONNECTIONS`) und 15s Header-Read-Timeout (`HTTP_HEADER_READ_TIMEOUT`). |
+| **Begleitdateien-Forensik (-wal/-shm)** | Angreifer analysiert temporäre SQLite-Dateien während oder nach dem Mount. | Sämtliche Daten werden vor Übergabe an SQLite verschlüsselt; WAL/SHM enthalten ausschließlich Ciphertext; TRUNCATE-Checkpointing und Bereinigung beim Aushängen (Z-03). |
+| **Nötigung / Schulterblick** | Zwang zur Passwortherausgabe. | Alibi-Carrier (Hidden Vault Modell A) mit steganografisch verstecktem zweiten Tresor und unabhängigen Schlüsseln. |
+
+---
+
+### 2.2 Außerhalb des Fokus (Out of Scope / Annahmen)
+
+- **Vollständig kompromittierter Host**: Ein Angreifer mit Kernel-Rootkit, Ring-0-Treiberrechten oder administrativem Keylogger kontrolliert das Gesamtsystem. In diesem Fall kann keine Userland-Anwendung Sicherheit garantieren.
+- **Direkte Speicherinjektion unter demselben Benutzerkonto**: Wenn Malware unter demselben Benutzerkonto mit denselben Rechten läuft und `ReadProcessMemory` / `OpenProcess` ausführt, greift das Betriebssystem-Sicherheitsmodell nicht. Sanctum empfiehlt getrennte Benutzerkonten und die Aktivierung von Windows Defender Exploit Protection.
+
+---
+
+## 3. Session-Token Bedrohungsmodell im Detail
+
+### 3.1 Lebenszyklus und Generierung
+- Für jede Mount-Sitzung wird ein **frisches 128-Bit kryptografisches Zufallstoken** via `rand::rngs::OsRng` (CryptGenRandom bzw. `getrandom`) generiert.
+- Das Token existiert ausschließlich im flüchtigen Speicher des Sanctum-Prozesses und wird nach dem Aushängen sicher aus dem RAM genullt.
+
+### 3.2 Keine Befehlszeilen-Leaks
+Unter Windows wird das WebDAV-Netzlaufwerk nicht über einen externen Aufruf wie `net use Z: http://127.0.0.1:8443 /user:...` eingebunden, sondern über den direkten Win32-API-Aufruf:
+```c
+WNetAddConnection2W(&net_resource, password, username, CONNECT_TEMPORARY)
+```
+Dadurch tauchen weder das Token noch die Zugangsdaten in der Windows-Prozesstabelle (`Get-Process`, Task-Manager, Sysinternals Process Explorer) auf.
+
+### 3.3 Header-basierte Authentifizierung (SA-05 & SA-06)
+- **Erlaubt**: 
+  - `Authorization: Basic <base64(sanctum:token)>`
+  - `X-Sanctum-Token: <token>`
+- **Streng verboten**: Token im URI-Pfad (`http://127.0.0.1:8443/<token>/...`) oder im Query-String (`?token=<token>`). Werden solche Anfragen empfangen, bricht Sanctum die Verarbeitung sofort mit HTTP `403 Forbidden` ab. Dies verhindert, dass Tokens in Referrer-Headern, Browser-Verläufen oder WebDAV-Caches protokolliert werden.
+- Alle Vergleiche erfolgen in konstanter Zeit (`ConstantTimeEq`), sodass Angreifer keine Rückschlüsse auf Token-Präfixe über Laufzeitunterschiede ziehen können.
+
+---
+
+## 4. Speicher- und Prozessisolation
+
+1. **VirtualLock & mlock RAII (`MemoryLockGuard`)**:
+   Der 256-Bit Data Encryption Key (DEK) wird sofort nach der Entschlüsselung im RAM mit `VirtualLock` (Windows) bzw. `mlock` (Linux) verriegelt. Dies garantiert, dass der Schlüssel zu keinem Zeitpunkt vom Windows Memory Manager in die unverschlüsselte Auslagerungsdatei (`pagefile.sys` / `swapfile.sys`) ausgelagert wird.
+   Durch die Kapselung in `Arc<MemoryLockGuard>` bleibt dieser Schutz auch bei parallelen WebDAV-Anfragen erhalten und wird erst aufgehoben, wenn die letzte Referenz freigegeben wird (V-03).
+2. **Zeroizing**:
+   Alle Schlüsselpuffer (`KEK`, `DEK`, KDF-Zwischenergebnisse) implementieren `zeroize::ZeroizeOnDrop` und werden beim Verlassen des Gültigkeitsbereichs mit Nullen überschrieben.
+3. **Session-Lock & Inactivity Shield**:
+   Sanctum lauscht über `WTSRegisterSessionNotification` auf Sperr-Events (`Win + L`) und Inaktivitäts-Timeouts. Beim Sperren wird das Laufwerk unverzüglich getrennt, alle Caches geleert, WAL-Checkpoints geschrieben und die Schlüssel zerstört.
+
+---
+
+## 5. Dateisystem-Forensik & SQLite WAL/SHM Begleitdateien (Z-03)
+
+### 5.1 Funktionsweise & Ciphertext-Garantie
+Während ein Sanctum-Container geöffnet oder aktiv eingebunden ist, nutzt die zugrundeliegende SQLite-Engine den Write-Ahead Logging (WAL) Modus (`PRAGMA journal_mode = WAL`). Dadurch entstehen temporär zwei Begleitdateien im selben Verzeichnis wie der Container:
+- `<container>.sanctum-wal` (Write-Ahead Log für Transaktionsdaten)
+- `<container>.sanctum-shm` (Shared-Memory-Index für parallele Lese- und Schreibzugriffe)
+
+**Kryptografische Sicherheit**:
+Alle Nutzdaten (Chunks) und Inode-Metadaten (Dateinamen) werden **vor** der Übergabe an SQLite im Sanctum-Userland via AES-256-GCM verschlüsselt. Die SQLite-Engine verarbeitet und speichert ausschließlich hochgradig ununterscheidbare Ciphertexte, Nonces, Authentifizierungs-Tags und HMAC-Prüfsummen.
+- Zu **keinem Zeitpunkt** gelangen Klartextdaten oder kryptografische Schlüssel (KEK, DEK) in die `-wal`- oder `-shm`-Dateien.
+- Selbst bei forensischer Extraktion der `-wal`- und `-shm`-Dateien sieht ein Angreifer ausschließlich unknackbares Zufallsrauschen ohne Entschlüsselungsmöglichkeit.
+
+### 5.2 Sauberes Beenden & Checkpointing
+Beim regulären Beenden (`sanctum unmount`, Ctrl+C, Inaktivitäts-Timeout oder Windows-Sitzungssperre) führt Sanctum automatisch:
+1. Einen vollständigen WAL-Checkpoint durch (`PRAGMA wal_checkpoint(TRUNCATE)`), der alle ausstehenden Transaktionen in die `.sanctum`-Hauptdatei überführt und die WAL-Datei auf 0 Bytes kürzt.
+2. Das Schließen der Datenbankverbindung durch, woraufhin SQLite die `-wal`- und `-shm`-Dateien vom Dateisystem entfernt.
+3. Ein explizites Bereinigungs-Fallback aus (`mount.rs`), das verbleibende Begleitdateien sicher vom Host-Dateisystem löscht.
+
+### 5.3 Abrupter Systemabsturz & OpSec-Überlegungen
+Wird der Rechner abrupt stromlos gemacht (`Hard Reset`), stürzt das Betriebssystem ab oder wird der Prozess via `SIGKILL` / Task-Manager beendet, verbleiben `<container>.sanctum-wal` und `-shm` möglicherweise auf dem Datenträger.
+- **Datenintegrität**: Beim nächsten Öffnen des Containers führt SQLite automatisch ein WAL-Recovery durch, wodurch keine Daten verloren gehen und die Metadaten-Authentifizierung (K-01) intakt bleibt.
+- **Forensische Sichtbarkeit**: Ein Angreifer kann aus der Existenz und Dateigröße der `-wal`-Datei ablesen, dass vor dem Absturz Schreiboperationen stattgefunden haben und wie viele Bytes modifiziert wurden.
+- **Flash-Wear-Leveling**: Auf SSDs/NVMe-Speichern können gelöschte Dateisystem-Sektoren bis zur TRIM-Bereinigung physisch im Flash-Speicher existieren. Für maximale OpSec empfiehlt Sanctum die Ablage von Containern auf vollverschlüsselten Host-Laufwerken (BitLocker / LUKS) oder RAM-Disks.

packages/scoop/sanctum.json

@@ -1,12 +1,12 @@
 {
-  "version": "0.5.0",
+  "version": "0.8.0",
   "description": "Verschlüsselter Ein-Datei-Container unter Windows im reinen Userland via WebDAV",
   "homepage": "https://gitea.pansi.eu/harald/sanctum",
   "license": "MIT",
   "architecture": {
     "64bit": {
-      "url": "https://gitea.pansi.eu/harald/sanctum/releases/download/v0.5.0/sanctum-v0.5.0-windows-x86_64.zip",
+      "url": "https://gitea.pansi.eu/harald/sanctum/releases/download/v0.8.0/sanctum-v0.8.0-windows-x86_64.zip",
-      "hash": "2f069a8cc41f9fa6a2559e2952e5669523c21c175df15f6d80f0473bbe2fa60e",
+      "hash": "11fa00bdd0dd48599ee578202c09c86ccbb7b971932bf14c8b4d11817aa26419",
       "bin": "sanctum.exe"
     }
   },

packages/winget/HaraldPansi.Sanctum.yaml

@@ -1,6 +1,6 @@
 # yaml-language-server: $schema=https://aka.ms/winget-manifest.singleton.1.6.0.schema.json
 PackageIdentifier: HaraldPansi.Sanctum
-PackageVersion: 0.5.0
+PackageVersion: 0.8.0
 PackageName: Sanctum
 Publisher: Harald Pansi
 PublisherUrl: https://gitea.pansi.eu/harald
@@ -18,7 +18,7 @@ Tags:
   - webdav
   - container
   - plausible-deniability
-ReleaseNotesUrl: https://gitea.pansi.eu/harald/sanctum/releases/tag/v0.5.0
+ReleaseNotesUrl: https://gitea.pansi.eu/harald/sanctum/releases/tag/v0.8.0
 Installers:
   - Architecture: x64
     InstallerType: zip
@@ -26,7 +26,7 @@ Installers:
     NestedInstallerFiles:
       - RelativeFilePath: sanctum.exe
         PortableCommandAlias: sanctum
-    InstallerUrl: https://gitea.pansi.eu/harald/sanctum/releases/download/v0.5.0/sanctum-v0.5.0-windows-x86_64.zip
+    InstallerUrl: https://gitea.pansi.eu/harald/sanctum/releases/download/v0.8.0/sanctum-v0.8.0-windows-x86_64.zip
-    InstallerSha256: 2f069a8cc41f9fa6a2559e2952e5669523c21c175df15f6d80f0473bbe2fa60e
+    InstallerSha256: 11fa00bdd0dd48599ee578202c09c86ccbb7b971932bf14c8b4d11817aa26419
 ManifestType: singleton
 ManifestVersion: 1.6.0

sanctum-release.pub

@@ -0,0 +1,2 @@
+untrusted comment: minisign public key E735BF824F9856AC
+RWSsVphPgr8157M9rTPkWDw3c0qIjc7xi28Gmw+cIWbMipOy4L6ToJEU

scripts/package-release-linux.ps1

@@ -106,6 +106,31 @@ $AllLines += "$ElfHash  sanctum"
 
 $AllLines | Set-Content -Path $ChecksumFile -Encoding utf8
 
+# Minisign Signatur aktualisieren (S-02)
+Write-Host "`nSigniere aktualisierte Pruefsummen mit Minisign..." -ForegroundColor Yellow
+$MinisignExe = "C:\Users\pansih\AppData\Local\Microsoft\WinGet\Packages\jedisct1.minisign_Microsoft.Winget.Source_8wekyb3d8bbwe\minisign-win64\x86_64\minisign.exe"
+$KeyFile = Join-Path $ProjectRoot "sanctum-release.key"
+$SigFile = Join-Path $DistDir "SHA256SUMS.txt.minisig"
+
+if (Test-Path $KeyFile) {
+    if (Test-Path $MinisignExe) {
+        if (Test-Path $SigFile) { Remove-Item $SigFile -Force }
+        & $MinisignExe -S -s $KeyFile -m $ChecksumFile -W -x $SigFile -t "version:$Version"
+        if ($LASTEXITCODE -eq 0 -and (Test-Path $SigFile)) {
+            Write-Host "[OK] Minisign-Signatur aktualisiert: dist\SHA256SUMS.txt.minisig" -ForegroundColor Green
+        } else {
+            Write-Error "Minisign-Signierung fehlgeschlagen!"
+            exit 1
+        }
+    } else {
+        Write-Error "minisign.exe nicht gefunden ($MinisignExe)! Release-Erstellung abgebrochen."
+        exit 1
+    }
+} else {
+    Write-Error "sanctum-release.key nicht gefunden ($KeyFile)! Release-Erstellung abgebrochen."
+    exit 1
+}
+
 $TarSizeMB = [math]::Round((Get-Item $TarGzFile).Length / 1MB, 2)
 $ElfSizeMB = [math]::Round((Get-Item $BinaryPath).Length / 1MB, 2)
 
@@ -116,4 +141,7 @@ Write-Host "  Archiv:        $TarGzFile ($TarSizeMB MB)"
 Write-Host "  TAR SHA-256:   $TarHash"
 Write-Host "  ELF SHA-256:   $ElfHash"
 Write-Host "  Checksum-File: $ChecksumFile"
+if (Test-Path $SigFile) {
+    Write-Host "  Minisign Sig:  $SigFile"
+}
 Write-Host "`nBereit fuer Gitea Release."

scripts/package-release.ps1

@@ -101,6 +101,31 @@ $AllLines | Set-Content -Path $ChecksumFile -Encoding utf8
 
 Write-Host "[OK] Pruefsummen in SHA256SUMS.txt gespeichert." -ForegroundColor Green
 
+# 5. Minisign Signatur generieren (S-02)
+Write-Host "`n[5/5] Signiere Pruefsummen mit Minisign..." -ForegroundColor Yellow
+$MinisignExe = "C:\Users\pansih\AppData\Local\Microsoft\WinGet\Packages\jedisct1.minisign_Microsoft.Winget.Source_8wekyb3d8bbwe\minisign-win64\x86_64\minisign.exe"
+$KeyFile = Join-Path $ProjectRoot "sanctum-release.key"
+$SigFile = Join-Path $DistDir "SHA256SUMS.txt.minisig"
+
+if (Test-Path $KeyFile) {
+    if (Test-Path $MinisignExe) {
+        if (Test-Path $SigFile) { Remove-Item $SigFile -Force }
+        & $MinisignExe -S -s $KeyFile -m $ChecksumFile -W -x $SigFile -t "version:$Version"
+        if ($LASTEXITCODE -eq 0 -and (Test-Path $SigFile)) {
+            Write-Host "[OK] Minisign-Signatur erstellt: dist\SHA256SUMS.txt.minisig" -ForegroundColor Green
+        } else {
+            Write-Error "Minisign-Signierung fehlgeschlagen!"
+            exit 1
+        }
+    } else {
+        Write-Error "minisign.exe nicht gefunden ($MinisignExe)! Release-Erstellung abgebrochen (Signatur ist obligatorisch)."
+        exit 1
+    }
+} else {
+    Write-Error "sanctum-release.key nicht gefunden ($KeyFile)! Release-Erstellung abgebrochen (Signatur ist obligatorisch)."
+    exit 1
+}
+
 # Abschluss-Zusammenfassung
 $ZipSize = (Get-Item $ZipFile).Length / 1MB
 Write-Host "`n============================================================" -ForegroundColor Green
@@ -110,4 +135,7 @@ Write-Host "  Archiv:        dist\$PackageName.zip ($([math]::Round($ZipSize, 2)
 Write-Host "  ZIP SHA-256:   $ZipHash"
 Write-Host "  EXE SHA-256:   $ExeHash"
 Write-Host "  Checksum-File: dist\SHA256SUMS.txt"
+if (Test-Path $SigFile) {
+    Write-Host "  Minisign Sig:  dist\SHA256SUMS.txt.minisig"
+}
 Write-Host "`nBereit fuer Gitea Release / Verteilung.`n"

scripts/publish-release.ps1

@@ -27,6 +27,12 @@ if (-not (Test-Path $ZipFile)) {
     & (Join-Path $ScriptDir "package-release.ps1")
 }
 
+$SigFile = Join-Path $DistDir "SHA256SUMS.txt.minisig"
+if (-not (Test-Path $SigFile)) {
+    Write-Error "Obligatorische Minisign-Signaturdatei '$SigFile' nicht gefunden! Ein Release ohne kryptografische Signatur darf nicht veroeffentlicht werden."
+    exit 1
+}
+
 # .env-Datei laden falls vorhanden (ist in .gitignore)
 $EnvFile = Join-Path $ProjectRoot ".env"
 if (Test-Path $EnvFile) {
@@ -155,8 +161,10 @@ Upload-ReleaseAsset -FilePath $LinuxTar -AssetName "sanctum-$TagName-linux-x86_6
 $LinuxElf = Join-Path $ProjectRoot "target\x86_64-unknown-linux-musl\release\sanctum"
 Upload-ReleaseAsset -FilePath $LinuxElf -AssetName "sanctum"
 
-# SHA256SUMS.txt hochladen
+# SHA256SUMS.txt & Minisign-Signatur hochladen
 Upload-ReleaseAsset -FilePath $ChecksumFile -AssetName "SHA256SUMS.txt"
+$SigFile = Join-Path $DistDir "SHA256SUMS.txt.minisig"
+Upload-ReleaseAsset -FilePath $SigFile -AssetName "SHA256SUMS.txt.minisig"
 
 
 Write-Host "`n============================================================" -ForegroundColor Green

src/carrier.rs

@@ -10,8 +10,8 @@ use bytes::{Buf, Bytes, BytesMut};
 use dav_server::{
     davpath::DavPath,
     fs::{
-        DavDirEntry, DavFile, DavFileSystem, DavMetaData, FsError, FsFuture, FsStream,
+        DavDirEntry, DavFile, DavFileSystem, DavMetaData, FsError, FsFuture, FsStream, OpenOptions,
-        OpenOptions, ReadDirMeta,
+        ReadDirMeta,
     },
 };
 use futures_util::stream;
@@ -23,7 +23,7 @@ use zeroize::{Zeroize, Zeroizing};
 
 use crate::crypto::{decrypt_chunk, encrypt_chunk, CHUNK_SIZE};
 use crate::storage::Database;
-use crate::vfs::{is_leak_file, SanctumDirEntry, SanctumMetaData};
+use crate::vfs::{is_leak_file_with_custom, SanctumDirEntry, SanctumMetaData};
 
 pub const CARRIER_MAGIC: &[u8; 8] = b"SANCTCAR";
 pub const CARRIER_VERSION: u32 = 1;
@@ -115,6 +115,7 @@ pub fn read_carrier_block(
         &chunk_rec.nonce,
         &chunk_rec.tag,
         format_version,
+        chunk_rec.generation,
     )?;
 
     // Das outer_decrypted enthält: inner_nonce (12B) || inner_tag (16B) || inner_ct_len (4B LE) || inner_ct || CSPRNG-Padding
@@ -149,6 +150,7 @@ pub fn read_carrier_block(
         &inner_nonce,
         &inner_tag,
         format_version,
+        chunk_rec.generation,
     )?;
 
     Ok(inner_plaintext)
@@ -167,6 +169,8 @@ pub fn write_carrier_block(
     plaintext: &[u8],
     format_version: u32,
 ) -> Result<()> {
+    let gen = 0u64;
+
     // 1. Innere Schicht verschlüsseln (mit dek_inner = DEK_1)
     let (inner_ct, inner_nonce, inner_tag) = encrypt_chunk(
         dek_inner,
@@ -174,6 +178,7 @@ pub fn write_carrier_block(
         block_idx,
         plaintext,
         format_version,
+        gen,
     )?;
 
     let inner_ct_len = inner_ct.len() as u32;
@@ -208,12 +213,14 @@ pub fn write_carrier_block(
         block_idx,
         &outer_plaintext,
         format_version,
+        gen,
     )?;
 
     // 4. In SQLite schreiben (in-place Überschreiben des bestehenden Chunks)
     db.write_chunk(
         carrier_node_id,
         block_idx,
+        gen,
         &outer_nonce,
         &outer_tag,
         &outer_ct,
@@ -234,17 +241,20 @@ pub fn shred_carrier_block(
     let mut noise = vec![0u8; CHUNK_SIZE];
     OsRng.fill_bytes(&mut noise);
 
+    let gen = 0u64;
     let (outer_ct, outer_nonce, outer_tag) = encrypt_chunk(
         dek_outer,
         carrier_node_id,
         block_idx,
         &noise,
         format_version,
+        gen,
     )?;
 
     db.write_chunk(
         carrier_node_id,
         block_idx,
+        gen,
         &outer_nonce,
         &outer_tag,
         &outer_ct,
@@ -261,11 +271,16 @@ pub struct CarrierFsInner {
     pub dek_inner: Arc<Zeroizing<[u8; 32]>>,
     pub format_version: u32,
     pub anti_leak: bool,
+    pub custom_leak_rules: Arc<Vec<String>>,
+    pub leak_counter: Arc<AtomicU64>,
     pub manifest: CarrierManifest,
     pub last_activity: Arc<AtomicU64>,
 }
 
 impl CarrierFsInner {
+    pub fn is_leak(&self, name: &str) -> bool {
+        self.anti_leak && is_leak_file_with_custom(name, &self.custom_leak_rules)
+    }
     pub fn save_manifest(&mut self) -> Result<()> {
         let manifest_bytes = serde_json::to_vec(&self.manifest)?;
         if manifest_bytes.len() > (crate::crypto::CHUNK_SIZE - 64) {
@@ -359,14 +374,15 @@ pub struct CarrierFs {
 }
 
 impl CarrierFs {
-    /// Lädt ein bestehendes Carrier-Dateisystem aus Block 0 der Trägerdatei.
+    /// Lädt ein bestehendes Carrier-Dateisystem mit benutzerdefinierten Anti-Leak-Regeln (V-04).
-    pub fn load(
+    pub fn load_with_leak_rules(
         db: Database,
         carrier_node_id: i64,
         dek_outer: Arc<Zeroizing<[u8; 32]>>,
         dek_inner: Arc<Zeroizing<[u8; 32]>>,
         format_version: u32,
         anti_leak: bool,
+        custom_leak_rules: Vec<String>,
     ) -> Result<Self> {
         let manifest_bytes = read_carrier_block(
             &db,
@@ -398,6 +414,8 @@ impl CarrierFs {
             dek_inner,
             format_version,
             anti_leak,
+            custom_leak_rules: Arc::new(custom_leak_rules),
+            leak_counter: Arc::new(AtomicU64::new(0)),
             manifest,
             last_activity: Arc::new(AtomicU64::new(now)),
         };
@@ -407,8 +425,33 @@ impl CarrierFs {
         })
     }
 
+    /// Lädt ein bestehendes Carrier-Dateisystem aus Block 0 der Trägerdatei.
+    pub fn load(
+        db: Database,
+        carrier_node_id: i64,
+        dek_outer: Arc<Zeroizing<[u8; 32]>>,
+        dek_inner: Arc<Zeroizing<[u8; 32]>>,
+        format_version: u32,
+        anti_leak: bool,
+    ) -> Result<Self> {
+        Self::load_with_leak_rules(
+            db,
+            carrier_node_id,
+            dek_outer,
+            dek_inner,
+            format_version,
+            anti_leak,
+            Vec::new(),
+        )
+    }
+
+    pub fn leak_counter(&self) -> Arc<AtomicU64> {
+        let inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
+        inner.leak_counter.clone()
+    }
+
     pub fn last_activity(&self) -> Arc<AtomicU64> {
-        let inner = self.inner.lock().unwrap();
+        let inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
         inner.last_activity.clone()
     }
 
@@ -439,13 +482,14 @@ impl DavFileSystem for CarrierFs {
             let mut inner = self.inner.lock().unwrap();
             let (parent_path, file_name) = inner.split_parent_and_name(&path_str);
 
-            if inner.anti_leak && is_leak_file(file_name) {
+            if inner.is_leak(file_name) {
                 if options.create
                     || options.create_new
                     || options.write
                     || options.append
                     || options.truncate
                 {
+                    inner.leak_counter.fetch_add(1, Ordering::Relaxed);
                     return Err(FsError::Forbidden);
                 }
             }
@@ -544,7 +588,14 @@ impl DavFileSystem for CarrierFs {
                 .inodes
                 .values()
                 .filter(|child| child.parent_id == Some(node.id))
-                .filter(|child| !inner.anti_leak || !is_leak_file(&child.name))
+                .filter(|child| {
+                    if inner.is_leak(&child.name) {
+                        inner.leak_counter.fetch_add(1, Ordering::Relaxed);
+                        false
+                    } else {
+                        true
+                    }
+                })
                 .map(|child| {
                     Ok(Box::new(SanctumDirEntry {
                         name: child.name.clone(),
@@ -591,7 +642,8 @@ impl DavFileSystem for CarrierFs {
             let mut inner = self.inner.lock().unwrap();
             let (parent_path, dir_name) = inner.split_parent_and_name(&path_str);
 
-            if inner.anti_leak && is_leak_file(dir_name) {
+            if inner.is_leak(dir_name) {
+                inner.leak_counter.fetch_add(1, Ordering::Relaxed);
                 return Err(FsError::Forbidden);
             }
 
@@ -624,9 +676,7 @@ impl DavFileSystem for CarrierFs {
             };
 
             inner.manifest.inodes.insert(new_id, new_dir);
-            inner
+            inner.save_manifest().map_err(|_| FsError::GeneralFailure)?;
-                .save_manifest()
-                .map_err(|_| FsError::GeneralFailure)?;
 
             Ok(())
         })
@@ -659,9 +709,7 @@ impl DavFileSystem for CarrierFs {
             }
 
             inner.manifest.inodes.remove(&node.id);
-            inner
+            inner.save_manifest().map_err(|_| FsError::GeneralFailure)?;
-                .save_manifest()
-                .map_err(|_| FsError::GeneralFailure)?;
 
             Ok(())
         })
@@ -690,9 +738,7 @@ impl DavFileSystem for CarrierFs {
             }
 
             inner.manifest.inodes.remove(&node.id);
-            inner
+            inner.save_manifest().map_err(|_| FsError::GeneralFailure)?;
-                .save_manifest()
-                .map_err(|_| FsError::GeneralFailure)?;
 
             Ok(())
         })
@@ -708,7 +754,8 @@ impl DavFileSystem for CarrierFs {
             let node = inner.resolve_path(&from_str).ok_or(FsError::NotFound)?;
 
             let (to_parent_path, to_name) = inner.split_parent_and_name(&to_str);
-            if inner.anti_leak && is_leak_file(to_name) {
+            if inner.is_leak(to_name) {
+                inner.leak_counter.fetch_add(1, Ordering::Relaxed);
                 return Err(FsError::Forbidden);
             }
 
@@ -748,13 +795,157 @@ impl DavFileSystem for CarrierFs {
                 inode.modified_at = now;
             }
 
-            inner
+            inner.save_manifest().map_err(|_| FsError::GeneralFailure)?;
-                .save_manifest()
-                .map_err(|_| FsError::GeneralFailure)?;
 
             Ok(())
         })
     }
+
+    fn copy<'a>(&'a self, from: &'a DavPath, to: &'a DavPath) -> FsFuture<'a, ()> {
+        Box::pin(async move {
+            self.touch();
+            let from_str = Self::path_to_str(from);
+            let to_str = Self::path_to_str(to);
+
+            if from_str == to_str {
+                return Ok(());
+            }
+
+            let mut inner = self.inner.lock().unwrap();
+            let node = inner.resolve_path(&from_str).ok_or(FsError::NotFound)?;
+
+            if node.is_dir {
+                return Err(FsError::NotImplemented);
+            }
+
+            let (to_parent_path, to_name) = inner.split_parent_and_name(&to_str);
+            if inner.is_leak(to_name) {
+                inner.leak_counter.fetch_add(1, Ordering::Relaxed);
+                return Err(FsError::Forbidden);
+            }
+
+            let to_parent = inner
+                .resolve_path(to_parent_path)
+                .ok_or(FsError::NotFound)?;
+            if !to_parent.is_dir {
+                return Err(FsError::Forbidden);
+            }
+
+            // Falls Zieldatei existiert und ein Verzeichnis ist: Fehler
+            if let Some(dest) = inner.resolve_path(&to_str) {
+                if dest.is_dir {
+                    return Err(FsError::Forbidden);
+                }
+                for b in dest.blocks {
+                    let _ = shred_carrier_block(
+                        &inner.db,
+                        inner.carrier_node_id,
+                        b,
+                        &inner.dek_outer,
+                        inner.format_version,
+                    );
+                    inner.manifest.free_blocks.push(b);
+                }
+                inner.manifest.inodes.remove(&dest.id);
+            }
+
+            if inner.manifest.free_blocks.len() < node.blocks.len() {
+                return Err(FsError::InsufficientStorage);
+            }
+
+            let mut dest_blocks = Vec::with_capacity(node.blocks.len());
+            for &src_block_idx in &node.blocks {
+                let dest_block_idx = match inner.allocate_block() {
+                    Ok(b) => b,
+                    Err(e) => {
+                        for b in dest_blocks {
+                            let _ = inner.free_block(b);
+                        }
+                        return Err(e);
+                    }
+                };
+
+                let data = match read_carrier_block(
+                    &inner.db,
+                    inner.carrier_node_id,
+                    src_block_idx,
+                    &inner.dek_outer,
+                    &inner.dek_inner,
+                    inner.format_version,
+                ) {
+                    Ok(d) => d,
+                    Err(e) => {
+                        error!("Fehler beim Lesen des Quell-Blocks während copy: {e}");
+                        let _ = inner.free_block(dest_block_idx);
+                        for b in dest_blocks {
+                            let _ = inner.free_block(b);
+                        }
+                        return Err(FsError::GeneralFailure);
+                    }
+                };
+
+                if let Err(e) = write_carrier_block(
+                    &inner.db,
+                    inner.carrier_node_id,
+                    dest_block_idx,
+                    &inner.dek_outer,
+                    &inner.dek_inner,
+                    &data,
+                    inner.format_version,
+                ) {
+                    error!("Fehler beim Schreiben des Ziel-Blocks während copy: {e}");
+                    let _ = inner.free_block(dest_block_idx);
+                    for b in dest_blocks {
+                        let _ = inner.free_block(b);
+                    }
+                    return Err(FsError::GeneralFailure);
+                }
+
+                dest_blocks.push(dest_block_idx);
+            }
+
+            let now = SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .map(|d| d.as_secs())
+                .unwrap_or(0);
+
+            let new_id = inner.manifest.next_inode_id;
+            inner.manifest.next_inode_id += 1;
+
+            let new_inode = CarrierInode {
+                id: new_id,
+                parent_id: Some(to_parent.id),
+                name: to_name.to_string(),
+                is_dir: false,
+                size: node.size,
+                created_at: now,
+                modified_at: now,
+                blocks: dest_blocks,
+            };
+
+            inner.manifest.inodes.insert(new_id, new_inode);
+            inner.save_manifest().map_err(|_| FsError::GeneralFailure)?;
+
+            Ok(())
+        })
+    }
+
+    fn get_quota(&self) -> FsFuture<'_, (u64, Option<u64>)> {
+        Box::pin(async move {
+            self.touch();
+            let inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
+            let total_capacity =
+                inner.manifest.total_blocks as u64 * crate::crypto::CHUNK_SIZE as u64;
+            let used_bytes = inner
+                .manifest
+                .inodes
+                .values()
+                .filter(|i| !i.is_dir)
+                .map(|i| i.size)
+                .sum::<u64>();
+            Ok((used_bytes, Some(total_capacity)))
+        })
+    }
 }
 
 /// Datei-Handle für Dateien innerhalb des Carrier-Dateisystems mit Streaming und Chunk-Pufferung.
@@ -927,6 +1118,35 @@ impl DavFile for CarrierFile {
     fn write_bytes(&mut self, buf: Bytes) -> FsFuture<'_, ()> {
         self.touch();
         Box::pin(async move {
+            // V-06: Sparse Writes — Lücke zwischen bisherigem Dateiende und Cursor mit Nullen füllen
+            if self.cursor > self.file_size {
+                let target = self.cursor;
+                while self.file_size < target {
+                    let block_idx = (self.file_size / CARRIER_BLOCK_PAYLOAD_SIZE as u64) as usize;
+                    let offset_in_block =
+                        (self.file_size % CARRIER_BLOCK_PAYLOAD_SIZE as u64) as usize;
+                    let space_in_block = CARRIER_BLOCK_PAYLOAD_SIZE - offset_in_block;
+                    let to_pad = ((target - self.file_size) as usize).min(space_in_block);
+
+                    let block_data = self.ensure_block_loaded(block_idx)?;
+                    if block_data.len() < offset_in_block + to_pad {
+                        block_data.resize(offset_in_block + to_pad, 0);
+                    }
+
+                    let mut is_full = false;
+                    if let Some((_, ref d, ref mut dirty)) = self.cached_block {
+                        *dirty = true;
+                        is_full = d.len() >= CARRIER_BLOCK_PAYLOAD_SIZE;
+                    }
+
+                    self.file_size += to_pad as u64;
+
+                    if is_full {
+                        self.flush_cached_block()?;
+                    }
+                }
+            }
+
             let mut src = &buf[..];
 
             while !src.is_empty() {
@@ -1011,9 +1231,7 @@ impl DavFile for CarrierFile {
                 inode.modified_at = now;
             }
 
-            inner
+            inner.save_manifest().map_err(|_| FsError::GeneralFailure)?;
-                .save_manifest()
-                .map_err(|_| FsError::GeneralFailure)?;
 
             self.meta.size = self.file_size;
             self.meta.modified_at = UNIX_EPOCH + Duration::from_secs(now);
@@ -1025,7 +1243,10 @@ impl DavFile for CarrierFile {
 impl Drop for CarrierFile {
     fn drop(&mut self) {
         if let Err(e) = self.flush_cached_block() {
-            tracing::warn!("Fehler beim automatischen Flush im CarrierFile::drop: {:?}", e);
+            tracing::warn!(
+                "Fehler beim automatischen Flush im CarrierFile::drop: {:?}",
+                e
+            );
         }
         if let Some((_, ref mut data, _)) = self.cached_block {
             data.zeroize();

src/lib.rs

@@ -1,11 +1,13 @@
 pub mod carrier;
 pub mod crypto;
 pub mod mount;
+pub mod pathutil;
 pub mod platform;
 pub mod recovery;
 pub mod storage;
 pub mod sync;
 pub mod ui;
+pub mod upgrade;
 pub mod verify;
 pub mod vfs;
 pub mod windows;

src/mount.rs

@@ -1,6 +1,7 @@
 use std::convert::Infallible;
 use std::net::SocketAddr;
 use std::path::Path;
+#[cfg(unix)]
 use std::process::Command;
 use std::sync::atomic::Ordering;
 use std::time::{SystemTime, UNIX_EPOCH};
@@ -32,29 +33,11 @@ pub fn format_drive(drive_letter: char) -> String {
     format!("{}:", drive_letter.to_ascii_uppercase())
 }
 
-/// Trennt ein Windows-Netzlaufwerk via `net use <DRIVE>: /delete /y` bzw. Unix-Mountpoint via `gio mount -u`.
+/// Trennt ein Windows-Netzlaufwerk via WNetCancelConnection2W bzw. Unix-Mountpoint via gio.
 pub fn unmount_drive(drive_letter: char) -> Result<()> {
     #[cfg(windows)]
     {
-        let drive_str = format_drive(drive_letter);
+        crate::windows::unmount_drive_wnet(drive_letter)
-
-        let output = Command::new("net")
-            .args(["use", &drive_str, "/delete", "/y"])
-            .output()
-            .context("Fehler beim Ausführen des Befehls 'net use'")?;
-
-        if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            let stdout = String::from_utf8_lossy(&output.stdout);
-            bail!(
-                "Netzlaufwerk {} konnte nicht getrennt werden:\n{}{}",
-                drive_str,
-                stdout,
-                stderr
-            );
-        }
-
-        Ok(())
     }
     #[cfg(unix)]
     {
@@ -68,74 +51,23 @@ pub fn unmount_drive(drive_letter: char) -> Result<()> {
     }
 }
 
-/// Bindet ein Windows-Netzlaufwerk via `net use <DRIVE>: http://127.0.0.1:<PORT>/<TOKEN>/ /persistent:no` ein
+/// Bindet ein Windows-Netzlaufwerk via in-process WNetAddConnection2W ein (R-05, kein Token in argv)
-/// bzw. unter Unix via `gio mount dav://127.0.0.1:<PORT>/<TOKEN>/`.
+/// bzw. unter Unix via `gio mount dav://127.0.0.1:<PORT>/`.
-fn run_mount_command(drive_str: &str, port: u16, session_token: &str) -> Result<()> {
+fn run_mount_command(drive_letter: char, port: u16, session_token: &str) -> Result<()> {
     #[cfg(windows)]
     {
-        let url = format!("http://127.0.0.1:{}/{}/", port, session_token);
+        crate::windows::mount_drive_wnet(drive_letter, port, session_token)
-
-        let mut output = Command::new("net")
-            .args(["use", drive_str, &url, "/persistent:no"])
-            .output()
-            .context("Fehler beim Ausführen des Befehls 'net use'")?;
-
-        // PRR-01: Selbstreparatur bei verwaister Zuordnung nach unsauberem Vorläufer (Systemfehler 85)
-        if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            let stdout = String::from_utf8_lossy(&output.stdout);
-            let is_already_in_use = stderr.contains("85")
-                || stderr.contains("bereits verwendet")
-                || stderr.contains("already in use")
-                || stdout.contains("85")
-                || stdout.contains("bereits verwendet")
-                || stdout.contains("already in use");
-
-            if is_already_in_use {
-                debug!("Verwaiste Zuordnung für {} entdeckt — führe automatische Bereinigung durch...", drive_str);
-                let _ = Command::new("net")
-                    .args(["use", drive_str, "/delete", "/y"])
-                    .output();
-
-                // Zweiter Versuch nach automatischer Bereinigung
-                output = Command::new("net")
-                    .args(["use", drive_str, &url, "/persistent:no"])
-                    .output()
-                    .context("Fehler beim erneuten Ausführen des Befehls 'net use'")?;
-            }
-        }
-
-        if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            let stdout = String::from_utf8_lossy(&output.stdout);
-            let webclient_hint = if stderr.contains("67") || stderr.contains("Netzwerkname") || stderr.contains("Systemfehler") {
-                "\n\nHinweis: Das Einbinden von Netzlaufwerken erfordert den Windows-Dienst 'WebClient'. Prüfen Sie in einer Administrator-Konsole: 'net start WebClient'."
-            } else {
-                ""
-            };
-            bail!(
-                "Laufwerk {} konnte nicht eingebunden werden:\n{}{}{}",
-                drive_str,
-                stdout,
-                stderr,
-                webclient_hint
-            );
-        }
-
-        Ok(())
     }
     #[cfg(unix)]
     {
-        let dav_url = format!("dav://127.0.0.1:{}/{}/", port, session_token);
+        let dav_url = format!("dav://127.0.0.1:{}/", port);
-        let _ = Command::new("gio")
+        let _ = Command::new("gio").args(["mount", &dav_url]).output();
-            .args(["mount", &dav_url])
+        let _ = (drive_letter, session_token);
-            .output();
-        let _ = drive_str;
         Ok(())
     }
     #[cfg(not(any(windows, unix)))]
     {
-        let _ = (drive_str, port, session_token);
+        let _ = (drive_letter, port, session_token);
         Ok(())
     }
 }
@@ -152,9 +84,11 @@ pub async fn mount_container(
     idle_timeout: Option<u64>,
     lock_on_screen_lock: bool,
     anti_leak: bool,
+    anti_leak_list: Option<&Path>,
     stealth: bool,
 ) -> Result<()> {
     let drive_str = format_drive(drive_letter);
+    let _ = &drive_str;
     let _ = mount_point;
     let _ = open_explorer;
     let _ = enable_tray;
@@ -171,8 +105,7 @@ pub async fn mount_container(
         println!();
         ui::step(1, 4, "📦", "Öffne Container & verifiziere Header...");
     }
-    let db = Database::open(container_path)
+    let db = Database::open(container_path).context("Konnte Container-Datenbank nicht öffnen")?;
-        .context("Konnte Container-Datenbank nicht öffnen")?;
 
     let meta = db
         .read_meta()
@@ -181,12 +114,22 @@ pub async fn mount_container(
     let (dek, carrier_dek, carrier_node_id, version, vault_id) = match auth {
         ContainerAuth::Password(ref password) => {
             if !stealth {
-                ui::step(2, 4, "🔑", "Leite KEK via Argon2id ab (konstante Zeit über alle Slots)...");
+                ui::step(
+                    2,
+                    4,
+                    "🔑",
+                    "Leite KEK via Argon2id ab (konstante Zeit über alle Slots)...",
+                );
             }
             match meta.authenticate(password) {
                 Some(keys) => {
                     if !stealth {
-                        ui::step(3, 4, "🔓", "Master-Passwort erfolgreich verifiziert & DEK entschlüsselt!");
+                        ui::step(
+                            3,
+                            4,
+                            "🔓",
+                            "Master-Passwort erfolgreich verifiziert & DEK entschlüsselt!",
+                        );
                     }
                     let vault_id = keys.slot_id();
                     let ver = keys.version();
@@ -203,41 +146,86 @@ pub async fn mount_container(
             if !stealth {
                 ui::step(2, 4, "🔑", "Dekodiere DEK aus 24-Wort Notfallschlüssel...");
             }
-            let dek = mnemonic_to_dek(phrase)
+            let dek = mnemonic_to_dek(phrase).context("Ungültiger 24-Wort Notfallschlüssel")?;
-                .context("Ungültiger 24-Wort Notfallschlüssel")?;
             if !stealth {
                 ui::step(3, 4, "🔓", "Notfallschlüssel erfolgreich verifiziert!");
             }
 
-            // Prüfe, ob dek Dateien im Hidden Vault (Root 2) entschlüsseln kann
+            let carrier_node_id = db.find_carrier_node_id()?.unwrap_or(0);
-            let is_hidden = {
+            let (carrier_dek, final_carrier_node_id, vault_id) = if carrier_node_id > 0 {
-                let children = db.list_children_in_vault(2, 1, &dek).unwrap_or_default();
+                let slot_id = crate::recovery::detect_recovery_key_slot(&db, &dek, meta.version)?;
-                !children.is_empty()
+                if slot_id == 1 {
+                    if !stealth {
+                        println!("  [i] Der angegebene Notfallschlüssel gehört zum Hidden-Vault (Slot 1).");
+                        println!("      Für den Zugriff auf die Trägerdatei wird das Passwort des Standard-Vaults benötigt.");
+                    }
+                    let decoy_pass = Zeroizing::new(
+                        rpassword::prompt_password("Master-Passwort für Standard-Vault eingeben: ")
+                            .context("Fehler beim Einlesen des Standard-Vault Passworts")?,
+                    );
+                    let decoy_keys = meta.authenticate(&decoy_pass).ok_or_else(|| {
+                        anyhow::anyhow!("Ungültiges Passwort für Standard-Vault.")
+                    })?;
+                    (Some(decoy_keys.dek().clone()), Some(carrier_node_id), 1)
+                } else {
+                    (None, Some(carrier_node_id), 0)
+                }
+            } else {
+                (None, None, 0)
             };
-            let vault_id = if is_hidden { 1 } else { 0 };
+
-            (dek, None, None, meta.version, vault_id)
+            (
+                dek,
+                carrier_dek,
+                final_carrier_node_id,
+                meta.version,
+                vault_id,
+            )
         }
     };
 
+    // S-06: Advisory Lock setzen, um parallele Mounts und schreibende Sync-Läufe abzuwehren
+    let _advisory_lock = db.acquire_advisory_lock_guard(false)?;
+
     // 128-Bit Session-Token für Loopback-Schutz (CWE-306) & Anti-CSRF generieren
     let mut token_bytes = [0u8; 16];
     rand::RngCore::fill_bytes(&mut rand::rngs::OsRng, &mut token_bytes);
     let session_token = hex::encode(token_bytes);
-    let token_path_prefix = format!("/{}", session_token);
+
+    // Benutzerdefinierte Anti-Leak Filterregeln laden (V-04)
+    let custom_leak_rules = if let Some(path) = anti_leak_list {
+        match crate::vfs::load_anti_leak_list(path) {
+            Ok(rules) => {
+                if !stealth {
+                    println!(
+                        "  • Anti-Leak Liste:   {} benutzerdefinierte Regeln geladen",
+                        rules.len()
+                    );
+                }
+                rules
+            }
+            Err(e) => {
+                bail!("Fehler beim Laden der Anti-Leak-Regeln: {e}");
+            }
+        }
+    } else {
+        Vec::new()
+    };
 
     // WebDAV Filesystem und Handler konfigurieren (mit Anti-Leak Shield & Carrier-Routing)
-    let fs = SanctumFs::with_carrier(
+    let fs = SanctumFs::with_carrier_and_leak_rules(
         db.clone(),
         dek,
         carrier_dek,
         carrier_node_id,
         version,
         anti_leak,
+        custom_leak_rules,
         vault_id,
     );
+    let fs_leak_counter = fs.leak_counter();
     let last_activity = fs.last_activity();
     let dav_server = DavHandler::builder()
-        .strip_prefix(token_path_prefix.clone())
         .filesystem(Box::new(fs))
         .locksystem(FakeLs::new())
         .build_handler();
@@ -288,12 +276,12 @@ pub async fn mount_container(
     let server_handle = tokio::spawn(serve_webdav_loop(
         listener,
         dav_server,
-        token_path_prefix.clone(),
+        session_token.clone(),
         shutdown_rx,
     ));
 
     // Netzlaufwerk bzw. Verzeichnis einbinden
-    if let Err(e) = run_mount_command(&drive_str, bound_port, &session_token) {
+    if let Err(e) = run_mount_command(drive_letter, bound_port, &session_token) {
         let _ = shutdown_tx.send(true);
         let _ = server_handle.await;
         return Err(e);
@@ -393,7 +381,10 @@ pub async fn mount_container(
         println!();
         println!("  • Container:    {}", container_path.display());
         #[cfg(windows)]
-        println!("  • Netzlaufwerk: {} (im Windows Explorer bereit)", ui::cyan(&drive_str));
+        println!(
+            "  • Netzlaufwerk: {} (im Windows Explorer bereit)",
+            ui::cyan(&drive_str)
+        );
         #[cfg(not(windows))]
         {
             if let Some(mp) = mount_point {
@@ -402,12 +393,14 @@ pub async fn mount_container(
                 println!("  • Modus:        WebDAV Userland-VFS");
             }
         }
-        println!("  • WebDAV-URL:   http://127.0.0.1:{}/{}/ (Session-Token geschützt)", bound_port, session_token);
+        println!(
+            "  • WebDAV-URL:   http://127.0.0.1:{}/ (lokal geschützt)",
+            bound_port
+        );
         #[cfg(not(windows))]
         {
-            println!("  • gio Befehl:   gio mount dav://127.0.0.1:{}/{}/", bound_port, session_token);
+            for line in format_linux_mount_instructions(bound_port, &session_token, mount_point) {
-            if let Some(mp) = mount_point {
+                println!("{}", line);
-                println!("  • davfs2:       mount -t davfs http://127.0.0.1:{}/{}/ {}", bound_port, session_token, mp.display());
             }
         }
         if let Some(secs) = idle_timeout {
@@ -429,9 +422,15 @@ pub async fn mount_container(
         }
         println!();
         #[cfg(windows)]
-        println!("  [{}] Drücke [Ctrl+C] oder nutze das Tray-Icon zum Beenden.", ui::yellow("Tipp"));
+        println!(
+            "  [{}] Drücke [Ctrl+C] oder nutze das Tray-Icon zum Beenden.",
+            ui::yellow("Tipp")
+        );
         #[cfg(not(windows))]
-        println!("  [{}] Drücke [Ctrl+C] zum sicheren Beenden.", ui::yellow("Tipp"));
+        println!(
+            "  [{}] Drücke [Ctrl+C] zum sicheren Beenden.",
+            ui::yellow("Tipp")
+        );
         println!();
     }
 
@@ -439,11 +438,13 @@ pub async fn mount_container(
     #[cfg(windows)]
     let (console_close_tx, mut console_close_rx) = tokio::sync::mpsc::channel::<()>(1);
     #[cfg(windows)]
-    let _console_guard = crate::windows::start_console_ctrl_monitor(console_close_tx, drive_letter).ok();
+    let _console_guard =
+        crate::windows::start_console_ctrl_monitor(console_close_tx, drive_letter).ok();
 
     // Unix Signale (SIGTERM, SIGHUP)
     #[cfg(unix)]
-    let mut sigterm = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()).ok();
+    let mut sigterm =
+        tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()).ok();
     #[cfg(unix)]
     let mut sighup = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::hangup()).ok();
 
@@ -556,7 +557,11 @@ pub async fn mount_container(
     } else {
         #[cfg(windows)]
         {
-            print!("  {} Trenne Windows-Netzlaufwerk {} ... ", ui::dim("[-]"), drive_str);
+            print!(
+                "  {} Trenne Windows-Netzlaufwerk {} ... ",
+                ui::dim("[-]"),
+                drive_str
+            );
             let _ = std::io::Write::flush(&mut std::io::stdout());
 
             // Automatisches Unmount
@@ -580,7 +585,11 @@ pub async fn mount_container(
         // Storage-Kompaktierung (Incremental Vacuum), falls freie Seiten existieren
         if let Ok(freelist) = db.freelist_count() {
             if freelist > 0 {
-                print!("  {} Führe Storage-Kompaktierung aus ({} freie Seiten) ... ", ui::dim("[-]"), freelist);
+                print!(
+                    "  {} Führe Storage-Kompaktierung aus ({} freie Seiten) ... ",
+                    ui::dim("[-]"),
+                    freelist
+                );
                 let _ = std::io::Write::flush(&mut std::io::stdout());
                 match db.incremental_vacuum(None) {
                     Ok(freed) => println!("{} ({} Seiten freigegeben)", ui::green("OK"), freed),
@@ -598,19 +607,108 @@ pub async fn mount_container(
             println!("{}", ui::green("OK"));
         }
 
+        let blocked_leaks = fs_leak_counter.load(Ordering::Relaxed);
+        if blocked_leaks > 0 {
+            println!(
+                "  • Anti-Leak Shield:  {} Zugriffe auf Metadaten-/Leak-Dateien blockiert.",
+                ui::cyan(&blocked_leaks.to_string())
+            );
+        }
+
         println!();
-        println!("{} Sanctum Container wurde sicher und vollständig geschlossen.", ui::green("✔"));
+        println!(
+            "{} Sanctum Container wurde sicher und vollständig geschlossen.",
+            ui::green("✔")
+        );
         println!();
     }
+
+    drop(db);
+    // S-10: Verifikation und Bereinigung von temporären SQLite WAL- und SHM-Dateien
+    let base_os = container_path.as_os_str().to_os_string();
+    let mut wal = base_os.clone();
+    wal.push("-wal");
+    let _ = std::fs::remove_file(wal);
+    let mut shm = base_os;
+    shm.push("-shm");
+    let _ = std::fs::remove_file(shm);
+
     Ok(())
 }
 
-/// Überprüft, ob ein Host-Header auf Loopback (127.0.0.1, localhost, [::1]) zeigt (Anti-DNS-Rebinding).
+/// Überprüft, ob ein Host-Header exakt auf Loopback (127.0.0.1, localhost, [::1], ::1) zeigt (Anti-DNS-Rebinding & S-06).
+/// Striktes Parsing von Host und Port ohne anfällige starts_with-Präfixprüfungen.
 pub fn is_loopback_host(host_str: &str) -> bool {
-    let host_lower = host_str.to_ascii_lowercase();
+    let host_trimmed = host_str.trim().to_ascii_lowercase();
-    host_lower.starts_with("127.0.0.1")
+    if host_trimmed.is_empty() {
-        || host_lower.starts_with("localhost")
+        return false;
-        || host_lower.starts_with("[::1]")
+    }
+
+    if host_trimmed == "::1" {
+        return true;
+    }
+
+    let host_part = if host_trimmed.starts_with('[') {
+        // IPv6 bracketed: [::1] oder [::1]:port
+        if let Some(bracket_end) = host_trimmed.find(']') {
+            let inside = &host_trimmed[1..bracket_end];
+            let after = &host_trimmed[bracket_end + 1..];
+            if !after.is_empty() {
+                if !after.starts_with(':') {
+                    return false;
+                }
+                if after[1..].parse::<u16>().is_err() {
+                    return false;
+                }
+            }
+            inside
+        } else {
+            return false;
+        }
+    } else {
+        // IPv4 oder Hostname: localhost, localhost:8443, 127.0.0.1, 127.0.0.1:8443
+        if let Some((h, p)) = host_trimmed.rsplit_once(':') {
+            if p.parse::<u16>().is_ok() {
+                h
+            } else {
+                return false;
+            }
+        } else {
+            &host_trimmed
+        }
+    };
+
+    matches!(host_part, "127.0.0.1" | "localhost" | "::1")
+}
+
+/// Erzeugt die plattformspezifischen Linux-Mount-Anweisungen und Authentifizierungsdaten (M-03).
+pub fn format_linux_mount_instructions(
+    port: u16,
+    token: &str,
+    mount_point: Option<&std::path::Path>,
+) -> Vec<String> {
+    let mut lines = Vec::new();
+    lines.push(format!(
+        "  • WebDAV-Auth:  Benutzer: sanctum | Token: {}",
+        token
+    ));
+    lines.push(format!(
+        "  • gio Befehl:   echo {} | gio mount dav://sanctum@127.0.0.1:{}/",
+        token, port
+    ));
+    if let Some(mp) = mount_point {
+        lines.push(format!(
+            "  • davfs2:       mount -t davfs -o username=sanctum http://127.0.0.1:{}/ {}",
+            port,
+            mp.display()
+        ));
+    } else {
+        lines.push(format!(
+            "  • davfs2:       mount -t davfs -o username=sanctum http://127.0.0.1:{}/ /mnt/sanctum",
+            port
+        ));
+    }
+    lines
 }
 
 /// Maximale Anzahl gleichzeitiger Verbindungen zum lokalen WebDAV-Endpunkt (Schutz gegen Socket-Exhaustion).
@@ -619,14 +717,81 @@ const MAX_CONCURRENT_DAV_CONNECTIONS: usize = 64;
 /// Timeout für das Lesen von HTTP-Headern (Schutz gegen Slowloris-Angriffe auf Loopback).
 const HTTP_HEADER_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(15);
 
-/// Führt die asynchrone WebDAV HTTP-Server-Schleife mit Session-Token & Host-Header Sicherheits-Middleware aus.
+/// Hilfsfunktion zur Validierung von HTTP Basic Auth.
+/// Unterstützt Format `username:password` (wobei Passwort dem Session-Token entspricht).
+/// SA-06: Verwendet strikten Constant-Time-Vergleich gegen Timing-Side-Channel-Angriffe.
+pub fn check_basic_auth(auth_header: &str, expected_token: &str) -> bool {
+    let auth_str = auth_header.trim();
+    let encoded = if let Some(rest) = auth_str.strip_prefix("Basic ") {
+        rest
+    } else if let Some(rest) = auth_str.strip_prefix("basic ") {
+        rest
+    } else {
+        return false;
+    };
+
+    use base64::Engine;
+    let decoded_bytes = match base64::engine::general_purpose::STANDARD.decode(encoded.trim()) {
+        Ok(bytes) => bytes,
+        Err(_) => return false,
+    };
+
+    let decoded_str = match std::str::from_utf8(&decoded_bytes) {
+        Ok(s) => s,
+        Err(_) => return false,
+    };
+
+    use subtle::ConstantTimeEq;
+    if let Some((_user, pass)) = decoded_str.split_once(':') {
+        pass.as_bytes().ct_eq(expected_token.as_bytes()).into()
+    } else {
+        false
+    }
+}
+
+/// Hilfsfunktion zur Validierung des X-Sanctum-Token Headers.
+/// SA-06: Verwendet strikten Constant-Time-Vergleich gegen Timing-Side-Channel-Angriffe.
+pub fn check_token_header(headers: &hyper::HeaderMap, expected_token: &str) -> bool {
+    use subtle::ConstantTimeEq;
+    if let Some(val) = headers.get("X-Sanctum-Token") {
+        if let Ok(val_str) = val.to_str() {
+            return val_str
+                .trim()
+                .as_bytes()
+                .ct_eq(expected_token.as_bytes())
+                .into();
+        }
+    }
+    false
+}
+
+/// Prüft, ob eine URI oder deren Query-Parameter das sensible Session-Token enthält (SA-05 / CWE-598).
+pub fn uri_contains_token(uri: &hyper::Uri, session_token: &str) -> bool {
+    if session_token.is_empty() {
+        return false;
+    }
+    uri.path().contains(session_token) || uri.query().unwrap_or("").contains(session_token)
+}
+
+/// Erzeugt eine standardkonforme HTTP 401 Unauthorized Antwort mit WWW-Authenticate Header.
+fn unauthorized_response() -> hyper::Response<dav_server::body::Body> {
+    hyper::Response::builder()
+        .status(hyper::StatusCode::UNAUTHORIZED)
+        .header(hyper::header::WWW_AUTHENTICATE, "Basic realm=\"Sanctum\"")
+        .header(hyper::header::CONTENT_LENGTH, "0")
+        .body(dav_server::body::Body::empty())
+        .unwrap()
+}
+
+/// Führt die asynchrone WebDAV HTTP-Server-Schleife mit Header-basierter Authentifizierung & Host-Header Sicherheits-Middleware aus.
 pub async fn serve_webdav_loop(
     listener: TcpListener,
     dav_server: DavHandler,
-    token_path_prefix: String,
+    session_token: String,
     mut shutdown_rx: watch::Receiver<bool>,
 ) {
-    let conn_semaphore = std::sync::Arc::new(tokio::sync::Semaphore::new(MAX_CONCURRENT_DAV_CONNECTIONS));
+    let conn_semaphore =
+        std::sync::Arc::new(tokio::sync::Semaphore::new(MAX_CONCURRENT_DAV_CONNECTIONS));
 
     loop {
         tokio::select! {
@@ -654,14 +819,14 @@ pub async fn serve_webdav_loop(
 
                 let io = TokioIo::new(stream);
                 let handler = dav_server.clone();
-                let expected_prefix = token_path_prefix.clone();
+                let expected_token = session_token.clone();
 
                 tokio::spawn(async move {
                     let _permit = permit; // Permit wird bei Verbindungsende automatisch freigegeben
 
                     let service = service_fn(move |req| {
                         let h = handler.clone();
-                        let prefix = expected_prefix.clone();
+                        let token = expected_token.clone();
                         async move {
                             // 1. RT-02: Strikte Fail-Closed Host-Header Validierung (Anti-DNS-Rebinding & Anti-Spoofing)
                             let host_valid = match req.headers().get(hyper::header::HOST) {
@@ -679,22 +844,46 @@ pub async fn serve_webdav_loop(
                                 );
                                 let res = hyper::Response::builder()
                                     .status(hyper::StatusCode::FORBIDDEN)
+                                    .header(hyper::header::CONTENT_LENGTH, "0")
                                     .body(dav_server::body::Body::empty())
                                     .unwrap();
                                 return Ok::<_, Infallible>(res);
                             }
 
-                            // 2. Session-Token Pfadprüfung (Loopback-Schutz gegen unbefugte lokale Prozesse & Browser CSRF)
+                            // 2. SA-05: Verhindere Session-Token in Request-URI oder Query (CWE-598).
-                            let path = req.uri().path();
+                            //    Session-Tokens dürfen ausschließlich in HTTP-Headern übertragen werden.
-                            if !path.starts_with(&prefix) {
+                            if uri_contains_token(req.uri(), &token) {
-                                debug!("Abgewiesener Zugriff ohne gültiges Session-Token: {}", path);
+                                warn!("Abgewiesener Zugriff: Session-Token in URI/Query übermittelt (SA-05 / CWE-598)");
                                 let res = hyper::Response::builder()
                                     .status(hyper::StatusCode::FORBIDDEN)
+                                    .header(hyper::header::CONTENT_LENGTH, "0")
                                     .body(dav_server::body::Body::empty())
                                     .unwrap();
                                 return Ok::<_, Infallible>(res);
                             }
 
+                            // 3. SA-05 & SA-06: Header-basierte Authentifizierung mit Constant-Time Token-Vergleich
+                            //    a) HTTP Basic Auth (Authorization: Basic ...)
+                            //    b) Header X-Sanctum-Token
+                            let mut authenticated = false;
+
+                            if let Some(auth_val) = req.headers().get(hyper::header::AUTHORIZATION) {
+                                if let Ok(auth_str) = auth_val.to_str() {
+                                    if check_basic_auth(auth_str, &token) {
+                                        authenticated = true;
+                                    }
+                                }
+                            }
+
+                            if !authenticated && check_token_header(req.headers(), &token) {
+                                authenticated = true;
+                            }
+
+                            if !authenticated {
+                                debug!("Abgewiesener unauthentifizierter Zugriff auf: {}", req.uri().path());
+                                return Ok::<_, Infallible>(unauthorized_response());
+                            }
+
                             Ok::<_, Infallible>(h.handle(req).await)
                         }
                     });
@@ -705,7 +894,6 @@ pub async fn serve_webdav_loop(
                     builder.header_read_timeout(HTTP_HEADER_READ_TIMEOUT);
 
                     if let Err(err) = builder.serve_connection(io, service).await {
-                        // Client-Disconnects im Explorer oder Timeout-Drops sind normal
                         debug!("HTTP-Verbindungsende: {:?}", err);
                     }
                 });
@@ -744,6 +932,88 @@ mod tests {
         assert_eq!(format_drive('s'), "S:");
         assert_eq!(format_drive('Z'), "Z:");
     }
+
+    #[test]
+    fn test_check_basic_auth() {
+        use base64::Engine;
+        let token = "deadbeefcafebabe0123456789abcdef";
+        let creds = format!("sanctum:{}", token);
+        let header_val = format!(
+            "Basic {}",
+            base64::engine::general_purpose::STANDARD.encode(creds)
+        );
+        assert!(check_basic_auth(&header_val, token));
+
+        // Kleingeschriebenes basic Präfix
+        let lower_header = format!(
+            "basic {}",
+            base64::engine::general_purpose::STANDARD.encode(format!("user:{}", token))
+        );
+        assert!(check_basic_auth(&lower_header, token));
+
+        // Falsches Token
+        let wrong_token_header = format!(
+            "Basic {}",
+            base64::engine::general_purpose::STANDARD.encode("sanctum:wrongtoken")
+        );
+        assert!(!check_basic_auth(&wrong_token_header, token));
+
+        // Ungültiges Base64 oder Format
+        assert!(!check_basic_auth("Basic !!!notbase64!!!", token));
+        assert!(!check_basic_auth("Bearer 12345", token));
+        assert!(!check_basic_auth("", token));
+    }
+
+    #[test]
+    fn test_check_token_header() {
+        let token = "deadbeefcafebabe0123456789abcdef";
+        let mut headers = hyper::HeaderMap::new();
+        assert!(!check_token_header(&headers, token));
+
+        headers.insert("X-Sanctum-Token", token.parse().unwrap());
+        assert!(check_token_header(&headers, token));
+
+        let mut wrong_headers = hyper::HeaderMap::new();
+        wrong_headers.insert("X-Sanctum-Token", "wrong".parse().unwrap());
+        assert!(!check_token_header(&wrong_headers, token));
+    }
+
+    #[test]
+    fn test_uri_contains_token_rejection() {
+        let token = "deadbeefcafebabe0123456789abcdef";
+
+        // Token im Pfad
+        let uri_path: hyper::Uri = format!("http://127.0.0.1:8443/{}/Photos/vacation.jpg", token)
+            .parse()
+            .unwrap();
+        assert!(uri_contains_token(&uri_path, token));
+
+        // Token im Query-String
+        let uri_query: hyper::Uri =
+            format!("http://127.0.0.1:8443/Photos/vacation.jpg?token={}", token)
+                .parse()
+                .unwrap();
+        assert!(uri_contains_token(&uri_query, token));
+
+        // Harmloser Pfad ohne Token
+        let uri_clean: hyper::Uri = "http://127.0.0.1:8443/Photos/vacation.jpg".parse().unwrap();
+        assert!(!uri_contains_token(&uri_clean, token));
+
+        // Leeres Token darf niemals matchen
+        assert!(!uri_contains_token(&uri_clean, ""));
+    }
+
+    #[test]
+    fn test_m03_format_linux_mount_instructions() {
+        let token = "fedcba9876543210fedcba9876543210";
+        let instructions =
+            format_linux_mount_instructions(8443, token, Some(std::path::Path::new("/mnt/secure")));
+
+        let all_text = instructions.join("\n");
+        assert!(all_text.contains("Benutzer: sanctum"));
+        assert!(all_text.contains(token));
+        assert!(all_text.contains("gio mount dav://sanctum@127.0.0.1:8443/"));
+        assert!(all_text
+            .contains("mount -t davfs -o username=sanctum http://127.0.0.1:8443/ /mnt/secure"));
+    }
 }
-
-

src/pathutil.rs

@@ -0,0 +1,77 @@
+use anyhow::{bail, Result};
+
+/// Prüft, ob ein Name Path-Traversal-Muster oder Pfadtrennzeichen enthält (S-02).
+pub fn is_path_traversal(name: &str) -> bool {
+    name.is_empty()
+        || name == "."
+        || name == ".."
+        || name.contains('/')
+        || name.contains('\\')
+        || name.contains('\0')
+}
+
+/// Validiert einen Datei- oder Verzeichnisnamen gegen Path-Traversal, Null-Bytes,
+/// unzulässige Steuerzeichen und Windows-reservierte Gerätenamen (S-08, R-03).
+pub fn validate_node_name(name: &str) -> Result<()> {
+    if name.is_empty() {
+        bail!("Dateiname darf nicht leer sein.");
+    }
+    if name == "." || name == ".." {
+        bail!(
+            "Ungültiger Dateiname (Verzeichnisreferenz verboten): '{}'",
+            name
+        );
+    }
+    if name.contains('/') || name.contains('\\') || name.contains('\0') {
+        bail!(
+            "Dateiname enthält unzulässige Trennzeichen oder Null-Bytes: '{}'",
+            name
+        );
+    }
+    for c in name.chars() {
+        if (c as u32) < 0x20 {
+            bail!("Dateiname enthält Steuerzeichen: '{}'", name);
+        }
+    }
+
+    // Windows reservierte Gerätenamen (CON, PRN, AUX, NUL, COM1..9, LPT1..9)
+    let base_name = if let Some(dot_idx) = name.find('.') {
+        &name[..dot_idx]
+    } else {
+        name
+    };
+    let base_upper = base_name.to_ascii_uppercase();
+    let reserved = [
+        "CON", "PRN", "AUX", "NUL", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8",
+        "COM9", "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9",
+    ];
+    if reserved.contains(&base_upper.as_str()) {
+        bail!(
+            "Dateiname '{}' kollidiert mit einem reservierten Windows-Gerätenamen.",
+            name
+        );
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_validate_node_name() {
+        assert!(validate_node_name("test.txt").is_ok());
+        assert!(validate_node_name("").is_err());
+        assert!(validate_node_name(".").is_err());
+        assert!(validate_node_name("..").is_err());
+        assert!(validate_node_name("foo/bar").is_err());
+        assert!(validate_node_name("foo\\bar").is_err());
+        assert!(validate_node_name("CON").is_err());
+        assert!(validate_node_name("aux.txt").is_err());
+        assert!(validate_node_name("nul").is_err());
+        assert!(validate_node_name("com1.log").is_err());
+        assert!(validate_node_name("line\nbreak").is_err());
+        assert!(validate_node_name("null\0byte").is_err());
+    }
+}

src/recovery.rs

@@ -6,8 +6,8 @@ use anyhow::{bail, Context, Result};
 use serde::{Deserialize, Serialize};
 
 use crate::crypto::{
-    derive_kek, generate_dummy_slot, mnemonic_to_dek, wrap_slot0_payload,
+    decrypt_chunk, derive_kek, generate_dummy_slot, mnemonic_to_dek, validate_password,
-    wrap_slot1_payload, KdfParams, FORMAT_VERSION,
+    wrap_slot0_payload, wrap_slot1_payload, KdfParams, FORMAT_VERSION,
 };
 use crate::storage::{ContainerMeta, Database, SlotMeta};
 
@@ -85,11 +85,31 @@ impl HeaderBackup {
         let mut slots = Vec::new();
 
         if !self.slots.is_empty() {
+            if self.slots.len() > 2 {
+                bail!(
+                    "Ungültige Slot-Anzahl im Backup: {} (maximal 2 erlaubt)",
+                    self.slots.len()
+                );
+            }
+            let mut seen_ids = std::collections::HashSet::new();
             for s in &self.slots {
-                let salt_bytes = hex::decode(&s.kdf_salt_hex)
+                if s.slot_id > 1 {
-                    .context("Ungültige Hex-Kodierung für KDF-Salt")?;
+                    bail!("Ungültige Slot-ID {} im Backup: Es sind ausschließlich die Slot-IDs 0 und 1 erlaubt", s.slot_id);
+                }
+                if !seen_ids.insert(s.slot_id) {
+                    bail!("Doppelte Slot-ID {} im Backup entdeckt", s.slot_id);
+                }
+                crate::crypto::validate_kdf_params(&s.kdf_params).map_err(|e| {
+                    anyhow::anyhow!("KDF-Parameter in Slot {} ungültig: {e}", s.slot_id)
+                })?;
+
+                let salt_bytes =
+                    hex::decode(&s.kdf_salt_hex).context("Ungültige Hex-Kodierung für KDF-Salt")?;
                 if salt_bytes.len() != 16 {
-                    bail!("Ungültige Salt-Länge im Backup: erwartet 16 Bytes, erhalten {}", salt_bytes.len());
+                    bail!(
+                        "Ungültige Salt-Länge im Backup: erwartet 16 Bytes, erhalten {}",
+                        salt_bytes.len()
+                    );
                 }
                 let mut kdf_salt = [0u8; 16];
                 kdf_salt.copy_from_slice(&salt_bytes);
@@ -97,10 +117,24 @@ impl HeaderBackup {
                 let wrapped_dek = hex::decode(&s.wrapped_dek_hex)
                     .context("Ungültige Hex-Kodierung für wrapped_dek")?;
 
+                if s.slot_id == 0 {
+                    if wrapped_dek.len() != 40 && wrapped_dek.len() != 32 {
+                        bail!("Ungültige wrapped_dek-Länge in Slot 0: {} Bytes (erwartet: 40 oder 32)", wrapped_dek.len());
+                    }
+                } else if s.slot_id == 1 {
+                    if wrapped_dek.len() != 72 && wrapped_dek.len() != 64 && wrapped_dek.len() != 32
+                    {
+                        bail!("Ungültige wrapped_dek-Länge in Slot 1: {} Bytes (erwartet: 72, 64 oder 32)", wrapped_dek.len());
+                    }
+                }
+
                 let nonce_bytes = hex::decode(&s.header_nonce_hex)
                     .context("Ungültige Hex-Kodierung für Header-Nonce")?;
                 if nonce_bytes.len() != 12 {
-                    bail!("Ungültige Nonce-Länge im Backup: erwartet 12 Bytes, erhalten {}", nonce_bytes.len());
+                    bail!(
+                        "Ungültige Nonce-Länge im Backup: erwartet 12 Bytes, erhalten {}",
+                        nonce_bytes.len()
+                    );
                 }
                 let mut header_nonce = [0u8; 12];
                 header_nonce.copy_from_slice(&nonce_bytes);
@@ -108,7 +142,10 @@ impl HeaderBackup {
                 let tag_bytes = hex::decode(&s.header_tag_hex)
                     .context("Ungültige Hex-Kodierung für Header-Tag")?;
                 if tag_bytes.len() != 16 {
-                    bail!("Ungültige Tag-Länge im Backup: erwartet 16 Bytes, erhalten {}", tag_bytes.len());
+                    bail!(
+                        "Ungültige Tag-Länge im Backup: erwartet 16 Bytes, erhalten {}",
+                        tag_bytes.len()
+                    );
                 }
                 let mut header_tag = [0u8; 16];
                 header_tag.copy_from_slice(&tag_bytes);
@@ -123,12 +160,19 @@ impl HeaderBackup {
                     header_tag,
                 });
             }
+
+            if !seen_ids.contains(&0) {
+                bail!("Ungültiges Backup: Slot 0 (Standard/Decoy Vault) fehlt");
+            }
         } else {
             // Fallback für alte Backups ohne slots-Array
-            let salt_bytes = hex::decode(&self.kdf_salt_hex)
+            let salt_bytes =
-                .context("Ungültige Hex-Kodierung für KDF-Salt")?;
+                hex::decode(&self.kdf_salt_hex).context("Ungültige Hex-Kodierung für KDF-Salt")?;
             if salt_bytes.len() != 16 {
-                bail!("Ungültige Salt-Länge im Backup: erwartet 16 Bytes, erhalten {}", salt_bytes.len());
+                bail!(
+                    "Ungültige Salt-Länge im Backup: erwartet 16 Bytes, erhalten {}",
+                    salt_bytes.len()
+                );
             }
             let mut kdf_salt = [0u8; 16];
             kdf_salt.copy_from_slice(&salt_bytes);
@@ -139,7 +183,10 @@ impl HeaderBackup {
             let nonce_bytes = hex::decode(&self.header_nonce_hex)
                 .context("Ungültige Hex-Kodierung für Header-Nonce")?;
             if nonce_bytes.len() != 12 {
-                bail!("Ungültige Nonce-Länge im Backup: erwartet 12 Bytes, erhalten {}", nonce_bytes.len());
+                bail!(
+                    "Ungültige Nonce-Länge im Backup: erwartet 12 Bytes, erhalten {}",
+                    nonce_bytes.len()
+                );
             }
             let mut header_nonce = [0u8; 12];
             header_nonce.copy_from_slice(&nonce_bytes);
@@ -147,7 +194,10 @@ impl HeaderBackup {
             let tag_bytes = hex::decode(&self.header_tag_hex)
                 .context("Ungültige Hex-Kodierung für Header-Tag")?;
             if tag_bytes.len() != 16 {
-                bail!("Ungültige Tag-Länge im Backup: erwartet 16 Bytes, erhalten {}", tag_bytes.len());
+                bail!(
+                    "Ungültige Tag-Länge im Backup: erwartet 16 Bytes, erhalten {}",
+                    tag_bytes.len()
+                );
             }
             let mut header_tag = [0u8; 16];
             header_tag.copy_from_slice(&tag_bytes);
@@ -180,19 +230,28 @@ impl HeaderBackup {
 /// Sichert die Header-Metadaten eines Containers in eine externe Backup-Datei (.sanctum.hdr).
 pub fn export_header_backup(container_path: &Path, backup_path: &Path) -> Result<()> {
     if !container_path.exists() {
-        bail!("Containerdatei '{}' existiert nicht.", container_path.display());
+        bail!(
+            "Containerdatei '{}' existiert nicht.",
+            container_path.display()
+        );
     }
 
     let db = Database::open(container_path)
         .context("Konnte Container-Datenbank zum Lesen des Headers nicht öffnen")?;
-    let meta = db.read_meta().context("Konnte Container-Header nicht lesen")?;
+    let meta = db
+        .read_meta()
+        .context("Konnte Container-Header nicht lesen")?;
 
     let backup = HeaderBackup::from_meta(&meta);
     let json_data = serde_json::to_string_pretty(&backup)
         .context("Fehler beim Serialisieren des Header-Backups")?;
 
-    fs::write(backup_path, json_data)
+    fs::write(backup_path, json_data).with_context(|| {
-        .with_context(|| format!("Konnte Backup-Datei '{}' nicht schreiben", backup_path.display()))?;
+        format!(
+            "Konnte Backup-Datei '{}' nicht schreiben",
+            backup_path.display()
+        )
+    })?;
 
     Ok(())
 }
@@ -203,25 +262,54 @@ pub fn restore_header_backup(container_path: &Path, backup_path: &Path) -> Resul
         bail!("Backup-Datei '{}' existiert nicht.", backup_path.display());
     }
 
-    let content = fs::read_to_string(backup_path)
+    let content = fs::read_to_string(backup_path).with_context(|| {
-        .with_context(|| format!("Konnte Backup-Datei '{}' nicht lesen", backup_path.display()))?;
+        format!(
+            "Konnte Backup-Datei '{}' nicht lesen",
+            backup_path.display()
+        )
+    })?;
 
     let backup: HeaderBackup = serde_json::from_str(&content)
         .context("Ungültiges Backup-Dateiformat (JSON-Parsing fehlgeschlagen)")?;
 
     let meta = backup.to_meta()?;
 
-    let db = Database::open(container_path)
+    let db = Database::open(container_path).context("Konnte Ziel-Containerdatei nicht öffnen")?;
-        .context("Konnte Ziel-Containerdatei nicht öffnen")?;
 
     db.restore_meta(&meta)
         .context("Fehler beim Wiederherstellen der Header-Tabelle in der Datenbank")?;
 
-    db.checkpoint().context("Fehler beim WAL-Checkpoint nach Header-Wiederherstellung")?;
+    db.checkpoint()
+        .context("Fehler beim WAL-Checkpoint nach Header-Wiederherstellung")?;
 
     Ok(())
 }
 
+/// Ermittelt automatisch, ob ein Notfallschlüssel zu Slot 0 (Standard/Decoy) oder Slot 1 (Hidden Vault) gehört (S-05).
+pub fn detect_recovery_key_slot(db: &Database, dek: &[u8; 32], version: u32) -> Result<u32> {
+    if let Ok(Some(carrier_id)) = db.find_carrier_node_id() {
+        if let Ok(Some(chunk0)) = db.read_chunk(carrier_id, 0) {
+            let is_dek0 = decrypt_chunk(
+                dek,
+                carrier_id,
+                0,
+                &chunk0.ciphertext,
+                &chunk0.nonce,
+                &chunk0.tag,
+                version,
+                chunk0.generation,
+            )
+            .is_ok();
+            if is_dek0 {
+                return Ok(0);
+            } else {
+                return Ok(1);
+            }
+        }
+    }
+    Ok(0)
+}
+
 /// Rekonstruiert einen Slot des Container-Headers mithilfe des 24-Wort BIP-39 Notfallschlüssels
 /// und initialisiert ein neues Master-Passwort für den entsprechenden Slot (0 = Decoy, 1 = Hidden Vault).
 pub fn restore_slot_from_recovery_key(
@@ -229,18 +317,19 @@ pub fn restore_slot_from_recovery_key(
     recovery_key: &str,
     new_password: &str,
     target_slot_id: u32,
+    dek_0: Option<&[u8; 32]>,
 ) -> Result<()> {
     if !container_path.exists() {
-        bail!("Containerdatei '{}' existiert nicht.", container_path.display());
+        bail!(
+            "Containerdatei '{}' existiert nicht.",
+            container_path.display()
+        );
     }
 
-    if new_password.trim().is_empty() {
+    validate_password(new_password)?;
-        bail!("Das neue Master-Passwort darf nicht leer sein.");
-    }
 
     // 1. DEK aus 24-Wort-Phrase dekodieren & validieren
-    let dek = mnemonic_to_dek(recovery_key)
+    let dek = mnemonic_to_dek(recovery_key).context("Ungültiger 24-Wort Notfallschlüssel")?;
-        .context("Ungültiger 24-Wort Notfallschlüssel")?;
 
     // 2. Neuen KEK mit frischem Salt ableiten
     let mut salt = [0u8; 16];
@@ -250,17 +339,18 @@ pub fn restore_slot_from_recovery_key(
     let kek = derive_kek(new_password, &salt, &kdf_params)
         .context("Schlüsselableitung für neues Passwort fehlgeschlagen")?;
 
-    let db = Database::open(container_path)
+    let db = Database::open(container_path).context("Konnte Container-Datenbank nicht öffnen")?;
-        .context("Konnte Container-Datenbank nicht öffnen")?;
 
     let carrier_node_id = db.find_carrier_node_id()?.unwrap_or(0);
 
     let mut existing_slots = db.read_slots().unwrap_or_default();
 
     let new_slot = if target_slot_id == 1 {
-        // Für Slot 1 wird DEK_0 benötigt (z. B. aus vorhandenem Slot 0)
+        // Für Slot 1 wird der echte DEK_0 benötigt (S-05)
-        let dek_0_bytes = [0u8; 32];
+        let dek_0_bytes = dek_0.ok_or_else(|| {
-        let (wrapped, nonce, tag) = wrap_slot1_payload(&kek, &dek, &dek_0_bytes, carrier_node_id)?;
+            anyhow::anyhow!("Für die Wiederherstellung von Slot 1 (Hidden Vault) wird der DEK von Slot 0 (Standard-Vault) benötigt.")
+        })?;
+        let (wrapped, nonce, tag) = wrap_slot1_payload(&kek, &dek, dek_0_bytes, carrier_node_id)?;
         SlotMeta {
             slot_id: 1,
             version: FORMAT_VERSION,
@@ -289,7 +379,7 @@ pub fn restore_slot_from_recovery_key(
     existing_slots.push(new_slot);
     existing_slots.sort_by_key(|s| s.slot_id);
 
-    // Falls Slot 1 fehlt, Dummy-Slot 1 ergänzen für Plausible Deniability
+    // Falls Slot 1 fehlt, Dummy-Slot 1 ergänzen für Dummy-Slot-Längenparität
     if !existing_slots.iter().any(|s| s.slot_id == 1) {
         let (dummy_dek, dummy_nonce, dummy_tag, dummy_salt) = generate_dummy_slot();
         let dummy_slot = SlotMeta {
@@ -322,7 +412,8 @@ pub fn restore_slot_from_recovery_key(
     db.restore_meta(&meta)
         .context("Fehler beim Schreiben des rekonstruierten Headers")?;
 
-    db.checkpoint().context("Fehler beim WAL-Checkpoint nach Header-Rekonstruktion")?;
+    db.checkpoint()
+        .context("Fehler beim WAL-Checkpoint nach Header-Rekonstruktion")?;
 
     Ok(())
 }
@@ -333,7 +424,74 @@ pub fn restore_header_from_recovery_key(
     recovery_key: &str,
     new_password: &str,
 ) -> Result<()> {
-    restore_slot_from_recovery_key(container_path, recovery_key, new_password, 0)
+    restore_slot_from_recovery_key(container_path, recovery_key, new_password, 0, None)
+}
+
+/// Führt ein vollständiges Rekeying eines Containers durch (K-03).
+/// Generiert einen neuen kryptografischen DEK, verschlüsselt alle Chunks um,
+/// verpackt den neuen DEK mit dem bestehenden Passwort und gibt das neue
+/// 24-Wort Notfallblatt (BIP-39 Mnemonic) zurück.
+/// Das alte Notfallblatt wird dadurch unwiderruflich ungültig.
+pub fn rekey_container(container_path: &Path, password: &str) -> Result<String> {
+    if !container_path.exists() {
+        bail!(
+            "Containerdatei '{}' existiert nicht.",
+            container_path.display()
+        );
+    }
+
+    let db = Database::open(container_path).context("Konnte Container-Datenbank nicht öffnen")?;
+    let meta = db
+        .read_meta()
+        .context("Konnte Container-Header nicht lesen")?;
+    let keys = meta.authenticate(password).ok_or_else(|| {
+        anyhow::anyhow!("Ungültiges Master-Passwort! Authentifizierung fehlgeschlagen.")
+    })?;
+
+    let old_dek = keys.dek().clone();
+    let slot_id = keys.slot_id();
+    let version = keys.version();
+    let carrier_dek = keys.carrier_dek();
+    let carrier_node_id = keys.carrier_node_id();
+
+    // 1. Neuen DEK generieren
+    let new_dek = crate::crypto::generate_dek();
+
+    // 2. Chunks des aktiven Vaults umverschlüsseln
+    db.rekey_vault(slot_id, &old_dek, &new_dek, version)?;
+
+    // 3. Neuen KEK ableiten und DEK neu verpacken
+    let new_salt = crate::crypto::generate_salt();
+    let new_params = KdfParams::default();
+    let new_kek = derive_kek(password, &new_salt, &new_params)?;
+
+    let (new_wrapped_dek, new_nonce, new_tag) = if slot_id == 1 {
+        let c_dek = carrier_dek
+            .ok_or_else(|| anyhow::anyhow!("DEK_0 (Träger-Schlüssel) für Slot 1 fehlt"))?;
+        let c_nid = carrier_node_id.unwrap_or(0);
+        wrap_slot1_payload(&new_kek, &new_dek, &c_dek, c_nid)?
+    } else {
+        let c_nid = carrier_node_id.unwrap_or(0);
+        wrap_slot0_payload(&new_kek, &new_dek, c_nid)?
+    };
+
+    db.update_slot_keys(
+        slot_id,
+        &new_salt,
+        &new_params,
+        &new_wrapped_dek,
+        &new_nonce,
+        &new_tag,
+    )?;
+
+    // 4. Metadaten-MAC mit neuem DEK aktualisieren
+    db.set_active_slot_and_dek(slot_id, new_dek.clone());
+    db.update_metadata_mac()?;
+    db.checkpoint()?;
+
+    // 5. Neues BIP-39 Notfallblatt generieren
+    let new_phrase = crate::crypto::dek_to_mnemonic(&new_dek)?;
+    Ok(new_phrase)
 }
 
 #[cfg(test)]
@@ -345,8 +503,10 @@ mod tests {
     #[test]
     fn test_header_backup_and_restore() {
         let temp_dir = std::env::temp_dir();
-        let container_path: PathBuf = temp_dir.join(format!("test_backup_{}.sanctum", std::process::id()));
+        let container_path: PathBuf =
-        let backup_path: PathBuf = temp_dir.join(format!("test_backup_{}.sanctum.hdr", std::process::id()));
+            temp_dir.join(format!("test_backup_{}.sanctum", std::process::id()));
+        let backup_path: PathBuf =
+            temp_dir.join(format!("test_backup_{}.sanctum.hdr", std::process::id()));
 
         if container_path.exists() {
             let _ = fs::remove_file(&container_path);
@@ -358,8 +518,8 @@ mod tests {
         let password = "SuperSecretPassword2026!";
         let salt = generate_salt();
         let kdf_params = KdfParams {
-            memory_cost: 1024,
+            memory_cost: crate::crypto::MIN_MEMORY_COST_KIB,
-            time_cost: 1,
+            time_cost: crate::crypto::MIN_TIME_COST,
             parallelism: 1,
         };
         let kek = derive_kek(password, &salt, &kdf_params).unwrap();
@@ -367,7 +527,8 @@ mod tests {
         let (wrapped_dek, nonce, tag) = wrap_dek(&kek, &dek).unwrap();
 
         let db = Database::open(&container_path).unwrap();
-        db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag).unwrap();
+        db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag)
+            .unwrap();
         db.checkpoint().unwrap();
 
         // 1. Export
@@ -391,8 +552,13 @@ mod tests {
         let restored_db = Database::open(&container_path).unwrap();
         let meta = restored_db.read_meta().expect("Read restored meta");
         let restored_kek = derive_kek(password, &meta.kdf_salt, &meta.kdf_params).unwrap();
-        let active_dek = unwrap_dek(&restored_kek, &meta.wrapped_dek, &meta.header_nonce, &meta.header_tag)
+        let active_dek = unwrap_dek(
-            .expect("Unwrap restored DEK");
+            &restored_kek,
+            &meta.wrapped_dek,
+            &meta.header_nonce,
+            &meta.header_tag,
+        )
+        .expect("Unwrap restored DEK");
         assert_eq!(*dek, *active_dek);
 
         let _ = fs::remove_file(&container_path);
@@ -402,7 +568,8 @@ mod tests {
     #[test]
     fn test_restore_from_recovery_key() {
         let temp_dir = std::env::temp_dir();
-        let container_path: PathBuf = temp_dir.join(format!("test_rec_key_{}.sanctum", std::process::id()));
+        let container_path: PathBuf =
+            temp_dir.join(format!("test_rec_key_{}.sanctum", std::process::id()));
 
         if container_path.exists() {
             let _ = fs::remove_file(&container_path);
@@ -413,8 +580,8 @@ mod tests {
 
         let salt = generate_salt();
         let kdf_params = KdfParams {
-            memory_cost: 1024,
+            memory_cost: crate::crypto::MIN_MEMORY_COST_KIB,
-            time_cost: 1,
+            time_cost: crate::crypto::MIN_TIME_COST,
             parallelism: 1,
         };
         let kek = derive_kek(old_password, &salt, &kdf_params).unwrap();
@@ -425,7 +592,8 @@ mod tests {
         let phrase = crate::crypto::dek_to_mnemonic(&dek).unwrap();
 
         let db = Database::open(&container_path).unwrap();
-        db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag).unwrap();
+        db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag)
+            .unwrap();
         db.checkpoint().unwrap();
 
         // Header zerstören
@@ -441,8 +609,13 @@ mod tests {
         let rescued_db = Database::open(&container_path).unwrap();
         let meta = rescued_db.read_meta().expect("Read rescued meta");
         let new_kek = derive_kek(new_password, &meta.kdf_salt, &meta.kdf_params).unwrap();
-        let unwrapped = unwrap_dek(&new_kek, &meta.wrapped_dek, &meta.header_nonce, &meta.header_tag)
+        let unwrapped = unwrap_dek(
-            .expect("Unwrap rescued DEK");
+            &new_kek,
+            &meta.wrapped_dek,
+            &meta.header_nonce,
+            &meta.header_tag,
+        )
+        .expect("Unwrap rescued DEK");
         assert_eq!(*dek, *unwrapped);
 
         let _ = fs::remove_file(&container_path);

src/ui.rs

@@ -131,13 +131,25 @@ pub fn step(num: u8, total: u8, icon: &str, msg: &str) {
 pub fn print_recovery_phrase_card(phrase: &str) {
     let words: Vec<&str> = phrase.split_whitespace().collect();
     println!();
-    println!("{}", yellow("┌─────────────────────────────────────────────────────────────┐"));
+    println!(
-    println!("{}", yellow("│        ⚠️  24-WORT NOTFALL-WIEDERHERSTELLUNGSSCHLÜSSEL       │"));
+        "{}",
-    println!("{}", yellow("├─────────────────────────────────────────────────────────────┤"));
+        yellow("┌─────────────────────────────────────────────────────────────┐")
+    );
+    println!(
+        "{}",
+        yellow("│        ⚠️  24-WORT NOTFALL-WIEDERHERSTELLUNGSSCHLÜSSEL       │")
+    );
+    println!(
+        "{}",
+        yellow("├─────────────────────────────────────────────────────────────┤")
+    );
     println!("│ Falls Sie Ihr Master-Passwort vergessen oder der Header     │");
     println!("│ beschädigt wird, ist dies Ihre EINZIGE Rettung!             │");
     println!("│ Notieren Sie die Wörter in EXAKTER Reihenfolge auf Papier!  │");
-    println!("{}", yellow("├─────────────────────────────────────────────────────────────┤"));
+    println!(
+        "{}",
+        yellow("├─────────────────────────────────────────────────────────────┤")
+    );
 
     for row in 0..8 {
         let w1 = if row < words.len() {
@@ -158,7 +170,10 @@ pub fn print_recovery_phrase_card(phrase: &str) {
         println!("│  {:<18} {:<18} {:<18} │", cyan(&w1), cyan(&w2), cyan(&w3));
     }
 
-    println!("{}", yellow("└─────────────────────────────────────────────────────────────┘"));
+    println!(
+        "{}",
+        yellow("└─────────────────────────────────────────────────────────────┘")
+    );
     println!();
 }
 
@@ -204,7 +219,10 @@ pub fn print_verification_report(report: &crate::verify::VerificationReport) {
     println!("    - Daten-Chunks:     {}", report.total_chunks);
     if report.total_bytes_decrypted > 0 {
         let mb = report.total_bytes_decrypted as f64 / (1024.0 * 1024.0);
-        println!("    - Verifiziert:      {:.2} MB (vollständig entschlüsselt)", mb);
+        println!(
+            "    - Verifiziert:      {:.2} MB (vollständig entschlüsselt)",
+            mb
+        );
     }
 
     if !report.errors.is_empty() {
@@ -217,10 +235,15 @@ pub fn print_verification_report(report: &crate::verify::VerificationReport) {
 
     println!();
     if report.is_healthy() {
-        println!("  {}", green("✔ Keine Beschädigungen oder Bitrot festgestellt. Der Container ist integer."));
+        println!(
+            "  {}",
+            green("✔ Keine Beschädigungen oder Bitrot festgestellt. Der Container ist integer.")
+        );
     } else {
-        println!("  {}", red("✖ ACHTUNG: Der Container weist Beschädigungen auf! Bitte Backup prüfen."));
+        println!(
+            "  {}",
+            red("✖ ACHTUNG: Der Container weist Beschädigungen auf! Bitte Backup prüfen.")
+        );
     }
     println!();
 }
-

src/upgrade.rs

@@ -0,0 +1,636 @@
+use std::fs;
+use std::io::{Read, Write};
+use std::path::{Path, PathBuf};
+use std::time::Duration;
+
+use anyhow::{bail, Context, Result};
+use semver::Version;
+use serde::Deserialize;
+use sha2::{Digest, Sha256};
+
+use crate::ui;
+
+#[cfg(windows)]
+pub const TARGET_ASSET_NAME: &str = "sanctum.exe";
+
+#[cfg(not(windows))]
+pub const TARGET_ASSET_NAME: &str = "sanctum";
+
+pub const OFFICIAL_UPGRADE_URL: &str = "https://gitea.pansi.eu";
+pub const CHECKSUM_ASSET_NAME: &str = "SHA256SUMS.txt";
+pub const CHECKSUM_SIG_ASSET_NAME: &str = "SHA256SUMS.txt.minisig";
+pub const SANCTUM_RELEASE_PUBKEY: &str = "RWSsVphPgr8157M9rTPkWDw3c0qIjc7xi28Gmw+cIWbMipOy4L6ToJEU";
+pub const SANCTUM_RELEASE_PUBKEY_BACKUP: &str =
+    "RWQEeUSLlX2p4EPUPN1GjeUv34qA0p2B6wJYzcou5oOwAkkw0f+r9FmZ";
+
+/// Repräsentiert ein Asset in einem Gitea-Release
+#[derive(Debug, Deserialize, Clone)]
+pub struct ReleaseAsset {
+    pub id: u64,
+    pub name: String,
+    pub size: u64,
+    pub browser_download_url: String,
+}
+
+/// Repräsentiert ein Release von der Gitea Releases-API
+#[derive(Debug, Deserialize, Clone)]
+pub struct GiteaRelease {
+    pub id: u64,
+    pub tag_name: String,
+    pub name: String,
+    pub body: String,
+    pub html_url: String,
+    pub published_at: Option<String>,
+    pub assets: Vec<ReleaseAsset>,
+}
+
+/// Optionen für das Upgrade
+#[derive(Debug, Clone)]
+pub struct UpgradeOptions {
+    pub check_only: bool,
+    pub yes: bool,
+    pub force: bool,
+    pub base_url: String,
+    pub insecure_url: bool,
+}
+
+impl Default for UpgradeOptions {
+    fn default() -> Self {
+        Self {
+            check_only: false,
+            yes: false,
+            force: false,
+            base_url: OFFICIAL_UPGRADE_URL.to_string(),
+            insecure_url: false,
+        }
+    }
+}
+
+/// Überprüft eine Minisign-Signatur für gegebene Binärdaten mit dem angegebenen Minisign Public Key (U-01).
+///
+/// Erzwingt strikt Pre-Hashing (`allow_legacy = false`), um Malleability- und Längenangriffe auszuschließen.
+/// Gibt bei erfolgreicher Verifikation den kryptografisch authentifizierten `trusted comment` zurück.
+pub fn verify_minisign_signature(data: &[u8], sig_str: &str, pubkey_str: &str) -> Result<String> {
+    let pubkey = minisign_verify::PublicKey::from_base64(pubkey_str)
+        .map_err(|e| anyhow::anyhow!("Ungültiger öffentlicher Minisign-Schlüssel: {e}"))?;
+    let signature = minisign_verify::Signature::decode(sig_str)
+        .map_err(|e| anyhow::anyhow!("Ungültiges Minisign-Signaturformat: {e}"))?;
+    pubkey
+        .verify(data, &signature, false)
+        .map_err(|e| anyhow::anyhow!("Minisign-Signaturprüfung FEHLGESCHLAGEN: {e}. Das Release-Manifest ist nicht vertrauenswürdig!"))?;
+    Ok(signature.trusted_comment().to_string())
+}
+
+/// Extrahiert die Versionsnummer aus dem Trusted Comment einer Minisign-Signatur und
+/// validiert sie gegen das erwartete Release-Tag (U-02).
+pub fn validate_trusted_comment_version(
+    trusted_comment: &str,
+    expected_release: &str,
+) -> Result<()> {
+    let clean_expected = expected_release.trim().trim_start_matches(['v', 'V']);
+
+    if clean_expected.is_empty() {
+        bail!("Erwartetes Release-Tag darf nicht leer sein.");
+    }
+
+    // Durchsuche die Tokens des Trusted Comments (getrennt durch Tabs oder Leerzeichen)
+    let found = trusted_comment.split_whitespace().any(|token| {
+        let val = if let Some(stripped) = token.strip_prefix("version:") {
+            stripped
+        } else if let Some(stripped) = token.strip_prefix("release:") {
+            stripped
+        } else if let Some(stripped) = token.strip_prefix("tag:") {
+            stripped
+        } else {
+            token
+        };
+
+        let clean_val = val.trim_start_matches(['v', 'V']);
+        clean_val == clean_expected
+    });
+
+    if !found {
+        bail!(
+            "Signatur-Validierungsfehler (U-02): Der kryptografisch gesicherte Trusted Comment \
+             '{}' stimmt nicht mit der erwarteten Release-Version '{}' überein! \
+             Möglicher Replay-Angriff mit einer älteren signierten Prüfsummendatei.",
+            trusted_comment.trim(),
+            expected_release
+        );
+    }
+
+    Ok(())
+}
+
+/// Überprüft eine Minisign-Signatur für ein Release-Manifest.
+///
+/// Prüft primär gegen `SANCTUM_RELEASE_PUBKEY`. Falls diese Verifikation fehlschlägt,
+/// wird transparent gegen den sekundären Backup-Schlüssel `SANCTUM_RELEASE_PUBKEY_BACKUP`
+/// geprüft (U-03), um unterbrechungsfreie Schlüsselrotationen zu ermöglichen.
+pub fn verify_release_manifest_signature(data: &[u8], sig_str: &str) -> Result<String> {
+    match verify_minisign_signature(data, sig_str, SANCTUM_RELEASE_PUBKEY) {
+        Ok(comment) => Ok(comment),
+        Err(primary_err) => {
+            match verify_minisign_signature(data, sig_str, SANCTUM_RELEASE_PUBKEY_BACKUP) {
+                Ok(comment) => {
+                    tracing::info!(
+                        "Minisign-Signatur erfolgreich mit sekundärem Backup-Schlüssel verifiziert."
+                    );
+                    Ok(comment)
+                }
+                Err(_) => Err(primary_err),
+            }
+        }
+    }
+}
+
+/// Erkannter Paketmanager
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum PackageManager {
+    Scoop,
+    Winget,
+}
+
+impl PackageManager {
+    pub fn name(&self) -> &'static str {
+        match self {
+            PackageManager::Scoop => "Scoop",
+            PackageManager::Winget => "Winget",
+        }
+    }
+
+    pub fn upgrade_command(&self) -> &'static str {
+        match self {
+            PackageManager::Scoop => "scoop update sanctum",
+            PackageManager::Winget => "winget upgrade HaraldPansi.Sanctum",
+        }
+    }
+}
+
+/// Prüft, ob die laufende Binary durch einen Paketmanager (Scoop oder Winget) verwaltet wird.
+pub fn detect_package_manager() -> Option<PackageManager> {
+    if let Ok(exe_path) = std::env::current_exe() {
+        detect_package_manager_from_path(&exe_path)
+    } else {
+        None
+    }
+}
+
+/// Hilfsfunktion für die Paketmanager-Erkennung anhand eines Pfads (für Tests isolierbar).
+pub fn detect_package_manager_from_path(path: &Path) -> Option<PackageManager> {
+    let s = path.to_string_lossy().to_lowercase();
+    if s.contains("scoop\\apps\\sanctum")
+        || s.contains("scoop/apps/sanctum")
+        || s.contains("scoop\\shims")
+        || s.contains("scoop/shims")
+    {
+        return Some(PackageManager::Scoop);
+    }
+    if s.contains("winget\\packages")
+        || s.contains("winget/packages")
+        || s.contains("winget\\links")
+        || s.contains("winget/links")
+    {
+        return Some(PackageManager::Winget);
+    }
+    None
+}
+
+/// Ruft das neueste Release von der Gitea Releases-API ab.
+pub fn fetch_latest_release(base_url: &str) -> Result<GiteaRelease> {
+    let base = base_url.trim_end_matches('/');
+    let api_url = format!("{}/api/v1/repos/harald/sanctum/releases/latest", base);
+
+    let resp = ureq::get(&api_url)
+        .set(
+            "User-Agent",
+            &format!("sanctum/{}", env!("CARGO_PKG_VERSION")),
+        )
+        .set("Accept", "application/json")
+        .timeout(Duration::from_secs(15))
+        .call()
+        .with_context(|| format!("Netzwerkfehler beim Abrufen der Releases von '{}'", api_url))?;
+
+    let release: GiteaRelease = resp
+        .into_json()
+        .context("Ungültiges JSON-Format von der Gitea Releases-API empfangen")?;
+
+    Ok(release)
+}
+
+/// Lädt eine Datei von einer URL als Text herunter.
+pub fn fetch_text(url: &str) -> Result<String> {
+    let resp = ureq::get(url)
+        .set(
+            "User-Agent",
+            &format!("sanctum/{}", env!("CARGO_PKG_VERSION")),
+        )
+        .timeout(Duration::from_secs(15))
+        .call()
+        .with_context(|| format!("Fehler beim Herunterladen von '{}'", url))?;
+
+    let text = resp
+        .into_string()
+        .with_context(|| format!("Fehler beim Lesen des Texts von '{}'", url))?;
+
+    Ok(text)
+}
+
+/// Extrahiert die SHA-256 Prüfsumme für ein bestimmtes Asset aus dem Inhalt von `SHA256SUMS.txt`.
+pub fn parse_checksum_for_asset(sha256sums_content: &str, target_asset: &str) -> Option<String> {
+    for line in sha256sums_content.lines() {
+        let trimmed = line.trim();
+        if trimmed.is_empty() || trimmed.starts_with('#') {
+            continue;
+        }
+        let parts: Vec<&str> = trimmed.split_whitespace().collect();
+        if parts.len() >= 2 {
+            let hash = parts[0];
+            let filename = parts[1].trim_start_matches('*');
+            if filename.eq_ignore_ascii_case(target_asset) && hash.len() == 64 {
+                return Some(hash.to_lowercase());
+            }
+        }
+    }
+    None
+}
+
+/// Bereinigt einen Versionsstring von führenden 'v' / 'V' Zeichen und parst ihn als SemVer.
+pub fn parse_clean_version(ver_str: &str) -> Result<Version> {
+    let clean = ver_str.trim().trim_start_matches(['v', 'V']);
+    Version::parse(clean).with_context(|| format!("Ungültiges SemVer-Format: '{}'", ver_str))
+}
+
+/// Vergleicht die aktuelle Version mit der entfernten Version.
+/// Gibt `true` zurück, wenn `remote > current`.
+pub fn is_newer_version(current: &str, remote: &str) -> bool {
+    let cur = match parse_clean_version(current) {
+        Ok(v) => v,
+        Err(_) => return false,
+    };
+    let rem = match parse_clean_version(remote) {
+        Ok(v) => v,
+        Err(_) => return false,
+    };
+    rem > cur
+}
+
+/// Lädt das Ziel-Binary in eine temporäre Datei herunter und validiert dabei den SHA-256 Hash.
+pub fn download_and_verify_binary(
+    download_url: &str,
+    expected_hash: &str,
+    expected_size: u64,
+) -> Result<PathBuf> {
+    let resp = ureq::get(download_url)
+        .set(
+            "User-Agent",
+            &format!("sanctum/{}", env!("CARGO_PKG_VERSION")),
+        )
+        .timeout(Duration::from_secs(120))
+        .call()
+        .with_context(|| format!("Fehler beim Starten des Downloads von '{}'", download_url))?;
+
+    let mut reader = resp.into_reader();
+
+    let mut temp_file = tempfile::Builder::new()
+        .prefix("sanctum_update_")
+        .suffix(if cfg!(windows) { ".exe" } else { "" })
+        .tempfile()
+        .context("Konnte temporäre Update-Datei nicht sicher erstellen")?;
+
+    let mut hasher = Sha256::new();
+    let mut buffer = [0u8; 64 * 1024]; // 64 KB Puffer
+    let mut downloaded_bytes = 0u64;
+
+    println!("  • Herunterladen von: {}", download_url);
+    print!("  • Fortschritt:        ");
+    let _ = std::io::stdout().flush();
+
+    loop {
+        let n = reader
+            .read(&mut buffer)
+            .context("Fehler beim Lesen des Download-Datenstroms")?;
+        if n == 0 {
+            break;
+        }
+
+        temp_file
+            .as_file_mut()
+            .write_all(&buffer[..n])
+            .context("Fehler beim Schreiben in die temporäre Datei")?;
+        hasher.update(&buffer[..n]);
+
+        downloaded_bytes += n as u64;
+
+        if expected_size > 0 {
+            let percent = (downloaded_bytes as f64 / expected_size as f64 * 100.0).min(100.0);
+            print!(
+                "\r  • Fortschritt:        {} / {} ({:.1}%)",
+                ui::format_bytes(downloaded_bytes),
+                ui::format_bytes(expected_size),
+                percent
+            );
+        } else {
+            print!(
+                "\r  • Fortschritt:        {}",
+                ui::format_bytes(downloaded_bytes)
+            );
+        }
+        let _ = std::io::stdout().flush();
+    }
+    println!();
+
+    temp_file
+        .as_file_mut()
+        .flush()
+        .context("Fehler beim Flush der temporären Datei")?;
+
+    // SHA-256 Integritätsprüfung
+    let calculated_hash = hex::encode(hasher.finalize()).to_lowercase();
+    let expected_lower = expected_hash.to_lowercase();
+
+    if calculated_hash != expected_lower {
+        // temp_file wird beim Drop automatisch gelöscht
+        bail!(
+            "Kryptografische Prüfsumme ungültig!\n  Erwartet:  {}\n  Berechnet: {}\nDas Update wurde aus Sicherheitsgründen verworfen.",
+            expected_lower,
+            calculated_hash
+        );
+    }
+
+    println!(
+        "  • SHA-256:            {} (verifiziert)",
+        ui::green(&calculated_hash[..16])
+    );
+
+    let (_, path) = temp_file
+        .keep()
+        .context("Konnte temporäre Datei nicht für Ersetzung persistieren")?;
+
+    Ok(path)
+}
+
+/// Führt den In-Place-Austausch des laufenden Binaries durch.
+pub fn apply_upgrade(temp_binary: &Path) -> Result<PathBuf> {
+    let current_exe = std::env::current_exe()
+        .context("Konnte den Pfad der aktuell ausgeführten Datei nicht ermitteln")?;
+
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        if let Ok(meta) = fs::metadata(temp_binary) {
+            let mut perms = meta.permissions();
+            perms.set_mode(0o755);
+            let _ = fs::set_permissions(temp_binary, perms);
+        }
+    }
+
+    let replace_res = self_replace::self_replace(temp_binary);
+    let _ = fs::remove_file(temp_binary);
+
+    replace_res.context("In-Place-Ersetzung der laufenden Anwendungsdatei fehlgeschlagen")?;
+
+    Ok(current_exe)
+}
+
+/// Führt den gesamten Upgrade-Workflow aus.
+pub fn run_upgrade(options: &UpgradeOptions) -> Result<()> {
+    let current_version = env!("CARGO_PKG_VERSION");
+
+    println!("┌─────────────────────────────────────────────────────────────┐");
+    println!("│  Sanctum — In-Place Upgrade & Aktualisierungsdienst        │");
+    println!("└─────────────────────────────────────────────────────────────┘");
+    println!(
+        "  • Aktuelle Version: {}",
+        ui::cyan(&format!("v{}", current_version))
+    );
+    println!("  • Server:           {}", options.base_url);
+    println!();
+
+    // S-02: Prüfung auf abweichende Server-URL
+    let is_official_server =
+        options.base_url.trim_end_matches('/') == OFFICIAL_UPGRADE_URL.trim_end_matches('/');
+    if !is_official_server {
+        if !options.insecure_url {
+            bail!(
+                "Sicherheitsverstoß: Abweichende Server-URL '{}' ist nicht vertrauenswürdig.\n\
+                 Aus Sicherheitsgründen sind Drittanbieter-URLs standardmäßig gesperrt.\n\
+                 Falls beabsichtigt, verwenden Sie das Flag '--insecure-url'.",
+                options.base_url
+            );
+        }
+
+        // Auch mit --insecure-url ist zwingend eine manuelle Bestätigung erforderlich (nicht mit -y überschreibbar!)
+        println!(
+            "  {} WARNUNG: Sie aktualisieren von einem inoffiziellen Server: {}",
+            ui::red("[SICHERHEITSWARNUNG]"),
+            options.base_url
+        );
+        println!("    Offizieller Server ist: {}", OFFICIAL_UPGRADE_URL);
+        print!("  Möchten Sie dieses ungesicherte Update WIRKLICH fortsetzen? [Tippen Sie 'JA' zur Bestätigung]: ");
+        let _ = std::io::stdout().flush();
+        let mut confirm = String::new();
+        std::io::stdin()
+            .read_line(&mut confirm)
+            .context("Fehler beim Einlesen der Bestätigung")?;
+        if confirm.trim() != "JA" {
+            bail!("Upgrade von Drittanbieter-URL durch Benutzer abgebrochen.");
+        }
+        println!();
+    }
+
+    // 1. Paketmanager-Prüfung
+    if let Some(pm) = detect_package_manager() {
+        println!(
+            "  {} Sanctum wird anscheinend über {} verwaltet!",
+            ui::yellow("[!]"),
+            pm.name()
+        );
+        println!(
+            "    Empfohlener Aktualisierungsbefehl: {}",
+            ui::cyan(pm.upgrade_command())
+        );
+        println!();
+
+        if !options.force && !options.yes && !options.check_only {
+            print!("  Möchten Sie das direkte In-Place-Upgrade trotzdem fortsetzen? [j/N]: ");
+            let _ = std::io::stdout().flush();
+            let mut answer = String::new();
+            std::io::stdin()
+                .read_line(&mut answer)
+                .context("Fehler beim Einlesen der Benutzereingabe")?;
+            let trimmed = answer.trim().to_lowercase();
+            if trimmed != "j" && trimmed != "ja" && trimmed != "y" && trimmed != "yes" {
+                println!("  Upgrade abgebrochen.");
+                return Ok(());
+            }
+            println!();
+        }
+    }
+
+    // 2. Neuestes Release abfragen
+    println!(
+        "  {} Suche nach neuesten Releases auf Gitea ...",
+        ui::dim("[-]")
+    );
+    let release = fetch_latest_release(&options.base_url)?;
+    let remote_tag = &release.tag_name;
+    let is_newer = is_newer_version(current_version, remote_tag);
+
+    println!(
+        "  • Neueste Version:  {}",
+        if is_newer {
+            ui::green(remote_tag)
+        } else {
+            ui::cyan(remote_tag)
+        }
+    );
+    println!("  • Release-Name:     {}", release.name);
+    if let Some(ref pub_at) = release.published_at {
+        println!("  • Veröffentlicht:   {}", pub_at);
+    }
+    println!("  • Release-URL:      {}", release.html_url);
+    println!();
+
+    if !is_newer && !options.force {
+        println!(
+            "  {} Sie verwenden bereits die neueste Version von Sanctum.",
+            ui::green("✔")
+        );
+        return Ok(());
+    }
+
+    if options.check_only {
+        if is_newer {
+            println!(
+                "  {} Ein Update auf {} ist verfügbar! Führen Sie 'sanctum upgrade' aus.",
+                ui::yellow("[!]"),
+                remote_tag
+            );
+        }
+        return Ok(());
+    }
+
+    // 3. Ziel-Asset, Checksumme und Minisign-Signatur identifizieren
+    let target_asset = release
+        .assets
+        .iter()
+        .find(|a| a.name.eq_ignore_ascii_case(TARGET_ASSET_NAME))
+        .ok_or_else(|| {
+            anyhow::anyhow!(
+                "Im Release '{}' wurde kein passendes Binary für Ihr Betriebssystem ('{}') gefunden!",
+                remote_tag,
+                TARGET_ASSET_NAME
+            )
+        })?;
+
+    let checksum_asset = release
+        .assets
+        .iter()
+        .find(|a| a.name.eq_ignore_ascii_case(CHECKSUM_ASSET_NAME))
+        .ok_or_else(|| {
+            anyhow::anyhow!(
+                "Im Release '{}' wurde keine Prüfsummendatei ('{}') gefunden!",
+                remote_tag,
+                CHECKSUM_ASSET_NAME
+            )
+        })?;
+
+    let sig_asset = release
+        .assets
+        .iter()
+        .find(|a| a.name.eq_ignore_ascii_case(CHECKSUM_SIG_ASSET_NAME))
+        .ok_or_else(|| {
+            anyhow::anyhow!(
+                "Im Release '{}' wurde keine Minisign-Signatur ('{}') gefunden! Unsignierte Updates werden verweigert.",
+                remote_tag,
+                CHECKSUM_SIG_ASSET_NAME
+            )
+        })?;
+
+    // 4. Prüfsummen und Signatur herunterladen und kryptografisch prüfen (S-02)
+    println!(
+        "  {} Lade Prüfsummen ({}) herunter ...",
+        ui::dim("[-]"),
+        CHECKSUM_ASSET_NAME
+    );
+    let sums_content = fetch_text(&checksum_asset.browser_download_url)?;
+
+    println!(
+        "  {} Lade Minisign-Signatur ({}) herunter ...",
+        ui::dim("[-]"),
+        CHECKSUM_SIG_ASSET_NAME
+    );
+    let sig_content = fetch_text(&sig_asset.browser_download_url)?;
+
+    println!(
+        "  {} Verifiziere Minisign-Signatur gegen eingebetteten Herstellerschlüssel ...",
+        ui::dim("[-]")
+    );
+    let trusted_comment = verify_release_manifest_signature(sums_content.as_bytes(), &sig_content)
+        .context("Minisign-Signaturprüfung für Prüfsummendatei FEHLGESCHLAGEN! Release ist nicht vertrauenswürdig.")?;
+    validate_trusted_comment_version(&trusted_comment, remote_tag)?;
+    println!(
+        "  • Signatur:           {} (Minisign Ed25519, Version validiert)",
+        ui::green("Gültig")
+    );
+
+    let expected_hash =
+        parse_checksum_for_asset(&sums_content, TARGET_ASSET_NAME).ok_or_else(|| {
+            anyhow::anyhow!(
+                "Prüfsummendatei enthält keinen SHA-256 Eintrag für '{}'!",
+                TARGET_ASSET_NAME
+            )
+        })?;
+
+    // 5. Interaktive Bestätigung (sofern nicht -y / --yes)
+    if !options.yes {
+        println!(
+            "  • Ziel-Binary:      {} ({})",
+            target_asset.name,
+            ui::format_bytes(target_asset.size)
+        );
+        println!("  • Erwarteter Hash:  {}...", &expected_hash[..16]);
+        println!();
+        print!(
+            "  Möchten Sie Sanctum jetzt von v{} auf {} aktualisieren? [J/n]: ",
+            current_version, remote_tag
+        );
+        let _ = std::io::stdout().flush();
+        let mut answer = String::new();
+        std::io::stdin()
+            .read_line(&mut answer)
+            .context("Fehler beim Einlesen der Benutzereingabe")?;
+        let trimmed = answer.trim().to_lowercase();
+        if trimmed == "n" || trimmed == "nein" || trimmed == "no" {
+            println!("  Upgrade abgebrochen.");
+            return Ok(());
+        }
+        println!();
+    }
+
+    // 6. Download & Verifikation
+    println!("  {} Lade neues Binary herunter ...", ui::dim("[-]"));
+    let temp_file = download_and_verify_binary(
+        &target_asset.browser_download_url,
+        &expected_hash,
+        target_asset.size,
+    )?;
+
+    // 7. In-Place-Austausch
+    println!("  {} Führe In-Place-Austausch durch ...", ui::dim("[-]"));
+    let updated_exe = apply_upgrade(&temp_file)?;
+
+    println!();
+    println!("┌─────────────────────────────────────────────────────────────┐");
+    println!(
+        "│  ✔ Sanctum wurde erfolgreich auf {} aktualisiert!         │",
+        remote_tag
+    );
+    println!("└─────────────────────────────────────────────────────────────┘");
+    println!("  • Pfad:             {}", updated_exe.display());
+    println!("  • Neue Version:     {}", ui::green(remote_tag));
+    println!();
+
+    Ok(())
+}

src/verify.rs

@@ -4,7 +4,7 @@ use std::path::Path;
 use anyhow::{bail, Context, Result};
 use zeroize::Zeroizing;
 
-use crate::crypto::{decrypt_chunk, FORMAT_VERSION_V1, FORMAT_VERSION_V2};
+use crate::crypto::{decrypt_chunk, FORMAT_VERSION_V1, FORMAT_VERSION_V2, FORMAT_VERSION_V3};
 use crate::storage::Database;
 
 /// Bericht über das Ergebnis einer Container-Integritätsprüfung.
@@ -43,11 +43,13 @@ pub fn verify_container(
     full_chunks: bool,
 ) -> Result<VerificationReport> {
     if !container_path.exists() {
-        bail!("Containerdatei '{}' existiert nicht.", container_path.display());
+        bail!(
+            "Containerdatei '{}' existiert nicht.",
+            container_path.display()
+        );
     }
 
-    let db = Database::open(container_path)
+    let db = Database::open(container_path).context("Konnte Container-Datenbank nicht öffnen")?;
-        .context("Konnte Container-Datenbank nicht öffnen")?;
 
     let mut report = VerificationReport {
         container_path: container_path.display().to_string(),
@@ -67,7 +69,8 @@ pub fn verify_container(
     };
 
     // 1. SQLite B-Tree & Foreign Key Prüfung
-    let sqlite_issues = db.run_sqlite_integrity_check()
+    let sqlite_issues = db
+        .run_sqlite_integrity_check()
         .context("Fehler bei der Ausführung des SQLite integrity_check")?;
     if !sqlite_issues.is_empty() {
         report.sqlite_ok = false;
@@ -78,7 +81,10 @@ pub fn verify_container(
     let meta = match db.read_meta() {
         Ok(m) => {
             report.format_version = m.version;
-            if m.version != FORMAT_VERSION_V1 && m.version != FORMAT_VERSION_V2 {
+            if m.version != FORMAT_VERSION_V1
+                && m.version != FORMAT_VERSION_V2
+                && m.version != FORMAT_VERSION_V3
+            {
                 report.header_ok = false;
                 report.header_error = Some(format!("Unbekannte Formatversion: {}", m.version));
             }
@@ -96,13 +102,16 @@ pub fn verify_container(
     };
 
     // 3. Node-Hierarchie & Strukturprüfung
-    let (dirs, files, chunks_count) = db.count_nodes_and_chunks()
+    let (dirs, files, chunks_count) = db
+        .count_nodes_and_chunks()
         .context("Fehler beim Zählen der Knoten und Chunks")?;
     report.total_dirs = dirs;
     report.total_files = files;
     report.total_chunks = chunks_count;
 
-    let all_nodes = db.list_all_nodes().context("Fehler beim Laden der Knotenliste")?;
+    let all_nodes = db
+        .list_all_nodes()
+        .context("Fehler beim Laden der Knotenliste")?;
     report.total_nodes = all_nodes.len();
 
     let mut node_map = HashMap::new();
@@ -114,23 +123,33 @@ pub fn verify_container(
     match node_map.get(&1) {
         Some(root) => {
             if !root.is_dir {
-                report.errors.push("Root-Knoten (id=1) ist nicht als Verzeichnis markiert!".to_string());
+                report
+                    .errors
+                    .push("Root-Knoten (id=1) ist nicht als Verzeichnis markiert!".to_string());
             }
             if root.parent_id.is_some() {
-                report.errors.push("Root-Knoten (id=1) darf keinen Parent haben!".to_string());
+                report
+                    .errors
+                    .push("Root-Knoten (id=1) darf keinen Parent haben!".to_string());
             }
         }
         None => {
-            report.errors.push("Root-Knoten (id=1) fehlt in der nodes-Tabelle!".to_string());
+            report
+                .errors
+                .push("Root-Knoten (id=1) fehlt in der nodes-Tabelle!".to_string());
         }
     }
 
     if let Some(root2) = node_map.get(&2) {
         if !root2.is_dir {
-            report.errors.push("Root-Knoten (id=2) ist nicht als Verzeichnis markiert!".to_string());
+            report
+                .errors
+                .push("Root-Knoten (id=2) ist nicht als Verzeichnis markiert!".to_string());
         }
         if root2.parent_id.is_some() {
-            report.errors.push("Root-Knoten (id=2) darf keinen Parent haben!".to_string());
+            report
+                .errors
+                .push("Root-Knoten (id=2) darf keinen Parent haben!".to_string());
         }
     }
 
@@ -231,11 +250,36 @@ pub fn verify_container(
         None
     };
 
+    // 3b. Metadaten-Authentifizierung (HMAC-SHA256) für Format V3 (K-01)
+    if let Some(active_dek) = dek {
+        if let Some(ref m) = meta {
+            if m.version >= FORMAT_VERSION_V3 {
+                match db.verify_metadata_mac(active_dek) {
+                    Ok(true) => {}
+                    Ok(false) => {
+                        report.errors.push(
+                            "Kritischer Metadaten-Authentifizierungsfehler (K-01): Metadaten-MAC ungültig. Manipulationsversuch an Dateinamen, Größen oder Verzeichnisstruktur in der SQLite-Datenbank erkannt.".to_string(),
+                        );
+                    }
+                    Err(e) => {
+                        report
+                            .errors
+                            .push(format!("Fehler bei der Metadaten-MAC-Prüfung: {e}"));
+                    }
+                }
+            }
+        }
+    }
+
     // 4. Kryptografische Chunk- & AEAD-Authentifizierungsprüfung
-    let chunk_headers = db.list_all_chunk_headers()
+    let chunk_headers = db
+        .list_all_chunk_headers()
         .context("Fehler beim Abrufen der Chunk-Liste")?;
 
-    let format_version = meta.as_ref().map(|m| m.version).unwrap_or(FORMAT_VERSION_V2);
+    let format_version = meta
+        .as_ref()
+        .map(|m| m.version)
+        .unwrap_or(FORMAT_VERSION_V2);
 
     for (node_id, chunk_index) in chunk_headers {
         if !node_map.contains_key(&node_id) {
@@ -257,6 +301,7 @@ pub fn verify_container(
                             &record.nonce,
                             &record.tag,
                             format_version,
+                            record.generation,
                         ) {
                             Ok(plaintext) => {
                                 report.total_bytes_decrypted += plaintext.len() as u64;
@@ -310,8 +355,8 @@ mod tests {
         let password = "HealthyTestPassword123!";
         let salt = generate_salt();
         let kdf_params = KdfParams {
-            memory_cost: 1024,
+            memory_cost: crate::crypto::MIN_MEMORY_COST_KIB,
-            time_cost: 1,
+            time_cost: crate::crypto::MIN_TIME_COST,
             parallelism: 1,
         };
         let kek = derive_kek(password, &salt, &kdf_params).unwrap();
@@ -319,7 +364,9 @@ mod tests {
         let (wrapped_dek, nonce, tag) = wrap_dek(&kek, &dek).unwrap();
 
         let db = Database::open(&container_path).unwrap();
-        db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag).unwrap();
+        db.set_active_dek(dek.clone());
+        db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag)
+            .unwrap();
 
         // Verzeichnis & Datei anlegen
         let folder = db.create_node(1, "photos", true).unwrap();
@@ -327,21 +374,32 @@ mod tests {
 
         // 2 Chunks schreiben
         let chunk0_data = b"Sample JPEG data header and pixels";
-        let (ct0, n0, t0) = encrypt_chunk(&dek, file.id, 0, chunk0_data, FORMAT_VERSION).unwrap();
+        let (ct0, n0, t0) =
-        db.write_chunk(file.id, 0, &n0, &t0, &ct0).unwrap();
+            encrypt_chunk(&dek, file.id, 0, chunk0_data, FORMAT_VERSION, 0).unwrap();
+        db.write_chunk(file.id, 0, 0, &n0, &t0, &ct0).unwrap();
 
         let chunk1_data = b"Additional payload data bytes";
-        let (ct1, n1, t1) = encrypt_chunk(&dek, file.id, 1, chunk1_data, FORMAT_VERSION).unwrap();
+        let (ct1, n1, t1) =
-        db.write_chunk(file.id, 1, &n1, &t1, &ct1).unwrap();
+            encrypt_chunk(&dek, file.id, 1, chunk1_data, FORMAT_VERSION, 0).unwrap();
+        db.write_chunk(file.id, 1, 0, &n1, &t1, &ct1).unwrap();
 
-        db.update_node_size_and_time(file.id, (chunk0_data.len() + chunk1_data.len()) as u64, 1000).unwrap();
+        db.update_node_size_and_time(
+            file.id,
+            (chunk0_data.len() + chunk1_data.len()) as u64,
+            1000,
+        )
+        .unwrap();
         db.checkpoint().unwrap();
 
         // Verifizieren
         let report = verify_container(&container_path, Some(&dek), true).expect("Verify container");
-        assert!(report.is_healthy(), "Container must be healthy, report: {:?}", report);
+        assert!(
+            report.is_healthy(),
+            "Container must be healthy, report: {:?}",
+            report
+        );
         assert_eq!(report.total_files, 1);
-        assert_eq!(report.total_dirs, 3); // Root 1 + Root 2 (Plausible Deniability) + photos
+        assert_eq!(report.total_dirs, 3); // Root 1 + Root 2 (Dual-Vault) + photos
         assert_eq!(report.total_chunks, 2);
         assert_eq!(report.corrupted_chunks, 0);
         assert_eq!(report.orphan_nodes, 0);
@@ -362,8 +420,8 @@ mod tests {
         let password = "BitrotTestPassword123!";
         let salt = generate_salt();
         let kdf_params = KdfParams {
-            memory_cost: 1024,
+            memory_cost: crate::crypto::MIN_MEMORY_COST_KIB,
-            time_cost: 1,
+            time_cost: crate::crypto::MIN_TIME_COST,
             parallelism: 1,
         };
         let kek = derive_kek(password, &salt, &kdf_params).unwrap();
@@ -371,12 +429,14 @@ mod tests {
         let (wrapped_dek, nonce, tag) = wrap_dek(&kek, &dek).unwrap();
 
         let db = Database::open(&container_path).unwrap();
-        db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag).unwrap();
+        db.set_active_dek(dek.clone());
+        db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag)
+            .unwrap();
 
         let file = db.create_node(1, "document.pdf", false).unwrap();
         let chunk_data = b"Vital documents that must not be corrupted";
-        let (ct, n, t) = encrypt_chunk(&dek, file.id, 0, chunk_data, FORMAT_VERSION).unwrap();
+        let (ct, n, t) = encrypt_chunk(&dek, file.id, 0, chunk_data, FORMAT_VERSION, 0).unwrap();
-        db.write_chunk(file.id, 0, &n, &t, &ct).unwrap();
+        db.write_chunk(file.id, 0, 0, &n, &t, &ct).unwrap();
         db.checkpoint().unwrap();
         drop(db);
 
@@ -387,14 +447,24 @@ mod tests {
         conn.execute(
             "UPDATE chunks SET ciphertext = ?1 WHERE node_id = ?2 AND chunk_index = 0",
             rusqlite::params![corrupted_ct, file.id],
-        ).unwrap();
+        )
+        .unwrap();
         drop(conn);
 
         // Verifizieren: Muss Bitrot via AEAD Tag-Fehler sofort entlarven!
         let report = verify_container(&container_path, Some(&dek), true).expect("Verify container");
-        assert!(!report.is_healthy(), "Container must report unhealthy due to bitrot");
+        assert!(
-        assert_eq!(report.corrupted_chunks, 1, "Must detect exactly 1 corrupted chunk");
+            !report.is_healthy(),
-        assert!(report.errors.iter().any(|e| e.contains("AEAD/Integritätsfehler")));
+            "Container must report unhealthy due to bitrot"
+        );
+        assert_eq!(
+            report.corrupted_chunks, 1,
+            "Must detect exactly 1 corrupted chunk"
+        );
+        assert!(report
+            .errors
+            .iter()
+            .any(|e| e.contains("AEAD/Integritätsfehler")));
 
         let _ = fs::remove_file(&container_path);
     }

src/windows.rs

@@ -2,6 +2,8 @@ use std::process::Command;
 
 #[allow(unused_imports)]
 use anyhow::{bail, Context, Result};
+#[cfg(windows)]
+use tracing::debug;
 
 /// Ermittelt den nächsten verfügbaren Windows-Laufwerksbuchstaben (von 'Z' rückwärts bis 'D').
 pub fn find_next_available_drive() -> Result<char> {
@@ -42,7 +44,9 @@ pub fn open_in_explorer(drive_char: char) -> Result<()> {
         Command::new("explorer.exe")
             .arg(&drive_path)
             .spawn()
-            .with_context(|| format!("Konnte Windows Explorer für '{}' nicht öffnen", drive_path))?;
+            .with_context(|| {
+                format!("Konnte Windows Explorer für '{}' nicht öffnen", drive_path)
+            })?;
         Ok(())
     }
     #[cfg(target_os = "macos")]
@@ -71,15 +75,19 @@ pub fn open_in_file_manager(path: &std::path::Path) -> Result<()> {
         Command::new("explorer.exe")
             .arg(path)
             .spawn()
-            .with_context(|| format!("Konnte Windows Explorer für '{}' nicht öffnen", path.display()))?;
+            .with_context(|| {
+                format!(
+                    "Konnte Windows Explorer für '{}' nicht öffnen",
+                    path.display()
+                )
+            })?;
         Ok(())
     }
     #[cfg(target_os = "macos")]
     {
-        Command::new("open")
+        Command::new("open").arg(path).spawn().with_context(|| {
-            .arg(path)
+            format!("Konnte macOS Finder für '{}' nicht öffnen", path.display())
-            .spawn()
+        })?;
-            .with_context(|| format!("Konnte macOS Finder für '{}' nicht öffnen", path.display()))?;
         Ok(())
     }
     #[cfg(all(unix, not(target_os = "macos")))]
@@ -87,7 +95,12 @@ pub fn open_in_file_manager(path: &std::path::Path) -> Result<()> {
         Command::new("xdg-open")
             .arg(path)
             .spawn()
-            .with_context(|| format!("Konnte Dateimanager via xdg-open für '{}' nicht öffnen", path.display()))?;
+            .with_context(|| {
+                format!(
+                    "Konnte Dateimanager via xdg-open für '{}' nicht öffnen",
+                    path.display()
+                )
+            })?;
         Ok(())
     }
     #[cfg(not(any(windows, unix)))]
@@ -127,8 +140,7 @@ pub fn notify_shell_associations_changed() {
         let _ = Command::new("update-desktop-database").spawn();
     }
     #[cfg(not(any(windows, all(unix, not(target_os = "macos")))))]
-    {
+    {}
-    }
 }
 
 /// Registriert `.sanctum`-Containerdateien im Windows Explorer für den aktuellen Benutzer bzw. unter Linux via Freedesktop.
@@ -141,11 +153,7 @@ pub fn register_explorer_integration() -> Result<()> {
 
         let reg_commands = [
             // 1. .sanctum Erweiterung mit ProgID verknüpfen
-            (
+            (r"HKCU\Software\Classes\.sanctum", "", "Sanctum.Container"),
-                r"HKCU\Software\Classes\.sanctum",
-                "",
-                "Sanctum.Container",
-            ),
             // 2. ProgID Metadaten & Beschreibung
             (
                 r"HKCU\Software\Classes\Sanctum.Container",
@@ -203,7 +211,9 @@ pub fn register_explorer_integration() -> Result<()> {
             }
             cmd.arg("/d").arg(val_data).arg("/f");
 
-            let output = cmd.output().with_context(|| format!("Fehler beim Ausführen von 'reg add {key}'"))?;
+            let output = cmd
+                .output()
+                .with_context(|| format!("Fehler beim Ausführen von 'reg add {key}'"))?;
             if !output.status.success() {
                 let stderr = String::from_utf8_lossy(&output.stderr);
                 bail!("Registry-Fehler beim Anlegen von {key}: {stderr}");
@@ -244,9 +254,7 @@ pub fn unregister_explorer_integration() -> Result<()> {
         ];
 
         for key in keys_to_delete {
-            let _ = Command::new("reg")
+            let _ = Command::new("reg").args(["delete", key, "/f"]).output();
-                .args(["delete", key, "/f"])
-                .output();
         }
 
         notify_shell_associations_changed();
@@ -256,8 +264,11 @@ pub fn unregister_explorer_integration() -> Result<()> {
     {
         if let Some(home) = std::env::var_os("HOME") {
             let home_path = std::path::PathBuf::from(home);
-            let _ = std::fs::remove_file(home_path.join(".local/share/applications/sanctum.desktop"));
+            let _ =
-            let _ = std::fs::remove_file(home_path.join(".local/share/mime/packages/application-x-sanctum.xml"));
+                std::fs::remove_file(home_path.join(".local/share/applications/sanctum.desktop"));
+            let _ = std::fs::remove_file(
+                home_path.join(".local/share/mime/packages/application-x-sanctum.xml"),
+            );
             notify_shell_associations_changed();
         }
         Ok(())
@@ -494,9 +505,9 @@ pub fn start_session_lock_monitor(
         })
         .context("Konnte Windows Session-Monitor-Thread nicht starten")?;
 
-    let hwnd = hwnd_rx
+    let hwnd = hwnd_rx.recv().map_err(|e| {
-        .recv()
+        anyhow::anyhow!("Session-Monitor-Thread initialisierte nicht rechtzeitig: {e}")
-        .map_err(|e| anyhow::anyhow!("Session-Monitor-Thread initialisierte nicht rechtzeitig: {e}"))?;
+    })?;
 
     if hwnd == 0 {
         bail!("Win32-Nachrichtenfenster für Session-Lock konnte nicht erstellt werden");
@@ -520,10 +531,38 @@ pub fn start_session_lock_monitor(
 // ─────────────────────────────────────────────────────────────
 
 #[cfg(windows)]
-static CONSOLE_CTRL_TX: std::sync::Mutex<Option<tokio::sync::mpsc::Sender<()>>> = std::sync::Mutex::new(None);
+static CONSOLE_CTRL_TX: std::sync::Mutex<Option<tokio::sync::mpsc::Sender<()>>> =
+    std::sync::Mutex::new(None);
 #[cfg(windows)]
 static CONSOLE_CTRL_DRIVE: std::sync::Mutex<Option<char>> = std::sync::Mutex::new(None);
 
+#[cfg(windows)]
+#[repr(C)]
+#[allow(non_snake_case)]
+struct NETRESOURCEW {
+    dwScope: u32,
+    dwType: u32,
+    dwDisplayType: u32,
+    dwUsage: u32,
+    lpLocalName: *mut u16,
+    lpRemoteName: *mut u16,
+    lpComment: *mut u16,
+    lpProvider: *mut u16,
+}
+
+#[cfg(windows)]
+#[link(name = "mpr")]
+extern "system" {
+    fn WNetAddConnection2W(
+        lpNetResource: *const NETRESOURCEW,
+        lpPassword: *const u16,
+        lpUserName: *const u16,
+        dwFlags: u32,
+    ) -> u32;
+
+    fn WNetCancelConnection2W(lpName: *const u16, dwFlags: u32, fForce: i32) -> u32;
+}
+
 #[cfg(windows)]
 unsafe extern "system" fn console_ctrl_routine(ctrl_type: u32) -> i32 {
     const CTRL_C_EVENT: u32 = 0;
@@ -534,13 +573,15 @@ unsafe extern "system" fn console_ctrl_routine(ctrl_type: u32) -> i32 {
 
     match ctrl_type {
         CTRL_CLOSE_EVENT | CTRL_LOGOFF_EVENT | CTRL_SHUTDOWN_EVENT => {
-            // 1. Sofortiges Notfall-Unmount direkt aus dem Win32-Callback ausführen
+            // 1. Sofortiges Notfall-Unmount direkt aus dem Win32-Callback ausführen (in-process)
             if let Ok(guard) = CONSOLE_CTRL_DRIVE.lock() {
                 if let Some(dl) = *guard {
                     let drive_str = format!("{}:", dl.to_ascii_uppercase());
-                    let _ = std::process::Command::new("net")
+                    let wide_drive: Vec<u16> =
-                        .args(["use", &drive_str, "/delete", "/y"])
+                        drive_str.encode_utf16().chain(std::iter::once(0)).collect();
-                        .output();
+                    unsafe {
+                        WNetCancelConnection2W(wide_drive.as_ptr(), 0, 1);
+                    }
                 }
             }
             // 2. Asynchronen Shutdown-Kanal benachrichtigen (für SQLite WAL Checkpoint)
@@ -681,6 +722,181 @@ pub fn unlock_memory(ptr: *const u8, len: usize) -> bool {
     }
 }
 
+/// Bindet ein Windows-Netzlaufwerk über WNetAddConnection2W ein (in-process, ohne argv-Token-Leak).
+#[cfg(windows)]
+pub fn mount_drive_wnet(drive_letter: char, port: u16, session_token: &str) -> Result<()> {
+    let drive_str = format!("{}:", drive_letter.to_ascii_uppercase());
+    let mut local_name: Vec<u16> = drive_str.encode_utf16().chain(std::iter::once(0)).collect();
+    let remote_url = format!("http://127.0.0.1:{}/", port);
+    let mut remote_name: Vec<u16> = remote_url
+        .encode_utf16()
+        .chain(std::iter::once(0))
+        .collect();
+    let username: Vec<u16> = "sanctum".encode_utf16().chain(std::iter::once(0)).collect();
+    let password: Vec<u16> = session_token
+        .encode_utf16()
+        .chain(std::iter::once(0))
+        .collect();
+
+    let nr = NETRESOURCEW {
+        dwScope: 0,
+        dwType: 1, // RESOURCETYPE_DISK
+        dwDisplayType: 0,
+        dwUsage: 0,
+        lpLocalName: local_name.as_mut_ptr(),
+        lpRemoteName: remote_name.as_mut_ptr(),
+        lpComment: std::ptr::null_mut(),
+        lpProvider: std::ptr::null_mut(),
+    };
+
+    let mut res = unsafe {
+        WNetAddConnection2W(
+            &nr,
+            password.as_ptr(),
+            username.as_ptr(),
+            0, // Nicht persistent
+        )
+    };
+
+    // PRR-01: Selbstreparatur bei verwaister Zuordnung nach unsauberem Vorläufer (Systemfehler 85 / 1202)
+    if res == 85 || res == 1202 {
+        debug!(
+            "Verwaiste Zuordnung für {} entdeckt — führe automatische Bereinigung durch...",
+            drive_str
+        );
+        unsafe {
+            WNetCancelConnection2W(local_name.as_ptr(), 0, 1);
+        }
+        res = unsafe { WNetAddConnection2W(&nr, password.as_ptr(), username.as_ptr(), 0) };
+    }
+
+    if res != 0 {
+        let webclient_hint = if res == 67 {
+            "\n\nHinweis: Das Einbinden von Netzlaufwerken erfordert den Windows-Dienst 'WebClient'. Prüfen Sie in einer Administrator-Konsole: 'net start WebClient'."
+        } else {
+            ""
+        };
+        bail!(
+            "Laufwerk {} konnte nicht eingebunden werden (Win32 Fehlercode {}){}",
+            drive_str,
+            res,
+            webclient_hint
+        );
+    }
+
+    Ok(())
+}
+
+/// Trennt ein eingebundenes Windows-Netzlaufwerk via WNetCancelConnection2W (in-process).
+#[cfg(windows)]
+pub fn unmount_drive_wnet(drive_letter: char) -> Result<()> {
+    let drive_str = format!("{}:", drive_letter.to_ascii_uppercase());
+    let local_name: Vec<u16> = drive_str.encode_utf16().chain(std::iter::once(0)).collect();
+
+    let res = unsafe {
+        WNetCancelConnection2W(local_name.as_ptr(), 0, 1 /* fForce = TRUE */)
+    };
+
+    // 0 = NO_ERROR, 2250 = ERROR_NOT_CONNECTED (bereits getrennt)
+    if res != 0 && res != 2250 {
+        bail!(
+            "Netzlaufwerk {} konnte nicht getrennt werden (Win32 Fehlercode {})",
+            drive_str,
+            res
+        );
+    }
+
+    Ok(())
+}
+
+#[cfg(not(windows))]
+pub fn mount_drive_wnet(_drive_letter: char, _port: u16, _session_token: &str) -> Result<()> {
+    Ok(())
+}
+
+#[cfg(not(windows))]
+pub fn unmount_drive_wnet(_drive_letter: char) -> Result<()> {
+    Ok(())
+}
+
+/// Prüft, ob ein Prozess mit der angegebenen PID auf dem lokalen System aktiv ist (S-06).
+pub fn is_process_alive(pid: u32) -> bool {
+    #[cfg(windows)]
+    {
+        extern "system" {
+            fn OpenProcess(desired_access: u32, inherit_handle: i32, process_id: u32) -> isize;
+            fn CloseHandle(handle: isize) -> i32;
+            fn GetExitCodeProcess(handle: isize, exit_code: *mut u32) -> i32;
+        }
+        const PROCESS_QUERY_LIMITED_INFORMATION: u32 = 0x1000;
+        const STILL_ACTIVE: u32 = 259;
+
+        let handle = unsafe { OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, pid) };
+        if handle == 0 {
+            return false;
+        }
+        let mut exit_code: u32 = 0;
+        let success = unsafe { GetExitCodeProcess(handle, &mut exit_code) };
+        unsafe { CloseHandle(handle) };
+        success != 0 && exit_code == STILL_ACTIVE
+    }
+    #[cfg(not(windows))]
+    {
+        std::path::Path::new(&format!("/proc/{}", pid)).exists()
+    }
+}
+
+/// Ermittelt den verfügbaren freien Speicherplatz auf dem Dateisystem des angegebenen Pfads (Z-04).
+pub fn get_available_disk_space<P: AsRef<std::path::Path>>(path: P) -> Option<u64> {
+    #[cfg(windows)]
+    {
+        use std::os::windows::ffi::OsStrExt;
+        let p = path.as_ref();
+        let dir = if p.is_dir() {
+            p.to_path_buf()
+        } else {
+            p.parent()
+                .map(|parent| parent.to_path_buf())
+                .unwrap_or_else(|| p.to_path_buf())
+        };
+        let mut wide: Vec<u16> = dir.as_os_str().encode_wide().collect();
+        wide.push(0);
+
+        let mut free_bytes_available = 0u64;
+        let mut total_number_of_bytes = 0u64;
+        let mut total_number_of_free_bytes = 0u64;
+
+        extern "system" {
+            fn GetDiskFreeSpaceExW(
+                lpDirectoryName: *const u16,
+                lpFreeBytesAvailableToCaller: *mut u64,
+                lpTotalNumberOfBytes: *mut u64,
+                lpTotalNumberOfFreeBytes: *mut u64,
+            ) -> i32;
+        }
+
+        let success = unsafe {
+            GetDiskFreeSpaceExW(
+                wide.as_ptr(),
+                &mut free_bytes_available,
+                &mut total_number_of_bytes,
+                &mut total_number_of_free_bytes,
+            )
+        };
+
+        if success != 0 {
+            Some(free_bytes_available)
+        } else {
+            None
+        }
+    }
+    #[cfg(not(windows))]
+    {
+        let _ = path;
+        Some(1024 * 1024 * 1024 * 1024)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -697,7 +913,7 @@ mod tests {
     fn test_find_next_available_drive() {
         let drive = find_next_available_drive().expect("Find next drive");
         assert!(drive.is_ascii_alphabetic());
-        assert!(drive >= 'D' && drive <= 'Z');
+        assert!(('D'..='Z').contains(&drive));
     }
 
     #[test]
@@ -717,4 +933,3 @@ mod tests {
         drop(monitor);
     }
 }
-

tests/carrier_model_a_test.rs

@@ -7,8 +7,8 @@ use rand::rngs::OsRng;
 use rand::RngCore;
 
 use sanctum::crypto::{
-    derive_kek, generate_dek, generate_salt, wrap_slot0_payload,
+    derive_kek, generate_dek, generate_salt, wrap_slot0_payload, wrap_slot1_payload, KdfParams,
-    wrap_slot1_payload, KdfParams, CHUNK_SIZE,
+    CHUNK_SIZE, MIN_MEMORY_COST_KIB, MIN_TIME_COST,
 };
 use sanctum::storage::Database;
 use sanctum::verify::verify_container;
@@ -31,8 +31,8 @@ async fn test_model_a_carrier_filesystem_and_accounting_attack_resistance() {
     let pass_hidden = "SuperSecretHiddenPassword2026!";
 
     let kdf_params = KdfParams {
-        memory_cost: 1024,
+        memory_cost: MIN_MEMORY_COST_KIB,
-        time_cost: 1,
+        time_cost: MIN_TIME_COST,
         parallelism: 1,
     };
 
@@ -45,8 +45,7 @@ async fn test_model_a_carrier_filesystem_and_accounting_attack_resistance() {
     let dek_1 = generate_dek();
 
     let carrier_node_id = 3i64;
-    let (wrapped_0, nonce_0, tag_0) =
+    let (wrapped_0, nonce_0, tag_0) = wrap_slot0_payload(&kek_0, &dek_0, carrier_node_id).unwrap();
-        wrap_slot0_payload(&kek_0, &dek_0, carrier_node_id).unwrap();
     let (wrapped_1, nonce_1, tag_1) =
         wrap_slot1_payload(&kek_1, &dek_1, &dek_0, carrier_node_id).unwrap();
 
@@ -103,7 +102,10 @@ async fn test_model_a_carrier_filesystem_and_accounting_attack_resistance() {
     let carrier_path = DavPath::new("/system_backup.dat").unwrap();
 
     // Metadaten der Alibi-Datei im Decoy prüfen
-    let carrier_meta = decoy_fs.metadata(&carrier_path).await.expect("Carrier meta");
+    let carrier_meta = decoy_fs
+        .metadata(&carrier_path)
+        .await
+        .expect("Carrier meta");
     assert_eq!(carrier_meta.len(), carrier_size_bytes);
     assert!(!carrier_meta.is_dir());
 
@@ -113,20 +115,29 @@ async fn test_model_a_carrier_filesystem_and_accounting_attack_resistance() {
         ..Default::default()
     };
     assert!(
-        matches!(decoy_fs.open(&carrier_path, write_opts).await, Err(FsError::Forbidden)),
+        matches!(
+            decoy_fs.open(&carrier_path, write_opts).await,
+            Err(FsError::Forbidden)
+        ),
         "Alibi-Datei darf nicht zum Schreiben geöffnet werden"
     );
 
     // Alibi-Datei darf im Decoy-Mount NICHT gelöscht werden
     assert!(
-        matches!(decoy_fs.remove_file(&carrier_path).await, Err(FsError::Forbidden)),
+        matches!(
+            decoy_fs.remove_file(&carrier_path).await,
+            Err(FsError::Forbidden)
+        ),
         "Alibi-Datei darf nicht gelöscht werden"
     );
 
     // Alibi-Datei darf im Decoy-Mount NICHT umbenannt werden
     let new_name = DavPath::new("/renamed.iso").unwrap();
     assert!(
-        matches!(decoy_fs.rename(&carrier_path, &new_name).await, Err(FsError::Forbidden)),
+        matches!(
+            decoy_fs.rename(&carrier_path, &new_name).await,
+            Err(FsError::Forbidden)
+        ),
         "Alibi-Datei darf nicht umbenannt werden"
     );
 
@@ -135,8 +146,14 @@ async fn test_model_a_carrier_filesystem_and_accounting_attack_resistance() {
         read: true,
         ..Default::default()
     };
-    let mut file_reader = decoy_fs.open(&carrier_path, read_opts).await.expect("Open read");
+    let mut file_reader = decoy_fs
-    let first_mb = file_reader.read_bytes(CHUNK_SIZE).await.expect("Read first chunk");
+        .open(&carrier_path, read_opts)
+        .await
+        .expect("Open read");
+    let first_mb = file_reader
+        .read_bytes(CHUNK_SIZE)
+        .await
+        .expect("Read first chunk");
     assert_eq!(first_mb.len(), CHUNK_SIZE);
 
     // 3. Hidden Mount: Dateisystem-Operationen innerhalb des Alibi-Carriers
@@ -161,11 +178,17 @@ async fn test_model_a_carrier_filesystem_and_accounting_attack_resistance() {
     while let Some(item) = stream.next().await {
         entries.push(item.unwrap().name());
     }
-    assert!(entries.is_empty(), "Hidden Vault Wurzelverzeichnis muss anfangs leer sein");
+    assert!(
+        entries.is_empty(),
+        "Hidden Vault Wurzelverzeichnis muss anfangs leer sein"
+    );
 
     // Ordner erstellen
     let secret_dir = DavPath::new("/Classified").unwrap();
-    hidden_fs.create_dir(&secret_dir).await.expect("Create Classified dir");
+    hidden_fs
+        .create_dir(&secret_dir)
+        .await
+        .expect("Create Classified dir");
 
     // Datei im Ordner anlegen und schreiben
     let secret_file_path = DavPath::new("/Classified/passwords.txt").unwrap();
@@ -196,14 +219,24 @@ async fn test_model_a_carrier_filesystem_and_accounting_attack_resistance() {
         .open(&secret_file_path, read_opts)
         .await
         .expect("Open secret file for read");
-    let read_data = read_handle.read_bytes(1024).await.expect("Read secret bytes");
+    let read_data = read_handle
+        .read_bytes(1024)
+        .await
+        .expect("Read secret bytes");
     assert_eq!(&read_data[..], secret_content);
     drop(read_handle);
 
     // Größere Binärdatei schreiben (über 2 MB = 2 Blöcke)
     let big_file_path = DavPath::new("/Classified/payload.bin").unwrap();
     let mut big_file = hidden_fs
-        .open(&big_file_path, OpenOptions { create: true, write: true, ..Default::default() })
+        .open(
+            &big_file_path,
+            OpenOptions {
+                create: true,
+                write: true,
+                ..Default::default()
+            },
+        )
         .await
         .expect("Create big file");
 
@@ -211,28 +244,46 @@ async fn test_model_a_carrier_filesystem_and_accounting_attack_resistance() {
     let mut payload = vec![0u8; payload_size];
     OsRng.fill_bytes(&mut payload);
 
-    big_file.write_bytes(Bytes::copy_from_slice(&payload)).await.expect("Write big payload");
+    big_file
+        .write_bytes(Bytes::copy_from_slice(&payload))
+        .await
+        .expect("Write big payload");
     big_file.flush().await.expect("Flush big file");
     drop(big_file);
 
     // Datei zurücklesen und Bit-für-Bit verifizieren
     let mut read_big = hidden_fs
-        .open(&big_file_path, OpenOptions { read: true, ..Default::default() })
+        .open(
+            &big_file_path,
+            OpenOptions {
+                read: true,
+                ..Default::default()
+            },
+        )
         .await
         .expect("Open big file");
-    let read_big_bytes = read_big.read_bytes(payload_size + 100).await.expect("Read big file bytes");
+    let read_big_bytes = read_big
+        .read_bytes(payload_size + 100)
+        .await
+        .expect("Read big file bytes");
     assert_eq!(read_big_bytes.len(), payload_size);
     assert_eq!(&read_big_bytes[..], &payload[..]);
     drop(read_big);
 
     // Datei umbenennen
     let renamed_path = DavPath::new("/Classified/renamed_payload.bin").unwrap();
-    hidden_fs.rename(&big_file_path, &renamed_path).await.expect("Rename file");
+    hidden_fs
+        .rename(&big_file_path, &renamed_path)
+        .await
+        .expect("Rename file");
     assert!(hidden_fs.metadata(&big_file_path).await.is_err());
     assert!(hidden_fs.metadata(&renamed_path).await.is_ok());
 
     // Datei löschen (Blöcke werden geshreddert und freigegeben)
-    hidden_fs.remove_file(&renamed_path).await.expect("Remove file");
+    hidden_fs
+        .remove_file(&renamed_path)
+        .await
+        .expect("Remove file");
     assert!(hidden_fs.metadata(&renamed_path).await.is_err());
 
     // Checkpoint SQLite
@@ -270,8 +321,8 @@ async fn test_model_a_container_file_size_invariance() {
     let pass_hidden = "HiddenPass2026!";
 
     let kdf_params = KdfParams {
-        memory_cost: 1024,
+        memory_cost: MIN_MEMORY_COST_KIB,
-        time_cost: 1,
+        time_cost: MIN_TIME_COST,
         parallelism: 1,
     };
 
@@ -284,8 +335,7 @@ async fn test_model_a_container_file_size_invariance() {
     let dek_1 = generate_dek();
 
     let carrier_node_id = 3i64;
-    let (wrapped_0, nonce_0, tag_0) =
+    let (wrapped_0, nonce_0, tag_0) = wrap_slot0_payload(&kek_0, &dek_0, carrier_node_id).unwrap();
-        wrap_slot0_payload(&kek_0, &dek_0, carrier_node_id).unwrap();
     let (wrapped_1, nonce_1, tag_1) =
         wrap_slot1_payload(&kek_1, &dek_1, &dek_0, carrier_node_id).unwrap();
 
@@ -315,7 +365,10 @@ async fn test_model_a_container_file_size_invariance() {
 
     // Initiale Dateigröße messen
     let initial_file_size = std::fs::metadata(&path).unwrap().len();
-    assert!(initial_file_size >= carrier_size_bytes, "Containergröße muss mindestens 10 MB betragen");
+    assert!(
+        initial_file_size >= carrier_size_bytes,
+        "Containergröße muss mindestens 10 MB betragen"
+    );
 
     // Hidden Mount öffnen und 4 MB geheime Daten schreiben
     let meta = db.read_meta().unwrap();
@@ -333,13 +386,23 @@ async fn test_model_a_container_file_size_invariance() {
 
     let test_file = DavPath::new("/large_confidential.pdf").unwrap();
     let mut handle = hidden_fs
-        .open(&test_file, OpenOptions { create: true, write: true, ..Default::default() })
+        .open(
+            &test_file,
+            OpenOptions {
+                create: true,
+                write: true,
+                ..Default::default()
+            },
+        )
         .await
         .expect("Open file");
 
     let mut random_data = vec![0u8; 4 * 1024 * 1024]; // 4 MB
     OsRng.fill_bytes(&mut random_data);
-    handle.write_bytes(Bytes::copy_from_slice(&random_data)).await.expect("Write 4MB");
+    handle
+        .write_bytes(Bytes::copy_from_slice(&random_data))
+        .await
+        .expect("Write 4MB");
     handle.flush().await.expect("Flush 4MB");
     drop(handle);
 
@@ -369,8 +432,8 @@ async fn test_carrier_file_drop_and_append_mode() {
     let pass_hidden = "HiddenSecretPassword2026!";
 
     let kdf_params = KdfParams {
-        memory_cost: 1024,
+        memory_cost: MIN_MEMORY_COST_KIB,
-        time_cost: 1,
+        time_cost: MIN_TIME_COST,
         parallelism: 1,
     };
 
@@ -383,8 +446,7 @@ async fn test_carrier_file_drop_and_append_mode() {
     let dek_1 = generate_dek();
 
     let carrier_node_id = 3i64;
-    let (wrapped_0, nonce_0, tag_0) =
+    let (wrapped_0, nonce_0, tag_0) = wrap_slot0_payload(&kek_0, &dek_0, carrier_node_id).unwrap();
-        wrap_slot0_payload(&kek_0, &dek_0, carrier_node_id).unwrap();
     let (wrapped_1, nonce_1, tag_1) =
         wrap_slot1_payload(&kek_1, &dek_1, &dek_0, carrier_node_id).unwrap();
 
@@ -428,45 +490,436 @@ async fn test_carrier_file_drop_and_append_mode() {
     // 1. TEST CarrierFile::drop: Write bytes OHNE expliziten flush(), dann drop(handle)
     let test_file = DavPath::new("/drop_flush_test.txt").unwrap();
     let mut write_handle = hidden_fs
-        .open(&test_file, OpenOptions { create: true, write: true, ..Default::default() })
+        .open(
+            &test_file,
+            OpenOptions {
+                create: true,
+                write: true,
+                ..Default::default()
+            },
+        )
         .await
         .expect("Open file for write");
 
     let initial_data = b"Hello from unflushed write!";
-    write_handle.write_bytes(Bytes::from_static(initial_data)).await.expect("Write initial data");
+    write_handle
+        .write_bytes(Bytes::from_static(initial_data))
+        .await
+        .expect("Write initial data");
     // WICHTIG: KEIN write_handle.flush()! Nur drop:
     drop(write_handle);
 
     // Jetzt Datei wieder lesend öffnen und prüfen, ob Daten durch Drop persistiert wurden
     let mut read_handle = hidden_fs
-        .open(&test_file, OpenOptions { read: true, ..Default::default() })
+        .open(
+            &test_file,
+            OpenOptions {
+                read: true,
+                ..Default::default()
+            },
+        )
         .await
         .expect("Open file for read");
     let read_back = read_handle.read_bytes(100).await.expect("Read data back");
-    assert_eq!(&read_back[..], initial_data, "Drop muss ungeflushte Datenblöcke und Inode automatisch sichern");
+    assert_eq!(
+        &read_back[..],
+        initial_data,
+        "Drop muss ungeflushte Datenblöcke und Inode automatisch sichern"
+    );
     drop(read_handle);
 
     // 2. TEST O_APPEND: Im Append-Modus öffnen und weitere Daten anhängen
     let append_data = b" - Appended data at EOF!";
     let mut append_handle = hidden_fs
-        .open(&test_file, OpenOptions { write: true, append: true, ..Default::default() })
+        .open(
+            &test_file,
+            OpenOptions {
+                write: true,
+                append: true,
+                ..Default::default()
+            },
+        )
         .await
         .expect("Open file for append");
 
-    append_handle.write_bytes(Bytes::from_static(append_data)).await.expect("Write appended data");
+    append_handle
+        .write_bytes(Bytes::from_static(append_data))
+        .await
+        .expect("Write appended data");
     drop(append_handle); // Drop sichert auch hier
 
     // Prüfe den vollständigen Dateiinhalt nach Append
     let mut read_handle_2 = hidden_fs
-        .open(&test_file, OpenOptions { read: true, ..Default::default() })
+        .open(
+            &test_file,
+            OpenOptions {
+                read: true,
+                ..Default::default()
+            },
+        )
         .await
         .expect("Open file for read after append");
-    let full_content = read_handle_2.read_bytes(200).await.expect("Read full content");
+    let full_content = read_handle_2
+        .read_bytes(200)
+        .await
+        .expect("Read full content");
     let mut expected = Vec::new();
     expected.extend_from_slice(initial_data);
     expected.extend_from_slice(append_data);
-    assert_eq!(&full_content[..], &expected[..], "O_APPEND muss Daten am Dateiende anhängen");
+    assert_eq!(
+        &full_content[..],
+        &expected[..],
+        "O_APPEND muss Daten am Dateiende anhängen"
+    );
     drop(read_handle_2);
 
     let _ = std::fs::remove_file(&path);
 }
+
+#[tokio::test]
+async fn test_v01_carrier_fs_copy_delegation_and_functionality() {
+    let path = temp_db_path("v01_copy");
+    let carrier_size_bytes = 10 * 1024 * 1024; // 10 MB
+    let carrier_name = "carrier_for_copy.bin";
+
+    let pass_decoy = "DecoyPass2026!";
+    let pass_hidden = "HiddenPass2026!";
+
+    let kdf_params = KdfParams {
+        memory_cost: MIN_MEMORY_COST_KIB,
+        time_cost: MIN_TIME_COST,
+        parallelism: 1,
+    };
+
+    let salt_0 = generate_salt();
+    let kek_0 = derive_kek(pass_decoy, &salt_0, &kdf_params).unwrap();
+    let dek_0 = generate_dek();
+
+    let salt_1 = generate_salt();
+    let kek_1 = derive_kek(pass_hidden, &salt_1, &kdf_params).unwrap();
+    let dek_1 = generate_dek();
+
+    let carrier_node_id = 3i64;
+    let (wrapped_0, nonce_0, tag_0) = wrap_slot0_payload(&kek_0, &dek_0, carrier_node_id).unwrap();
+    let (wrapped_1, nonce_1, tag_1) =
+        wrap_slot1_payload(&kek_1, &dek_1, &dek_0, carrier_node_id).unwrap();
+
+    let db = Database::open(&path).expect("Open database");
+
+    db.init_schema_with_carrier(
+        &salt_0,
+        &kdf_params,
+        &wrapped_0,
+        &nonce_0,
+        &tag_0,
+        Some((
+            carrier_name,
+            carrier_size_bytes,
+            &salt_1,
+            &kdf_params,
+            &wrapped_1,
+            &nonce_1,
+            &tag_1,
+            &dek_0,
+            &dek_1,
+        )),
+    )
+    .expect("Init carrier schema");
+
+    db.checkpoint().unwrap();
+
+    let meta = db.read_meta().unwrap();
+    let auth_hidden = meta.authenticate(pass_hidden).expect("Auth hidden");
+
+    let hidden_fs = SanctumFs::with_carrier(
+        db.clone(),
+        auth_hidden.dek().clone(),
+        auth_hidden.carrier_dek(),
+        auth_hidden.carrier_node_id(),
+        auth_hidden.version(),
+        true,
+        1,
+    );
+
+    // Ordner anlegen
+    let folder = DavPath::new("/work").unwrap();
+    hidden_fs.create_dir(&folder).await.expect("Create folder");
+
+    // Datei anlegen und Inhalt schreiben
+    let src_path = DavPath::new("/work/original.txt").unwrap();
+    let test_data = b"V01 CarrierFs Copy Functionality Test Payload 2026";
+    let mut file = hidden_fs
+        .open(
+            &src_path,
+            OpenOptions {
+                create: true,
+                write: true,
+                ..Default::default()
+            },
+        )
+        .await
+        .expect("Create source file");
+    file.write_bytes(Bytes::from_static(test_data))
+        .await
+        .expect("Write source data");
+    file.flush().await.expect("Flush source file");
+    drop(file);
+
+    // V-01: copy von /work/original.txt nach /work/copy.txt aufrufen
+    let dest_path = DavPath::new("/work/copy.txt").unwrap();
+    hidden_fs
+        .copy(&src_path, &dest_path)
+        .await
+        .expect("V-01: Copy must succeed on CarrierFs");
+
+    // Metadaten der Kopie prüfen
+    let copy_meta = hidden_fs
+        .metadata(&dest_path)
+        .await
+        .expect("Metadata of copied file");
+    assert_eq!(copy_meta.len(), test_data.len() as u64);
+    assert!(!copy_meta.is_dir());
+
+    // Inhalt der Kopie lesen und verifizieren
+    let mut read_copy = hidden_fs
+        .open(
+            &dest_path,
+            OpenOptions {
+                read: true,
+                ..Default::default()
+            },
+        )
+        .await
+        .expect("Open copied file");
+    let copy_bytes = read_copy.read_bytes(1024).await.expect("Read copy bytes");
+    assert_eq!(&copy_bytes[..], test_data);
+    drop(read_copy);
+
+    // Quelldatei löschen: Die Kopie muss unabhängig erhalten bleiben!
+    hidden_fs
+        .remove_file(&src_path)
+        .await
+        .expect("Delete source file");
+    assert!(hidden_fs.metadata(&src_path).await.is_err());
+
+    let mut read_copy_again = hidden_fs
+        .open(
+            &dest_path,
+            OpenOptions {
+                read: true,
+                ..Default::default()
+            },
+        )
+        .await
+        .expect("Open copied file after source delete");
+    let copy_bytes_2 = read_copy_again
+        .read_bytes(1024)
+        .await
+        .expect("Read copy bytes after source delete");
+    assert_eq!(&copy_bytes_2[..], test_data);
+    drop(read_copy_again);
+
+    // Overwrite-Copy testen
+    let src2_path = DavPath::new("/work/source2.txt").unwrap();
+    let test_data_2 = b"New Overwrite Payload Content";
+    let mut file2 = hidden_fs
+        .open(
+            &src2_path,
+            OpenOptions {
+                create: true,
+                write: true,
+                ..Default::default()
+            },
+        )
+        .await
+        .expect("Create source2");
+    file2
+        .write_bytes(Bytes::from_static(test_data_2))
+        .await
+        .expect("Write source2");
+    file2.flush().await.expect("Flush source2");
+    drop(file2);
+
+    hidden_fs
+        .copy(&src2_path, &dest_path)
+        .await
+        .expect("Overwrite copy must succeed");
+
+    let mut read_overwritten = hidden_fs
+        .open(
+            &dest_path,
+            OpenOptions {
+                read: true,
+                ..Default::default()
+            },
+        )
+        .await
+        .expect("Open overwritten copy");
+    let overwritten_bytes = read_overwritten
+        .read_bytes(1024)
+        .await
+        .expect("Read overwritten bytes");
+    assert_eq!(&overwritten_bytes[..], test_data_2);
+    drop(read_overwritten);
+
+    // Checkpoint & Verify
+    db.checkpoint().unwrap();
+    let report = verify_container(&path, Some(&dek_0), true).expect("Verify with DEK_0");
+    assert!(
+        report.is_healthy(),
+        "Container muss integer und gesund bleiben: {:?}",
+        report.errors
+    );
+
+    let _ = std::fs::remove_file(&path);
+}
+
+#[test]
+fn test_m05_deniability_schema_equality_standard_vs_hidden() {
+    let path_std = temp_db_path("schema_std");
+    let path_hidden = temp_db_path("schema_hidden");
+
+    let kdf_params = KdfParams {
+        memory_cost: MIN_MEMORY_COST_KIB,
+        time_cost: MIN_TIME_COST,
+        parallelism: 1,
+    };
+
+    let salt_std = generate_salt();
+    let kek_std = derive_kek("StandardPass123!", &salt_std, &kdf_params).unwrap();
+    let dek_std = generate_dek();
+    let (wrapped_std, nonce_std, tag_std) = wrap_slot0_payload(&kek_std, &dek_std, 0).unwrap();
+
+    let db_std = Database::open(&path_std).expect("Open std db");
+    db_std
+        .init_schema(&salt_std, &kdf_params, &wrapped_std, &nonce_std, &tag_std)
+        .expect("Init std schema");
+    db_std.checkpoint().unwrap();
+
+    let salt_0 = generate_salt();
+    let kek_0 = derive_kek("DecoyPass123!", &salt_0, &kdf_params).unwrap();
+    let dek_0 = generate_dek();
+
+    let salt_1 = generate_salt();
+    let kek_1 = derive_kek("HiddenPass123!", &salt_1, &kdf_params).unwrap();
+    let dek_1 = generate_dek();
+
+    let carrier_node_id = 3i64;
+    let (wrapped_0, nonce_0, tag_0) = wrap_slot0_payload(&kek_0, &dek_0, carrier_node_id).unwrap();
+    let (wrapped_1, nonce_1, tag_1) =
+        wrap_slot1_payload(&kek_1, &dek_1, &dek_0, carrier_node_id).unwrap();
+
+    let db_hidden = Database::open(&path_hidden).expect("Open hidden db");
+    db_hidden
+        .init_schema_with_carrier(
+            &salt_0,
+            &kdf_params,
+            &wrapped_0,
+            &nonce_0,
+            &tag_0,
+            Some((
+                "carrier.dat",
+                1024 * 1024,
+                &salt_1,
+                &kdf_params,
+                &wrapped_1,
+                &nonce_1,
+                &tag_1,
+                &dek_0,
+                &dek_1,
+            )),
+        )
+        .expect("Init carrier schema");
+    db_hidden.checkpoint().unwrap();
+
+    // Vergleiche Schemas via rusqlite
+    let conn_std = rusqlite::Connection::open(&path_std).unwrap();
+    let conn_hidden = rusqlite::Connection::open(&path_hidden).unwrap();
+
+    let get_schema_elements =
+        |conn: &rusqlite::Connection| -> Vec<(String, String, Option<String>)> {
+            let mut stmt = conn
+                .prepare(
+                    "SELECT type, name, sql FROM sqlite_master 
+                 WHERE type IN ('table', 'index') AND name NOT LIKE 'sqlite_%' 
+                 ORDER BY type, name",
+                )
+                .unwrap();
+            let rows = stmt
+                .query_map([], |row| {
+                    Ok((
+                        row.get::<_, String>(0)?,
+                        row.get::<_, String>(1)?,
+                        row.get::<_, Option<String>>(2)?,
+                    ))
+                })
+                .unwrap();
+            rows.map(|r| r.unwrap()).collect()
+        };
+
+    let schema_std = get_schema_elements(&conn_std);
+    let schema_hidden = get_schema_elements(&conn_hidden);
+
+    assert_eq!(
+        schema_std, schema_hidden,
+        "M-05: SQLite-Schema (Tabellen, Indizes, DDL) muss zwischen Standard- und Hidden-Vault identisch sein"
+    );
+
+    // Spalten- und Typinformationen vergleichen
+    for table in &["meta", "nodes", "chunks"] {
+        let get_table_info =
+            |conn: &rusqlite::Connection| -> Vec<(i64, String, String, i64, Option<String>, i64)> {
+                let mut stmt = conn
+                    .prepare(&format!("PRAGMA table_info({});", table))
+                    .unwrap();
+                let rows = stmt
+                    .query_map([], |row| {
+                        Ok((
+                            row.get::<_, i64>(0)?,
+                            row.get::<_, String>(1)?,
+                            row.get::<_, String>(2)?,
+                            row.get::<_, i64>(3)?,
+                            row.get::<_, Option<String>>(4)?,
+                            row.get::<_, i64>(5)?,
+                        ))
+                    })
+                    .unwrap();
+                rows.map(|r| r.unwrap()).collect()
+            };
+
+        let cols_std = get_table_info(&conn_std);
+        let cols_hidden = get_table_info(&conn_hidden);
+        assert_eq!(
+            cols_std, cols_hidden,
+            "M-05: Spalten und Typen für Tabelle '{}' müssen identisch sein",
+            table
+        );
+    }
+
+    // Pragmas vergleichen (page_size, auto_vacuum, secure_delete)
+    let get_pragma = |conn: &rusqlite::Connection, pragma: &str| -> i64 {
+        conn.query_row(&format!("PRAGMA {};", pragma), [], |r| r.get(0))
+            .unwrap()
+    };
+
+    assert_eq!(
+        get_pragma(&conn_std, "page_size"),
+        get_pragma(&conn_hidden, "page_size")
+    );
+    assert_eq!(
+        get_pragma(&conn_std, "auto_vacuum"),
+        get_pragma(&conn_hidden, "auto_vacuum")
+    );
+    assert_eq!(
+        get_pragma(&conn_std, "secure_delete"),
+        get_pragma(&conn_hidden, "secure_delete")
+    );
+
+    drop(conn_std);
+    drop(conn_hidden);
+    drop(db_std);
+    drop(db_hidden);
+
+    let _ = std::fs::remove_file(&path_std);
+    let _ = std::fs::remove_file(&path_hidden);
+}

tests/live_crash_resilience_test.rs

@@ -20,7 +20,10 @@ use sanctum::{
 #[tokio::test]
 async fn test_live_crash_and_recovery_stress() {
     let temp_dir = std::env::temp_dir();
-    let container_path: PathBuf = temp_dir.join(format!("sanctum_live_stress_{}.sanctum", std::process::id()));
+    let container_path: PathBuf = temp_dir.join(format!(
+        "sanctum_live_stress_{}.sanctum",
+        std::process::id()
+    ));
     if container_path.exists() {
         let _ = std::fs::remove_file(&container_path);
     }
@@ -28,8 +31,8 @@ async fn test_live_crash_and_recovery_stress() {
     let password = "LiveStressPassword2026!";
     let salt = generate_salt();
     let kdf_params = KdfParams {
-        memory_cost: 1024,
+        memory_cost: sanctum::crypto::MIN_MEMORY_COST_KIB,
-        time_cost: 1,
+        time_cost: sanctum::crypto::MIN_TIME_COST,
         parallelism: 1,
     };
     let kek = derive_kek(password, &salt, &kdf_params).expect("KEK derivation");
@@ -105,13 +108,17 @@ async fn test_live_crash_and_recovery_stress() {
 
     // 4. Recovery & Integritätsprüfung nach Crash
     // Das System muss die SQLite WAL-Datei automatisch erkennen und verarbeiten
-    let verify_result = verify_container(&container_path, Some(&dek), false).expect("Verify post-crash");
+    let verify_result =
+        verify_container(&container_path, Some(&dek), false).expect("Verify post-crash");
     assert!(
         verify_result.is_healthy(),
         "Container muss nach Crash vollkommen konsistent sein! Fehler: {:?}",
         verify_result.errors
     );
-    assert_eq!(verify_result.corrupted_chunks, 0, "Keine korrupten Chunks erlaubt");
+    assert_eq!(
+        verify_result.corrupted_chunks, 0,
+        "Keine korrupten Chunks erlaubt"
+    );
 
     // 5. Konsistentes Weiterarbeiten nach dem Absturz
     let db_recovered = Database::open(&container_path).expect("Open database after crash");

tests/mount_security_test.rs

@@ -0,0 +1,311 @@
+use sanctum::crypto::{
+    derive_kek, generate_dek, generate_salt, wrap_dek, KdfParams, MIN_MEMORY_COST_KIB,
+    MIN_TIME_COST,
+};
+use sanctum::mount::is_loopback_host;
+use sanctum::storage::Database;
+use std::path::PathBuf;
+
+#[test]
+fn test_is_loopback_host_comprehensive() {
+    // Gültige IPv4 Loopback Varianten
+    assert!(is_loopback_host("127.0.0.1"));
+    assert!(is_loopback_host("127.0.0.1:80"));
+    assert!(is_loopback_host("127.0.0.1:8080"));
+    assert!(is_loopback_host("127.0.0.1:65535"));
+
+    // Gültige Hostname Loopback Varianten
+    assert!(is_loopback_host("localhost"));
+    assert!(is_loopback_host("localhost:80"));
+    assert!(is_loopback_host("localhost:8443"));
+    assert!(is_loopback_host("LOCALHOST"));
+    assert!(is_loopback_host("LocalHost:9000"));
+
+    // Gültige IPv6 Loopback Varianten
+    assert!(is_loopback_host("[::1]"));
+    assert!(is_loopback_host("[::1]:80"));
+    assert!(is_loopback_host("[::1]:8443"));
+    assert!(is_loopback_host("::1"));
+
+    // DNS-Rebinding & Spoofing Angriffe (MÜSSEN abgewiesen werden)
+    assert!(!is_loopback_host("127.0.0.1.attacker.com"));
+    assert!(!is_loopback_host("localhost.attacker.com"));
+    assert!(!is_loopback_host("localhost.evil.org:8080"));
+    assert!(!is_loopback_host("notlocalhost"));
+    assert!(!is_loopback_host("attacker.com"));
+    assert!(!is_loopback_host("attacker.com:127001"));
+    assert!(!is_loopback_host("192.168.1.1"));
+    assert!(!is_loopback_host("10.0.0.1"));
+    assert!(!is_loopback_host("0.0.0.0"));
+    assert!(!is_loopback_host(""));
+    assert!(!is_loopback_host("   "));
+    assert!(!is_loopback_host("foo:bar:baz"));
+}
+
+#[test]
+fn test_wal_and_shm_cleanup_on_close() {
+    let temp_dir = std::env::temp_dir();
+    let container_path: PathBuf =
+        temp_dir.join(format!("test_wal_cleanup_{}.sanctum", std::process::id()));
+    if container_path.exists() {
+        let _ = std::fs::remove_file(&container_path);
+    }
+
+    let salt = generate_salt();
+    let kdf_params = KdfParams {
+        memory_cost: MIN_MEMORY_COST_KIB,
+        time_cost: MIN_TIME_COST,
+        parallelism: 1,
+    };
+    let kek = derive_kek("WalCleanupPassword2026!", &salt, &kdf_params).unwrap();
+    let dek = generate_dek();
+    let (wrapped_dek, nonce, tag) = wrap_dek(&kek, &dek).unwrap();
+
+    let db = Database::open(&container_path).unwrap();
+    db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag)
+        .unwrap();
+
+    // Erstelle Knoten, um Schreibaktivität im WAL zu erzeugen
+    let _ = db.create_node(1, "test_file.txt", false).unwrap();
+    db.checkpoint().unwrap();
+    drop(db);
+
+    // Bereinigungslogik (wie in mount.rs unmount) ausführen
+    let base_os = container_path.as_os_str().to_os_string();
+    let mut wal = base_os.clone();
+    wal.push("-wal");
+    let _ = std::fs::remove_file(&wal);
+    let mut shm = base_os;
+    shm.push("-shm");
+    let _ = std::fs::remove_file(&shm);
+
+    assert!(
+        !PathBuf::from(wal).exists(),
+        "WAL-Datei darf nach sauberem Unmount nicht zurückbleiben"
+    );
+    assert!(
+        !PathBuf::from(shm).exists(),
+        "SHM-Datei darf nach sauberem Unmount nicht zurückbleiben"
+    );
+
+    let _ = std::fs::remove_file(&container_path);
+}
+
+#[test]
+fn test_mount_security_multi_auth_and_no_token_in_url() {
+    use sanctum::mount::{check_basic_auth, check_token_header, uri_contains_token};
+
+    let session_token = "4f8a12bc90de45f187a23456789abcde";
+    let port = 8443;
+    let remote_url = format!("http://127.0.0.1:{}/", port);
+
+    // R-05 & SA-05: Die Remote-URL für Mount-Befehle darf niemals das Session-Token enthalten!
+    assert!(
+        !remote_url.contains(session_token),
+        "Remote URL darf niemals das Session-Token enthalten"
+    );
+
+    // 1. Basic Auth Prüfung (Constant-Time)
+    use base64::Engine;
+    let auth_header = format!(
+        "Basic {}",
+        base64::engine::general_purpose::STANDARD.encode(format!("sanctum:{}", session_token))
+    );
+    assert!(check_basic_auth(&auth_header, session_token));
+
+    let wrong_auth = format!(
+        "Basic {}",
+        base64::engine::general_purpose::STANDARD.encode("sanctum:wrong_token_1234567890abcdef")
+    );
+    assert!(!check_basic_auth(&wrong_auth, session_token));
+
+    // 2. Token Header Prüfung (Constant-Time)
+    let mut headers = hyper::HeaderMap::new();
+    headers.insert("X-Sanctum-Token", session_token.parse().unwrap());
+    assert!(check_token_header(&headers, session_token));
+
+    let mut wrong_headers = hyper::HeaderMap::new();
+    wrong_headers.insert(
+        "X-Sanctum-Token",
+        "wrong_token_1234567890abcdef".parse().unwrap(),
+    );
+    assert!(!check_token_header(&wrong_headers, session_token));
+
+    // 3. SA-05: Verifikation, dass Token in URI (Pfad oder Query) erkannt und strikt abgewiesen wird
+    let uri_path: hyper::Uri = format!("http://127.0.0.1:8443/{}/test.txt", session_token)
+        .parse()
+        .unwrap();
+    assert!(
+        uri_contains_token(&uri_path, session_token),
+        "Token im Pfad muss erkannt werden"
+    );
+
+    let uri_query: hyper::Uri = format!("http://127.0.0.1:8443/test.txt?token={}", session_token)
+        .parse()
+        .unwrap();
+    assert!(
+        uri_contains_token(&uri_query, session_token),
+        "Token im Query-String muss erkannt werden"
+    );
+
+    let uri_clean: hyper::Uri = "http://127.0.0.1:8443/test.txt".parse().unwrap();
+    assert!(
+        !uri_contains_token(&uri_clean, session_token),
+        "Saubere URI darf kein Token enthalten"
+    );
+}
+
+#[tokio::test]
+async fn test_vfs_memory_lock_retention_on_clone_v03() {
+    use dav_server::davpath::DavPath;
+    use dav_server::fs::{DavFileSystem, ReadDirMeta};
+    use futures_util::StreamExt;
+    use sanctum::vfs::SanctumFs;
+
+    let temp_dir = std::env::temp_dir();
+    let container_path: PathBuf =
+        temp_dir.join(format!("test_v03_lock_{}.sanctum", std::process::id()));
+    if container_path.exists() {
+        let _ = std::fs::remove_file(&container_path);
+    }
+
+    let salt = generate_salt();
+    let kdf_params = KdfParams {
+        memory_cost: MIN_MEMORY_COST_KIB,
+        time_cost: MIN_TIME_COST,
+        parallelism: 1,
+    };
+    let kek = derive_kek("TestPassV03!", &salt, &kdf_params).unwrap();
+    let dek = generate_dek();
+    let (wrapped_dek, nonce, tag) = wrap_dek(&kek, &dek).unwrap();
+
+    let db = Database::open(&container_path).unwrap();
+    db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag)
+        .unwrap();
+
+    // 1. Initialisiere SanctumFs
+    let fs = SanctumFs::new(db.clone(), dek, sanctum::crypto::FORMAT_VERSION);
+    assert_eq!(
+        fs.dek_strong_count(),
+        1,
+        "Anfangs muss genau 1 Referenz auf den verriegelten DEK existieren"
+    );
+
+    // 2. Klone SanctumFs (wie bei jeder HTTP/WebDAV-Anfrage im Server)
+    let fs_clone = fs.clone();
+    assert_eq!(
+        fs.dek_strong_count(),
+        2,
+        "Nach dem Klonen müssen 2 Referenzen existieren"
+    );
+
+    // 3. Droppe den Klon
+    drop(fs_clone);
+
+    // 4. V-03: Der Refcount muss nun wieder 1 sein. Der Speicherbereich darf NICHT
+    // vorzeitig über Drop eines Klons entriegelt worden sein!
+    assert_eq!(
+        fs.dek_strong_count(),
+        1,
+        "Nach Drop des Klons muss genau 1 Referenz erhalten bleiben"
+    );
+
+    // Verifiziere funktionale Nutzbarkeit nach Drop des Klons
+    let root_path = DavPath::new("/").unwrap();
+    let mut entries = fs.read_dir(&root_path, ReadDirMeta::None).await.unwrap();
+    assert!(entries.next().await.is_none());
+
+    drop(fs);
+    let _ = std::fs::remove_file(&container_path);
+}
+
+#[test]
+fn test_z01_decoy_password_zeroize_memory() {
+    use sanctum::mount::ContainerAuth;
+    use zeroize::Zeroizing;
+
+    // Test that ContainerAuth properly encapsulates Zeroizing credentials
+    let raw_pass = "TopSecretDecoyPass2026!".to_string();
+    let zeroized_pass = Zeroizing::new(raw_pass.clone());
+    let auth = ContainerAuth::Password(zeroized_pass.clone());
+
+    if let ContainerAuth::Password(ref p) = auth {
+        assert_eq!(p.as_str(), raw_pass.as_str());
+    } else {
+        panic!("ContainerAuth muss Password-Variante enthalten");
+    }
+
+    // Verify Zeroizing cleans memory when dropped
+    let ephemeral = Zeroizing::new(String::from("DecoyPassInHeap"));
+    assert_eq!(&*ephemeral, "DecoyPassInHeap");
+    // Explicit drop calls zeroize
+    drop(ephemeral);
+}
+
+#[tokio::test]
+async fn test_z04_webdav_quota_report() {
+    use dav_server::fs::DavFileSystem;
+    use sanctum::vfs::SanctumFs;
+
+    let temp_dir = std::env::temp_dir();
+    let container_path: PathBuf =
+        temp_dir.join(format!("test_z04_quota_{}.sanctum", std::process::id()));
+    if container_path.exists() {
+        let _ = std::fs::remove_file(&container_path);
+    }
+
+    let salt = generate_salt();
+    let kdf_params = KdfParams {
+        memory_cost: MIN_MEMORY_COST_KIB,
+        time_cost: MIN_TIME_COST,
+        parallelism: 1,
+    };
+    let kek = derive_kek("TestPassZ04!", &salt, &kdf_params).unwrap();
+    let dek = generate_dek();
+    let (wrapped_dek, nonce, tag) = wrap_dek(&kek, &dek).unwrap();
+
+    let db = Database::open(&container_path).unwrap();
+    db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag)
+        .unwrap();
+
+    // Erstelle einen Testknoten mit Chunks
+    let node = db.create_node(1, "payload.bin", false).unwrap();
+    let dummy_chunk = vec![0xAAu8; 1024 * 1024]; // 1 MiB
+    db.write_chunk_and_update_size(
+        node.id,
+        0,
+        0,
+        &[0u8; 12],
+        &[0u8; 16],
+        &dummy_chunk,
+        1024 * 1024,
+        123456,
+    )
+    .unwrap();
+
+    let fs = SanctumFs::new(db.clone(), dek, sanctum::crypto::FORMAT_VERSION);
+
+    // Rufe WebDAV get_quota ab
+    let (used, total_opt) = fs.get_quota().await.unwrap();
+
+    assert!(
+        used > 0,
+        "Z-04: Verwendeter Speicherplatz muss > 0 sein (gemeldet: {} Bytes)",
+        used
+    );
+    assert!(
+        total_opt.is_some(),
+        "Z-04: Gesamtkapazität muss gemeldet werden"
+    );
+    let total = total_opt.unwrap();
+    assert!(
+        total >= used,
+        "Z-04: Gesamtkapazität ({}) muss mindestens dem belegten Speicher ({}) entsprechen",
+        total,
+        used
+    );
+
+    drop(fs);
+    drop(db);
+    let _ = std::fs::remove_file(&container_path);
+}

tests/path_traversal_test.rs

@@ -0,0 +1,129 @@
+use sanctum::sync::validate_node_name;
+
+#[test]
+fn test_validate_node_name_rejections() {
+    // 1. Leere Namen
+    assert!(validate_node_name("").is_err());
+
+    // 2. Relative Verzeichnisreferenzen
+    assert!(validate_node_name(".").is_err());
+    assert!(validate_node_name("..").is_err());
+
+    // 3. Pfadtrenner
+    assert!(validate_node_name("foo/bar").is_err());
+    assert!(validate_node_name("foo\\bar").is_err());
+    assert!(validate_node_name("../evil.exe").is_err());
+    assert!(validate_node_name("..\\evil.exe").is_err());
+    assert!(validate_node_name("/root_file").is_err());
+
+    // 4. Null-Bytes
+    assert!(validate_node_name("test\0file.txt").is_err());
+
+    // 5. Steuerzeichen (< 0x20)
+    assert!(validate_node_name("line\nbreak.txt").is_err());
+    assert!(validate_node_name("carriage\rreturn.txt").is_err());
+    assert!(validate_node_name("tab\tseparated.txt").is_err());
+    assert!(validate_node_name("control\x01char.txt").is_err());
+
+    // 6. Windows reservierte Gerätenamen
+    let reserved_names = [
+        "CON",
+        "con",
+        "prn",
+        "PRN",
+        "aux",
+        "AUX",
+        "nul",
+        "NUL",
+        "COM1",
+        "com2",
+        "COM9",
+        "lpt1",
+        "LPT2",
+        "LPT9",
+        "con.txt",
+        "aux.dat",
+        "NUL.tar.gz",
+        "com1.log",
+        "prn.pdf",
+    ];
+    for res in reserved_names {
+        assert!(
+            validate_node_name(res).is_err(),
+            "Reservierter Name '{}' muss abgewiesen werden",
+            res
+        );
+    }
+}
+
+#[test]
+fn test_validate_node_name_accepted() {
+    let valid_names = [
+        "document.pdf",
+        "my_notes_2026.txt",
+        "archive.tar.gz",
+        "spaces are allowed.docx",
+        "unicode_äöü_ß_test.rs",
+        "hyphens-and_underscores.json",
+        "file (1).jpg",
+        "normal_file",
+    ];
+    for valid in valid_names {
+        assert!(
+            validate_node_name(valid).is_ok(),
+            "Gültiger Name '{}' sollte akzeptiert werden",
+            valid
+        );
+    }
+}
+
+#[test]
+fn test_storage_create_and_rename_reject_invalid_names() {
+    let mut path = std::env::temp_dir();
+    path.push(format!(
+        "sanctum_test_pathutil_{}.sanctum",
+        std::process::id()
+    ));
+    if path.exists() {
+        let _ = std::fs::remove_file(&path);
+    }
+
+    let salt = sanctum::crypto::generate_salt();
+    let kdf_params = sanctum::crypto::KdfParams {
+        memory_cost: sanctum::crypto::MIN_MEMORY_COST_KIB,
+        time_cost: sanctum::crypto::MIN_TIME_COST,
+        parallelism: 1,
+    };
+    let kek = sanctum::crypto::derive_kek("Pass1234!", &salt, &kdf_params).unwrap();
+    let dek = sanctum::crypto::generate_dek();
+    let (wrapped, nonce, tag) = sanctum::crypto::wrap_dek(&kek, &dek).unwrap();
+
+    let db = sanctum::storage::Database::open(&path).unwrap();
+    db.init_schema(&salt, &kdf_params, &wrapped, &nonce, &tag)
+        .unwrap();
+
+    // create_node_in_vault mit ungültigem Namen muss scheitern
+    assert!(db.create_node_in_vault(0, 1, "..", false, &dek).is_err());
+    assert!(db.create_node_in_vault(0, 1, "CON", false, &dek).is_err());
+    assert!(db
+        .create_node_in_vault(0, 1, "sub/dir", false, &dek)
+        .is_err());
+
+    // Gültige Datei erstellen
+    let valid_node = db
+        .create_node_in_vault(0, 1, "valid.txt", false, &dek)
+        .unwrap();
+
+    // rename_node_in_vault mit ungültigem Namen muss scheitern
+    assert!(db
+        .rename_node_in_vault(valid_node.id, 1, "..", 0, &dek)
+        .is_err());
+    assert!(db
+        .rename_node_in_vault(valid_node.id, 1, "AUX", 0, &dek)
+        .is_err());
+    assert!(db
+        .rename_node_in_vault(valid_node.id, 1, "bad\\name", 0, &dek)
+        .is_err());
+
+    let _ = std::fs::remove_file(&path);
+}

tests/sync_carrier_protection_test.rs

@@ -0,0 +1,232 @@
+use rand::rngs::OsRng;
+use rand::RngCore;
+use std::collections::HashSet;
+use std::path::PathBuf;
+
+use sanctum::crypto::{
+    derive_kek, generate_dek, generate_salt, wrap_slot0_payload, wrap_slot1_payload, KdfParams,
+    MIN_MEMORY_COST_KIB, MIN_TIME_COST,
+};
+use sanctum::storage::Database;
+use sanctum::sync::{delete_orphans_in_vault, SyncStats};
+
+fn temp_db_path(prefix: &str) -> PathBuf {
+    let mut path = std::env::temp_dir();
+    let id: u64 = OsRng.next_u64();
+    path.push(format!("sanctum_test_{}_{}.sanctum", prefix, id));
+    path
+}
+
+#[test]
+fn test_carrier_protection_in_storage_and_sync() {
+    let path = temp_db_path("carrier_sec");
+    let carrier_name = "secret_carrier.iso";
+    let carrier_size_bytes = 2 * 1024 * 1024; // 2 MB
+
+    let pass_decoy = "DecoyPassword2026!";
+    let pass_hidden = "SuperSecretHiddenPassword2026!";
+
+    let kdf_params = KdfParams {
+        memory_cost: MIN_MEMORY_COST_KIB,
+        time_cost: MIN_TIME_COST,
+        parallelism: 1,
+    };
+
+    let salt_0 = generate_salt();
+    let kek_0 = derive_kek(pass_decoy, &salt_0, &kdf_params).unwrap();
+    let dek_0 = generate_dek();
+
+    let salt_1 = generate_salt();
+    let kek_1 = derive_kek(pass_hidden, &salt_1, &kdf_params).unwrap();
+    let dek_1 = generate_dek();
+
+    let carrier_node_id = 3i64;
+    let (wrapped_0, nonce_0, tag_0) = wrap_slot0_payload(&kek_0, &dek_0, carrier_node_id).unwrap();
+    let (wrapped_1, nonce_1, tag_1) =
+        wrap_slot1_payload(&kek_1, &dek_1, &dek_0, carrier_node_id).unwrap();
+
+    let db = Database::open(&path).expect("Open database");
+
+    let created_cid = db
+        .init_schema_with_carrier(
+            &salt_0,
+            &kdf_params,
+            &wrapped_0,
+            &nonce_0,
+            &tag_0,
+            Some((
+                carrier_name,
+                carrier_size_bytes,
+                &salt_1,
+                &kdf_params,
+                &wrapped_1,
+                &nonce_1,
+                &tag_1,
+                &dek_0,
+                &dek_1,
+            )),
+        )
+        .expect("Init carrier schema");
+
+    db.checkpoint().unwrap();
+    assert_eq!(created_cid, Some(carrier_node_id));
+
+    // 1. Direkter Löschversuch der Trägerdatei muss fail-closed abgewehrt werden
+    let del_res = db.delete_node(carrier_node_id);
+    assert!(
+        del_res.is_err(),
+        "Löschen der Trägerdatei muss fehlschlagen"
+    );
+    assert!(del_res.unwrap_err().to_string().contains("Carrier-Schutz"));
+
+    // 2. Umbenennung der Trägerdatei muss fail-closed abgewehrt werden
+    let rename_res = db.rename_node_in_vault(carrier_node_id, 1, "renamed.iso", 0, &dek_0);
+    assert!(
+        rename_res.is_err(),
+        "Umbenennen der Trägerdatei muss fehlschlagen"
+    );
+    assert!(rename_res
+        .unwrap_err()
+        .to_string()
+        .contains("Carrier-Schutz"));
+
+    // 3. Truncate der Trägerdatei muss fail-closed abgewehrt werden
+    let trunc_res = db.truncate_chunks_after(carrier_node_id, 0);
+    assert!(
+        trunc_res.is_err(),
+        "Truncate der Trägerdatei muss fehlschlagen"
+    );
+    assert!(trunc_res
+        .unwrap_err()
+        .to_string()
+        .contains("Carrier-Schutz"));
+
+    // 4. delete_orphans_in_vault mit leerem lokalem Pfad-Set:
+    // Der Carrier darf unter keinen Umständen gelöscht werden!
+    let local_paths = HashSet::new();
+    let excluded_paths = HashSet::new();
+    let mut stats = SyncStats::default();
+    let orphan_res = delete_orphans_in_vault(
+        &db,
+        0, // Decoy Vault ID
+        &dek_0,
+        1, // Root-Knoten
+        "",
+        &local_paths,
+        &excluded_paths,
+        &[],
+        false, // delete_excluded: false
+        false, // kein dry_run
+        true,  // quiet
+        &mut stats,
+    );
+    assert!(
+        orphan_res.is_ok(),
+        "delete_orphans_in_vault muss ohne Fehler durchlaufen"
+    );
+    assert_eq!(
+        stats.files_deleted, 0,
+        "Carrier-Datei darf nicht gelöscht worden sein"
+    );
+
+    // Sicherstellen, dass Carrier nach wie vor in der DB existiert
+    let carrier_rec = db.get_node_by_id(carrier_node_id).unwrap();
+    assert!(
+        carrier_rec.is_some(),
+        "Carrier-Knoten muss nach Sync unversehrt vorhanden sein"
+    );
+
+    // 5. R-02: sync_single_file_to_host muss Carrier-Pull strikt ablehnen
+    let carrier_node = db.get_node_by_id(carrier_node_id).unwrap().unwrap();
+    let local_dest_file =
+        std::env::temp_dir().join(format!("carrier_leak_{}.iso", std::process::id()));
+    let pull_single_res = sanctum::sync::sync_single_file_to_host(
+        &db,
+        0,
+        &dek_0,
+        sanctum::crypto::FORMAT_VERSION,
+        &carrier_node,
+        &local_dest_file,
+        false,
+        false,
+    );
+    assert!(
+        pull_single_res.is_err(),
+        "sync_single_file_to_host auf Carrier muss fehlschlagen"
+    );
+    assert!(
+        !local_dest_file.exists(),
+        "Trägerdatei darf niemals auf den Host geschrieben werden"
+    );
+
+    // 6. R-02: run_sync mit Pull muss die Trägerdatei überspringen
+    let local_pull_dir =
+        std::env::temp_dir().join(format!("sanctum_pull_test_{}", std::process::id()));
+    let sync_options = sanctum::sync::SyncOptions {
+        direction: sanctum::sync::SyncDirection::Pull,
+        delete: false,
+        delete_excluded: false,
+        dry_run: false,
+        checksum: false,
+        exclude_patterns: Vec::new(),
+        quiet: true,
+        force: false,
+        backup: false,
+        update: false,
+    };
+    let pull_res = sanctum::sync::run_sync(
+        &db,
+        0,
+        &dek_0,
+        sanctum::crypto::FORMAT_VERSION,
+        "/",
+        &local_pull_dir.to_string_lossy(),
+        &sync_options,
+    );
+    assert!(
+        pull_res.is_ok(),
+        "run_sync pull muss erfolgreich durchlaufen"
+    );
+    let pulled_carrier = local_pull_dir.join(carrier_name);
+    assert!(
+        !pulled_carrier.exists(),
+        "Trägerdatei darf bei recursive pull nicht auf den Host kopiert werden"
+    );
+    let _ = std::fs::remove_dir_all(&local_pull_dir);
+
+    // 7. R-02: VFS Copy Schutz
+    let fs = sanctum::vfs::SanctumFs::with_carrier(
+        db.clone(),
+        dek_0.clone(),
+        Some(dek_0.clone()),
+        Some(carrier_node_id),
+        sanctum::crypto::FORMAT_VERSION,
+        false,
+        0,
+    );
+    use dav_server::davpath::DavPath;
+    use dav_server::fs::DavFileSystem;
+    // Copy Quelle = Carrier
+    let from_carrier = DavPath::new(&format!("/{}", carrier_name)).unwrap();
+    let to_copy = DavPath::new("/carrier_copy.iso").unwrap();
+    let rt = tokio::runtime::Runtime::new().unwrap();
+    let copy_src_res = rt.block_on(fs.copy(&from_carrier, &to_copy));
+    assert!(
+        copy_src_res.is_err(),
+        "SanctumFs::copy mit Carrier als Quelle muss FsError::Forbidden liefern"
+    );
+
+    // Copy Ziel = Carrier
+    let _regular_file = db
+        .create_node_in_vault(0, 1, "regular.txt", false, &dek_0)
+        .unwrap();
+    let from_regular = DavPath::new("/regular.txt").unwrap();
+    let to_carrier = DavPath::new(&format!("/{}", carrier_name)).unwrap();
+    let copy_dst_res = rt.block_on(fs.copy(&from_regular, &to_carrier));
+    assert!(
+        copy_dst_res.is_err(),
+        "SanctumFs::copy mit Carrier als Ziel muss FsError::Forbidden liefern"
+    );
+
+    let _ = std::fs::remove_file(&path);
+}

tests/untrusted_container_test.rs

@@ -0,0 +1,997 @@
+use sanctum::crypto::{
+    decrypt_chunk, derive_kek, encrypt_chunk, generate_dek, generate_salt, wrap_dek,
+    wrap_slot0_payload, KdfParams, MIN_MEMORY_COST_KIB, MIN_TIME_COST,
+};
+use sanctum::storage::Database;
+use sanctum::verify::verify_container;
+use std::path::PathBuf;
+
+#[test]
+fn test_reject_arbitrary_sqlite_database() {
+    let temp_dir = std::env::temp_dir();
+    let db_path: PathBuf = temp_dir.join(format!("test_foreign_sqlite_{}.db", std::process::id()));
+    if db_path.exists() {
+        let _ = std::fs::remove_file(&db_path);
+    }
+
+    // Erstelle eine fremde SQLite-Datenbank mit beliebigen Daten
+    {
+        let conn = rusqlite::Connection::open(&db_path).unwrap();
+        conn.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)", [])
+            .unwrap();
+        conn.execute("INSERT INTO users (name) VALUES ('Alice')", [])
+            .unwrap();
+    }
+
+    // Sanctum Database::open muss die Datei sofort fail-closed ablehnen
+    let res = Database::open(&db_path);
+    match res {
+        Err(err) => {
+            let msg = err.to_string();
+            assert!(
+                msg.contains("kein gültiger Sanctum-Container"),
+                "Fehler muss ungültigen Container abweisen: {msg}"
+            );
+        }
+        Ok(_) => panic!("Fremde SQLite-DB ohne meta-Tabelle muss abgelehnt werden"),
+    }
+
+    let _ = std::fs::remove_file(&db_path);
+}
+
+#[test]
+fn test_reject_sqlite_database_with_invalid_magic() {
+    let temp_dir = std::env::temp_dir();
+    let db_path: PathBuf = temp_dir.join(format!("test_invalid_magic_{}.db", std::process::id()));
+    if db_path.exists() {
+        let _ = std::fs::remove_file(&db_path);
+    }
+
+    // Erstelle SQLite DB mit 'meta' Tabelle, aber falscher Magic
+    {
+        let conn = rusqlite::Connection::open(&db_path).unwrap();
+        conn.execute(
+            "CREATE TABLE meta (
+                slot_id INTEGER PRIMARY KEY,
+                magic BLOB NOT NULL,
+                version INTEGER NOT NULL,
+                kdf_salt BLOB NOT NULL,
+                kdf_params TEXT NOT NULL,
+                wrapped_dek BLOB NOT NULL,
+                header_nonce BLOB NOT NULL,
+                header_tag BLOB NOT NULL
+            );",
+            [],
+        )
+        .unwrap();
+        conn.execute(
+            "INSERT INTO meta (slot_id, magic, version, kdf_salt, kdf_params, wrapped_dek, header_nonce, header_tag)
+             VALUES (0, ?1, 2, ?2, '{}', ?3, ?4, ?5)",
+            rusqlite::params![
+                b"EVIL_MAGIC",
+                &[0u8; 16][..],
+                &[0u8; 40][..],
+                &[0u8; 12][..],
+                &[0u8; 16][..]
+            ],
+        )
+        .unwrap();
+    }
+
+    let res = Database::open(&db_path);
+    match res {
+        Err(err) => {
+            let msg = err.to_string();
+            assert!(
+                msg.contains("kein gültiger Sanctum-Container"),
+                "Fehler muss ungültigen Magic-Header monieren: {msg}"
+            );
+        }
+        Ok(_) => panic!("Container mit ungültigen Magic Bytes muss abgelehnt werden"),
+    }
+
+    let _ = std::fs::remove_file(&db_path);
+}
+
+#[test]
+fn test_reject_out_of_bounds_kdf_params() {
+    let temp_dir = std::env::temp_dir();
+    let db_path: PathBuf = temp_dir.join(format!("test_oob_kdf_{}.sanctum", std::process::id()));
+    if db_path.exists() {
+        let _ = std::fs::remove_file(&db_path);
+    }
+
+    // 1. Initialisiere gültigen Container
+    let salt = generate_salt();
+    let kdf_params = KdfParams {
+        memory_cost: MIN_MEMORY_COST_KIB,
+        time_cost: MIN_TIME_COST,
+        parallelism: 1,
+    };
+    let kek = derive_kek("ValidPassword2026!", &salt, &kdf_params).unwrap();
+    let dek = generate_dek();
+    let (wrapped_dek, nonce, tag) = wrap_dek(&kek, &dek).unwrap();
+
+    let db = Database::open(&db_path).unwrap();
+    db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag)
+        .unwrap();
+    db.checkpoint().unwrap();
+    drop(db);
+
+    // 2. Manipuliere KDF-Parameter in der meta-Tabelle auf gefährliche Werte (DoS: 16 GiB Memory)
+    {
+        let conn = rusqlite::Connection::open(&db_path).unwrap();
+        conn.execute(
+            "UPDATE meta SET kdf_params = '{\"memory_cost\": 16777216, \"time_cost\": 3, \"parallelism\": 4}' WHERE slot_id = 0",
+            [],
+        )
+        .unwrap();
+    }
+
+    // 3. Öffnen und read_slots() aufrufen: muss mit Kdf-Param-Fehler abbrechen
+    let db_reopened = Database::open(&db_path).unwrap();
+    let slots_res = db_reopened.read_slots();
+    match slots_res {
+        Err(err) => {
+            let msg = err.to_string();
+            assert!(
+                msg.contains("KDF-Parameter"),
+                "Fehler muss KDF-Parameter monieren: {msg}"
+            );
+        }
+        Ok(_) => panic!("Überhöhte KDF-Parameter müssen fail-closed abgewehrt werden"),
+    }
+
+    // 4. Manipuliere KDF-Parameter auf zu schwache Werte (< MIN_MEMORY_COST_KIB)
+    {
+        let conn = rusqlite::Connection::open(&db_path).unwrap();
+        conn.execute(
+            "UPDATE meta SET kdf_params = '{\"memory_cost\": 1024, \"time_cost\": 3, \"parallelism\": 4}' WHERE slot_id = 0",
+            [],
+        )
+        .unwrap();
+    }
+    let slots_res2 = db_reopened.read_slots();
+    match slots_res2 {
+        Err(err) => {
+            let msg = err.to_string();
+            assert!(
+                msg.contains("KDF-Parameter"),
+                "Fehler muss KDF-Parameter monieren: {msg}"
+            );
+        }
+        Ok(_) => panic!("Zu schwache KDF-Parameter müssen fail-closed abgewehrt werden"),
+    }
+
+    let _ = std::fs::remove_file(&db_path);
+}
+
+#[test]
+fn test_reject_corrupted_slot_lengths() {
+    let temp_dir = std::env::temp_dir();
+    let db_path: PathBuf =
+        temp_dir.join(format!("test_slot_lengths_{}.sanctum", std::process::id()));
+    if db_path.exists() {
+        let _ = std::fs::remove_file(&db_path);
+    }
+
+    let salt = generate_salt();
+    let kdf_params = KdfParams {
+        memory_cost: MIN_MEMORY_COST_KIB,
+        time_cost: MIN_TIME_COST,
+        parallelism: 1,
+    };
+    let kek = derive_kek("ValidPassword2026!", &salt, &kdf_params).unwrap();
+    let dek = generate_dek();
+    let (wrapped_dek, nonce, tag) = wrap_dek(&kek, &dek).unwrap();
+
+    let db = Database::open(&db_path).unwrap();
+    db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag)
+        .unwrap();
+    db.checkpoint().unwrap();
+    drop(db);
+
+    // Manipuliere Salt-Länge auf 8 Byte statt 16 Byte
+    {
+        let conn = rusqlite::Connection::open(&db_path).unwrap();
+        conn.execute(
+            "UPDATE meta SET kdf_salt = ?1 WHERE slot_id = 0",
+            [&[0u8; 8][..]],
+        )
+        .unwrap();
+    }
+
+    let db_reopened = Database::open(&db_path).unwrap();
+    let res = db_reopened.read_slots();
+    match res {
+        Err(err) => {
+            let msg = err.to_string();
+            assert!(
+                msg.contains("Salt-Länge"),
+                "Fehler muss fehlerhafte Salt-Länge monieren: {msg}"
+            );
+        }
+        Ok(_) => panic!("Ungültige Salt-Länge muss abgewiesen werden"),
+    }
+
+    let _ = std::fs::remove_file(&db_path);
+}
+
+#[test]
+fn test_reject_slot_amplification_and_excessive_slots_dos() {
+    let temp_dir = std::env::temp_dir();
+    let salt = generate_salt();
+    let kdf_params = KdfParams {
+        memory_cost: MIN_MEMORY_COST_KIB,
+        time_cost: MIN_TIME_COST,
+        parallelism: 1,
+    };
+    let kek = derive_kek("TestPassword2026!", &salt, &kdf_params).unwrap();
+    let dek = generate_dek();
+    let (wrapped_dek, nonce, tag) = wrap_dek(&kek, &dek).unwrap();
+    let params_json = serde_json::to_string(&kdf_params).unwrap();
+
+    // 1. Fall: 0 Slots (leere meta-Tabelle)
+    {
+        let db_path = temp_dir.join(format!("test_0_slots_{}.sanctum", std::process::id()));
+        let _ = std::fs::remove_file(&db_path);
+        {
+            let conn = rusqlite::Connection::open(&db_path).unwrap();
+            conn.execute(
+                "CREATE TABLE meta (
+                    slot_id INTEGER PRIMARY KEY, magic BLOB NOT NULL, version INTEGER NOT NULL,
+                    kdf_salt BLOB NOT NULL, kdf_params TEXT NOT NULL, wrapped_dek BLOB NOT NULL,
+                    header_nonce BLOB NOT NULL, header_tag BLOB NOT NULL
+                );",
+                [],
+            )
+            .unwrap();
+            conn.execute("CREATE TABLE nodes (id INTEGER PRIMARY KEY);", [])
+                .unwrap();
+            conn.execute("CREATE TABLE chunks (node_id INTEGER);", [])
+                .unwrap();
+        }
+        let db = Database::open(&db_path).unwrap();
+        let res = db.read_slots();
+        assert!(res.is_err());
+        let err_msg = res.err().unwrap().to_string();
+        assert!(
+            err_msg.contains("leer oder beschädigt"),
+            "Fehlermeldung: {err_msg}"
+        );
+        let _ = std::fs::remove_file(&db_path);
+    }
+
+    // 2. Fall: Genau 1 Slot (Slot 0 Decoy/Standard) -> MUSS erfolgreich sein
+    {
+        let db_path = temp_dir.join(format!("test_1_slot_{}.sanctum", std::process::id()));
+        let _ = std::fs::remove_file(&db_path);
+        let db = Database::open(&db_path).unwrap();
+        db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag)
+            .unwrap();
+        // Lösche Dummy-Slot 1, um reinen 1-Slot Container zu simulieren
+        {
+            let conn = rusqlite::Connection::open(&db_path).unwrap();
+            conn.execute("DELETE FROM meta WHERE slot_id = 1", [])
+                .unwrap();
+        }
+        let db_reopened = Database::open(&db_path).unwrap();
+        let slots = db_reopened
+            .read_slots()
+            .expect("1 gültiger Slot (Slot 0) muss erfolgreich gelesen werden");
+        assert_eq!(slots.len(), 1);
+        assert_eq!(slots[0].slot_id, 0);
+        let _ = std::fs::remove_file(&db_path);
+    }
+
+    // 3. Fall: Genau 2 Slots (Slot 0 & Slot 1) -> MUSS erfolgreich sein
+    {
+        let db_path = temp_dir.join(format!("test_2_slots_{}.sanctum", std::process::id()));
+        let _ = std::fs::remove_file(&db_path);
+        let db = Database::open(&db_path).unwrap();
+        db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag)
+            .unwrap();
+        let slots = db
+            .read_slots()
+            .expect("2 gültige Slots müssen erfolgreich gelesen werden");
+        assert_eq!(slots.len(), 2);
+        assert_eq!(slots[0].slot_id, 0);
+        assert_eq!(slots[1].slot_id, 1);
+        let _ = std::fs::remove_file(&db_path);
+    }
+
+    // 4. Fall: 3 Slots (Überschreitung des Limits von 2) -> MUSS fail-closed abgewehrt werden
+    {
+        let db_path = temp_dir.join(format!("test_3_slots_{}.sanctum", std::process::id()));
+        let _ = std::fs::remove_file(&db_path);
+        {
+            let conn = rusqlite::Connection::open(&db_path).unwrap();
+            conn.execute(
+                "CREATE TABLE meta (
+                    slot_id INTEGER, magic BLOB NOT NULL, version INTEGER NOT NULL,
+                    kdf_salt BLOB NOT NULL, kdf_params TEXT NOT NULL, wrapped_dek BLOB NOT NULL,
+                    header_nonce BLOB NOT NULL, header_tag BLOB NOT NULL
+                );",
+                [],
+            )
+            .unwrap();
+            for i in 0..3 {
+                conn.execute(
+                    "INSERT INTO meta VALUES (?1, ?2, 2, ?3, ?4, ?5, ?6, ?7)",
+                    rusqlite::params![
+                        i,
+                        b"SANCTUM\0",
+                        &salt[..],
+                        &params_json,
+                        &wrapped_dek[..],
+                        &nonce[..],
+                        &tag[..]
+                    ],
+                )
+                .unwrap();
+            }
+        }
+        let open_res = Database::open(&db_path);
+        assert!(
+            open_res.is_err(),
+            "Database::open muss 3 Slots sofort abweisen"
+        );
+        let err_msg = open_res.err().unwrap().to_string();
+        assert!(
+            err_msg.contains("Ungültige Slot-Anzahl"),
+            "Fehlermeldung: {err_msg}"
+        );
+        let _ = std::fs::remove_file(&db_path);
+    }
+
+    // 5. Fall: 100 Slots (KDF-Amplification DoS Angriff) -> MUSS sofort ohne KDF abgewehrt werden
+    {
+        let db_path = temp_dir.join(format!("test_100_slots_{}.sanctum", std::process::id()));
+        let _ = std::fs::remove_file(&db_path);
+        {
+            let conn = rusqlite::Connection::open(&db_path).unwrap();
+            conn.execute(
+                "CREATE TABLE meta (
+                    slot_id INTEGER, magic BLOB NOT NULL, version INTEGER NOT NULL,
+                    kdf_salt BLOB NOT NULL, kdf_params TEXT NOT NULL, wrapped_dek BLOB NOT NULL,
+                    header_nonce BLOB NOT NULL, header_tag BLOB NOT NULL
+                );",
+                [],
+            )
+            .unwrap();
+            for i in 0..100 {
+                conn.execute(
+                    "INSERT INTO meta VALUES (?1, ?2, 2, ?3, ?4, ?5, ?6, ?7)",
+                    rusqlite::params![
+                        i,
+                        b"SANCTUM\0",
+                        &salt[..],
+                        &params_json,
+                        &wrapped_dek[..],
+                        &nonce[..],
+                        &tag[..]
+                    ],
+                )
+                .unwrap();
+            }
+        }
+        let open_res = Database::open(&db_path);
+        assert!(
+            open_res.is_err(),
+            "100 Slots müssen sofort abgewiesen werden"
+        );
+        let _ = std::fs::remove_file(&db_path);
+    }
+
+    // 6. Fall: 1000 Slots (Massiver DoS-Angriff) -> MUSS sofort abgewehrt werden
+    {
+        let db_path = temp_dir.join(format!("test_1000_slots_{}.sanctum", std::process::id()));
+        let _ = std::fs::remove_file(&db_path);
+        {
+            let conn = rusqlite::Connection::open(&db_path).unwrap();
+            conn.execute(
+                "CREATE TABLE meta (
+                    slot_id INTEGER, magic BLOB NOT NULL, version INTEGER NOT NULL,
+                    kdf_salt BLOB NOT NULL, kdf_params TEXT NOT NULL, wrapped_dek BLOB NOT NULL,
+                    header_nonce BLOB NOT NULL, header_tag BLOB NOT NULL
+                );",
+                [],
+            )
+            .unwrap();
+            let mut stmt = conn
+                .prepare("INSERT INTO meta VALUES (?1, ?2, 2, ?3, ?4, ?5, ?6, ?7)")
+                .unwrap();
+            for i in 0..1000 {
+                stmt.execute(rusqlite::params![
+                    i,
+                    b"SANCTUM\0",
+                    &salt[..],
+                    &params_json,
+                    &wrapped_dek[..],
+                    &nonce[..],
+                    &tag[..]
+                ])
+                .unwrap();
+            }
+        }
+        let open_res = Database::open(&db_path);
+        assert!(
+            open_res.is_err(),
+            "1000 Slots müssen sofort abgewiesen werden"
+        );
+        let err_msg = open_res.err().unwrap().to_string();
+        assert!(
+            err_msg.contains("Ungültige Slot-Anzahl"),
+            "Fehlermeldung: {err_msg}"
+        );
+        let _ = std::fs::remove_file(&db_path);
+    }
+}
+
+#[test]
+fn test_reject_duplicate_and_invalid_slot_ids() {
+    let temp_dir = std::env::temp_dir();
+    let salt = generate_salt();
+    let kdf_params = KdfParams {
+        memory_cost: MIN_MEMORY_COST_KIB,
+        time_cost: MIN_TIME_COST,
+        parallelism: 1,
+    };
+    let kek = derive_kek("TestPassword2026!", &salt, &kdf_params).unwrap();
+    let dek = generate_dek();
+    let (wrapped_dek, nonce, tag) = wrap_dek(&kek, &dek).unwrap();
+    let params_json = serde_json::to_string(&kdf_params).unwrap();
+
+    // 1. Fall: Doppelte Slot-ID (zwei Slots mit slot_id = 0)
+    {
+        let db_path = temp_dir.join(format!("test_dup_slot_0_{}.sanctum", std::process::id()));
+        let _ = std::fs::remove_file(&db_path);
+        {
+            let conn = rusqlite::Connection::open(&db_path).unwrap();
+            conn.execute(
+                "CREATE TABLE meta (
+                    slot_id INTEGER, magic BLOB NOT NULL, version INTEGER NOT NULL,
+                    kdf_salt BLOB NOT NULL, kdf_params TEXT NOT NULL, wrapped_dek BLOB NOT NULL,
+                    header_nonce BLOB NOT NULL, header_tag BLOB NOT NULL
+                );",
+                [],
+            )
+            .unwrap();
+            conn.execute(
+                "INSERT INTO meta VALUES (0, ?1, 2, ?2, ?3, ?4, ?5, ?6)",
+                rusqlite::params![
+                    b"SANCTUM\0",
+                    &salt[..],
+                    &params_json,
+                    &wrapped_dek[..],
+                    &nonce[..],
+                    &tag[..]
+                ],
+            )
+            .unwrap();
+            conn.execute(
+                "INSERT INTO meta VALUES (0, ?1, 2, ?2, ?3, ?4, ?5, ?6)",
+                rusqlite::params![
+                    b"SANCTUM\0",
+                    &salt[..],
+                    &params_json,
+                    &wrapped_dek[..],
+                    &nonce[..],
+                    &tag[..]
+                ],
+            )
+            .unwrap();
+        }
+        let db = Database::open(&db_path).unwrap();
+        let res = db.read_slots();
+        assert!(res.is_err(), "Doppelte Slot-ID 0 muss abgewiesen werden");
+        let err_msg = res.err().unwrap().to_string();
+        assert!(
+            err_msg.contains("Doppelte Slot-ID 0"),
+            "Fehlermeldung: {err_msg}"
+        );
+        let _ = std::fs::remove_file(&db_path);
+    }
+
+    // 2. Fall: Ungültige Slot-ID (z. B. slot_id = 5 statt 0 oder 1)
+    {
+        let db_path = temp_dir.join(format!(
+            "test_invalid_slot_id_{}.sanctum",
+            std::process::id()
+        ));
+        let _ = std::fs::remove_file(&db_path);
+        {
+            let conn = rusqlite::Connection::open(&db_path).unwrap();
+            conn.execute(
+                "CREATE TABLE meta (
+                    slot_id INTEGER, magic BLOB NOT NULL, version INTEGER NOT NULL,
+                    kdf_salt BLOB NOT NULL, kdf_params TEXT NOT NULL, wrapped_dek BLOB NOT NULL,
+                    header_nonce BLOB NOT NULL, header_tag BLOB NOT NULL
+                );",
+                [],
+            )
+            .unwrap();
+            conn.execute(
+                "INSERT INTO meta VALUES (5, ?1, 2, ?2, ?3, ?4, ?5, ?6)",
+                rusqlite::params![
+                    b"SANCTUM\0",
+                    &salt[..],
+                    &params_json,
+                    &wrapped_dek[..],
+                    &nonce[..],
+                    &tag[..]
+                ],
+            )
+            .unwrap();
+        }
+        let db = Database::open(&db_path).unwrap();
+        let res = db.read_slots();
+        assert!(res.is_err(), "Ungültige Slot-ID 5 muss abgewiesen werden");
+        let err_msg = res.err().unwrap().to_string();
+        assert!(
+            err_msg.contains("Ungültige Slot-ID 5"),
+            "Fehlermeldung: {err_msg}"
+        );
+        let _ = std::fs::remove_file(&db_path);
+    }
+
+    // 3. Fall: Fehlender Slot 0 (nur Slot 1 vorhanden)
+    {
+        let db_path = temp_dir.join(format!(
+            "test_missing_slot_0_{}.sanctum",
+            std::process::id()
+        ));
+        let _ = std::fs::remove_file(&db_path);
+        {
+            let conn = rusqlite::Connection::open(&db_path).unwrap();
+            conn.execute(
+                "CREATE TABLE meta (
+                    slot_id INTEGER, magic BLOB NOT NULL, version INTEGER NOT NULL,
+                    kdf_salt BLOB NOT NULL, kdf_params TEXT NOT NULL, wrapped_dek BLOB NOT NULL,
+                    header_nonce BLOB NOT NULL, header_tag BLOB NOT NULL
+                );",
+                [],
+            )
+            .unwrap();
+            conn.execute(
+                "INSERT INTO meta VALUES (1, ?1, 2, ?2, ?3, ?4, ?5, ?6)",
+                rusqlite::params![
+                    b"SANCTUM\0",
+                    &salt[..],
+                    &params_json,
+                    &wrapped_dek[..],
+                    &nonce[..],
+                    &tag[..]
+                ],
+            )
+            .unwrap();
+        }
+        let db = Database::open(&db_path).unwrap();
+        let res = db.read_slots();
+        assert!(res.is_err(), "Fehlender Slot 0 muss abgewiesen werden");
+        let err_msg = res.err().unwrap().to_string();
+        assert!(
+            err_msg.contains("Slot 0 (Standard/Decoy Vault) fehlt"),
+            "Fehlermeldung: {err_msg}"
+        );
+        let _ = std::fs::remove_file(&db_path);
+    }
+}
+
+#[test]
+fn test_container_meta_authenticate_defense_in_depth() {
+    use sanctum::storage::{ContainerMeta, SlotMeta};
+
+    let salt = generate_salt();
+    let kdf_params = KdfParams {
+        memory_cost: MIN_MEMORY_COST_KIB,
+        time_cost: MIN_TIME_COST,
+        parallelism: 1,
+    };
+    let kek = derive_kek("TestPassword2026!", &salt, &kdf_params).unwrap();
+    let dek = generate_dek();
+    let (wrapped_dek, nonce, tag) = wrap_dek(&kek, &dek).unwrap();
+
+    let valid_slot_0 = SlotMeta {
+        slot_id: 0,
+        version: 2,
+        kdf_salt: salt,
+        kdf_params: kdf_params.clone(),
+        wrapped_dek: wrapped_dek.clone(),
+        header_nonce: nonce,
+        header_tag: tag,
+    };
+
+    let valid_slot_1 = SlotMeta {
+        slot_id: 1,
+        version: 2,
+        kdf_salt: salt,
+        kdf_params: kdf_params.clone(),
+        wrapped_dek: wrapped_dek.clone(),
+        header_nonce: nonce,
+        header_tag: tag,
+    };
+
+    // A. Leere Slots -> sofort None
+    let meta_empty = ContainerMeta {
+        version: 2,
+        kdf_salt: salt,
+        kdf_params: kdf_params.clone(),
+        wrapped_dek: wrapped_dek.clone(),
+        header_nonce: nonce,
+        header_tag: tag,
+        slots: vec![],
+    };
+    assert!(meta_empty.authenticate("TestPassword2026!").is_none());
+
+    // B. Mehr als 2 Slots -> sofort None (keine KDF-Berechnung!)
+    let meta_3_slots = ContainerMeta {
+        version: 2,
+        kdf_salt: salt,
+        kdf_params: kdf_params.clone(),
+        wrapped_dek: wrapped_dek.clone(),
+        header_nonce: nonce,
+        header_tag: tag,
+        slots: vec![
+            valid_slot_0.clone(),
+            valid_slot_1.clone(),
+            valid_slot_0.clone(),
+        ],
+    };
+    assert!(meta_3_slots.authenticate("TestPassword2026!").is_none());
+
+    // C. Fehlender Slot 0 (nur Slot 1) -> sofort None
+    let meta_no_slot0 = ContainerMeta {
+        version: 2,
+        kdf_salt: salt,
+        kdf_params: kdf_params.clone(),
+        wrapped_dek: wrapped_dek.clone(),
+        header_nonce: nonce,
+        header_tag: tag,
+        slots: vec![valid_slot_1.clone()],
+    };
+    assert!(meta_no_slot0.authenticate("TestPassword2026!").is_none());
+
+    // D. Ungültige Slot-ID (> 1) -> sofort None
+    let mut invalid_slot = valid_slot_0.clone();
+    invalid_slot.slot_id = 99;
+    let meta_invalid_id = ContainerMeta {
+        version: 2,
+        kdf_salt: salt,
+        kdf_params: kdf_params.clone(),
+        wrapped_dek: wrapped_dek.clone(),
+        header_nonce: nonce,
+        header_tag: tag,
+        slots: vec![valid_slot_0.clone(), invalid_slot],
+    };
+    assert!(meta_invalid_id.authenticate("TestPassword2026!").is_none());
+
+    // E. Korrekter 1-Slot Container -> Erfolgreiche Authentifizierung
+    let meta_valid_1 = ContainerMeta {
+        version: 2,
+        kdf_salt: salt,
+        kdf_params: kdf_params.clone(),
+        wrapped_dek: wrapped_dek.clone(),
+        header_nonce: nonce,
+        header_tag: tag,
+        slots: vec![valid_slot_0.clone()],
+    };
+    assert!(meta_valid_1.authenticate("TestPassword2026!").is_some());
+}
+
+#[test]
+fn test_k01_metadata_tampering_detected_by_verify() {
+    let temp_dir = std::env::temp_dir();
+    let db_path: PathBuf = temp_dir.join(format!("test_k01_meta_{}.sanctum", std::process::id()));
+    if db_path.exists() {
+        let _ = std::fs::remove_file(&db_path);
+    }
+
+    let password = "SecretMasterPassword2026!";
+    let kdf_params = KdfParams {
+        memory_cost: MIN_MEMORY_COST_KIB,
+        time_cost: MIN_TIME_COST,
+        parallelism: 1,
+    };
+    let salt = generate_salt();
+    let kek = derive_kek(password, &salt, &kdf_params).unwrap();
+    let dek = generate_dek();
+    let (wrapped_dek, nonce, tag) = wrap_slot0_payload(&kek, &dek, 0).unwrap();
+
+    let db = Database::open(&db_path).unwrap();
+    db.set_active_dek(dek.clone());
+    db.init_schema_with_carrier(&salt, &kdf_params, &wrapped_dek, &nonce, &tag, None)
+        .unwrap();
+
+    // Knoten anlegen
+    let node = db.create_node(1, "secret_financials.xlsx", false).unwrap();
+    db.update_node_size_and_time(node.id, 50000, 1000).unwrap();
+    db.checkpoint().unwrap();
+
+    // 1. Initialer Zustand: Verifikation muss erfolgreich sein
+    let report = verify_container(&db_path, Some(&dek), true).unwrap();
+    assert!(
+        report.is_healthy(),
+        "Initialer V3-Container muss gesund sein, aber Fehler: {:?}",
+        report.errors
+    );
+
+    // 2. Angreifer manipuliert Dateigröße direkt in SQLite (ohne MAC aktualisieren zu können)
+    {
+        let conn = rusqlite::Connection::open(&db_path).unwrap();
+        conn.execute(
+            "UPDATE nodes SET size = 999999 WHERE name = 'secret_financials.xlsx';",
+            [],
+        )
+        .unwrap();
+    }
+
+    // Verifikation MUSS fehlschlagen und den K-01 Metadatenfehler melden!
+    let tampered_report = verify_container(&db_path, Some(&dek), true).unwrap();
+    assert!(
+        !tampered_report.is_healthy(),
+        "Container mit manipulierter Knotengröße darf nicht als gesund eingestuft werden!"
+    );
+    assert!(
+        tampered_report
+            .errors
+            .iter()
+            .any(|e| e.contains("K-01") || e.contains("Metadaten-MAC")),
+        "Fehlermeldung zu Metadaten-MAC erwartet, erhalten: {:?}",
+        tampered_report.errors
+    );
+
+    // 3. Angreifer manipuliert Dateinamen direkt in SQLite
+    {
+        let conn = rusqlite::Connection::open(&db_path).unwrap();
+        conn.execute(
+            "UPDATE nodes SET name = 'backdoor.exe' WHERE id = ?1;",
+            [node.id],
+        )
+        .unwrap();
+    }
+
+    let tampered_name_report = verify_container(&db_path, Some(&dek), true).unwrap();
+    assert!(
+        !tampered_name_report.is_healthy(),
+        "Container mit manipuliertem Knotennamen darf nicht als gesund eingestuft werden!"
+    );
+    assert!(
+        tampered_name_report
+            .errors
+            .iter()
+            .any(|e| e.contains("K-01") || e.contains("Metadaten-MAC")),
+        "Fehlermeldung zu Metadaten-MAC erwartet, erhalten: {:?}",
+        tampered_name_report.errors
+    );
+
+    let _ = std::fs::remove_file(&db_path);
+}
+
+#[test]
+fn test_k01_upgrade_format_v2_to_v3() {
+    let temp_dir = std::env::temp_dir();
+    let db_path: PathBuf =
+        temp_dir.join(format!("test_k01_upgrade_{}.sanctum", std::process::id()));
+    if db_path.exists() {
+        let _ = std::fs::remove_file(&db_path);
+    }
+
+    let password = "UpgradeMasterPassword2026!";
+    let kdf_params = KdfParams {
+        memory_cost: MIN_MEMORY_COST_KIB,
+        time_cost: MIN_TIME_COST,
+        parallelism: 1,
+    };
+    let salt = generate_salt();
+    let kek = derive_kek(password, &salt, &kdf_params).unwrap();
+    let dek = generate_dek();
+    let (wrapped_dek, nonce, tag) = wrap_slot0_payload(&kek, &dek, 0).unwrap();
+
+    // Erzeuge bewusst einen V2-Container ohne metadata_mac
+    {
+        let conn = rusqlite::Connection::open(&db_path).unwrap();
+        conn.execute_batch(
+            "CREATE TABLE meta (
+                slot_id INTEGER NOT NULL PRIMARY KEY,
+                magic BLOB NOT NULL,
+                version INTEGER NOT NULL,
+                kdf_salt BLOB NOT NULL,
+                kdf_params TEXT NOT NULL,
+                wrapped_dek BLOB NOT NULL,
+                header_nonce BLOB NOT NULL,
+                header_tag BLOB NOT NULL
+            );
+            CREATE TABLE nodes (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                parent_id INTEGER,
+                name TEXT NOT NULL,
+                is_dir INTEGER NOT NULL,
+                size INTEGER NOT NULL DEFAULT 0,
+                created_at INTEGER NOT NULL,
+                modified_at INTEGER NOT NULL,
+                is_carrier INTEGER NOT NULL DEFAULT 0
+            );
+            CREATE TABLE chunks (
+                node_id INTEGER NOT NULL,
+                chunk_index INTEGER NOT NULL,
+                nonce BLOB NOT NULL,
+                tag BLOB NOT NULL,
+                ciphertext BLOB NOT NULL,
+                PRIMARY KEY (node_id, chunk_index)
+            );",
+        )
+        .unwrap();
+
+        let params_json = serde_json::to_string(&kdf_params).unwrap();
+        conn.execute(
+            "INSERT INTO meta (slot_id, magic, version, kdf_salt, kdf_params, wrapped_dek, header_nonce, header_tag)
+             VALUES (0, ?1, 2, ?2, ?3, ?4, ?5, ?6)",
+            rusqlite::params![
+                sanctum::crypto::MAGIC_BYTES.as_slice(),
+                salt.as_slice(),
+                params_json,
+                wrapped_dek,
+                nonce.as_slice(),
+                tag.as_slice(),
+            ],
+        )
+        .unwrap();
+
+        conn.execute(
+            "INSERT INTO nodes (id, parent_id, name, is_dir, size, created_at, modified_at)
+             VALUES (1, NULL, '', 1, 0, 100, 100), (2, NULL, '', 1, 0, 100, 100);",
+            [],
+        )
+        .unwrap();
+    }
+
+    let db = Database::open(&db_path).unwrap();
+    let meta_before = db.read_meta().unwrap();
+    assert_eq!(meta_before.version, 2);
+
+    // Upgrade auf Format V3 durchführen
+    db.upgrade_to_v3(&dek).unwrap();
+    db.checkpoint().unwrap();
+
+    let meta_after = db.read_meta().unwrap();
+    assert_eq!(meta_after.version, 3);
+
+    // V3-Container muss nach dem Upgrade integer und gesund sein
+    let report = verify_container(&db_path, Some(&dek), true).unwrap();
+    assert!(
+        report.is_healthy(),
+        "Container nach upgrade_to_v3 muss gesund sein: {:?}",
+        report.errors
+    );
+
+    let _ = std::fs::remove_file(&db_path);
+}
+
+#[tokio::test]
+async fn test_k02_chunk_replay_detected_by_vfs_and_crypto() {
+    let temp_dir = std::env::temp_dir();
+    let db_path = temp_dir.join(format!(
+        "k02_replay_test_{}.sanctum",
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_nanos()
+    ));
+
+    let password = "TestPasswordK02!";
+    let salt = generate_salt();
+    let kdf_params = KdfParams {
+        memory_cost: MIN_MEMORY_COST_KIB,
+        time_cost: MIN_TIME_COST,
+        parallelism: 1,
+    };
+    let kek = derive_kek(password, &salt, &kdf_params).unwrap();
+    let dek = generate_dek();
+    let (wrapped_dek, nonce, tag) = wrap_dek(&kek, &dek).unwrap();
+
+    let db = Database::open(&db_path).unwrap();
+    db.set_active_dek(dek.clone());
+    db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag)
+        .unwrap();
+
+    // 1. Datei im Format V3 anlegen
+    let file = db.create_node(1, "replay_target.txt", false).unwrap();
+    let initial_data = b"State 1: Initial secret content in chunk 0.";
+    let gen1 = db.next_chunk_generation(file.id, 0).unwrap();
+    let (ct1, nonce1, tag1) = encrypt_chunk(
+        &dek,
+        file.id,
+        0,
+        initial_data,
+        sanctum::crypto::FORMAT_VERSION_V3,
+        gen1,
+    )
+    .unwrap();
+    db.write_chunk_and_update_size(
+        file.id,
+        0,
+        gen1,
+        &nonce1,
+        &tag1,
+        &ct1,
+        initial_data.len() as u64,
+        1000,
+    )
+    .unwrap();
+    db.checkpoint().unwrap();
+
+    // Ciphertext-Zeile von Zustand 1 sichern (Nonce, Tag, Ciphertext)
+    let saved_chunk1 = db.read_chunk(file.id, 0).unwrap().unwrap();
+    assert_eq!(saved_chunk1.generation, gen1);
+
+    // 2. Chunk mit neuem Inhalt überschreiben (Zustand 2)
+    let updated_data = b"State 2: Updated overwritten content in chunk 0.";
+    let gen2 = db.next_chunk_generation(file.id, 0).unwrap();
+    assert!(gen2 > gen1, "Generation muss monoton steigen");
+    let (ct2, nonce2, tag2) = encrypt_chunk(
+        &dek,
+        file.id,
+        0,
+        updated_data,
+        sanctum::crypto::FORMAT_VERSION_V3,
+        gen2,
+    )
+    .unwrap();
+    db.write_chunk_and_update_size(
+        file.id,
+        0,
+        gen2,
+        &nonce2,
+        &tag2,
+        &ct2,
+        updated_data.len() as u64,
+        2000,
+    )
+    .unwrap();
+    db.checkpoint().unwrap();
+
+    let current_chunk = db.read_chunk(file.id, 0).unwrap().unwrap();
+    assert_eq!(current_chunk.generation, gen2);
+
+    // 3. Replay-Angriff: Angreifer spielt alte Ciphertext-Zeile von Zustand 1 zurück in die SQLite-Tabelle
+    {
+        let conn = rusqlite::Connection::open(&db_path).unwrap();
+        conn.execute(
+            "UPDATE chunks SET nonce = ?1, tag = ?2, ciphertext = ?3 WHERE node_id = ?4 AND chunk_index = 0",
+            rusqlite::params![
+                saved_chunk1.nonce.as_slice(),
+                saved_chunk1.tag.as_slice(),
+                saved_chunk1.ciphertext,
+                file.id,
+            ],
+        )
+        .unwrap();
+    }
+
+    // Entschlüsselungsversuch muss fehlschlagen (AEAD Auth-Fehler wegen AAD-Generationsabweichung)
+    let replayed_chunk = db.read_chunk(file.id, 0).unwrap().unwrap();
+    let decrypt_res = decrypt_chunk(
+        &dek,
+        file.id,
+        0,
+        &replayed_chunk.ciphertext,
+        &replayed_chunk.nonce,
+        &replayed_chunk.tag,
+        sanctum::crypto::FORMAT_VERSION_V3,
+        replayed_chunk.generation,
+    );
+    assert!(
+        decrypt_res.is_err(),
+        "K-02: Replay von altem Ciphertext in aktuellem Chunk-Slot muss durch AEAD AAD-Mismatch abgewiesen werden!"
+    );
+
+    // Verify muss Replay/Manipulierte Chunks erkennen
+    let verify_res = verify_container(&db_path, Some(&dek), true).unwrap();
+    assert!(
+        !verify_res.is_healthy() || verify_res.corrupted_chunks > 0,
+        "Verify muss Replay/Manipulierte Chunks erkennen"
+    );
+
+    let _ = std::fs::remove_file(&db_path);
+}

tests/upgrade_security_test.rs

@@ -0,0 +1,193 @@
+use sanctum::upgrade::{
+    run_upgrade, validate_trusted_comment_version, verify_minisign_signature,
+    verify_release_manifest_signature, UpgradeOptions, SANCTUM_RELEASE_PUBKEY,
+    SANCTUM_RELEASE_PUBKEY_BACKUP,
+};
+
+#[test]
+fn test_minisign_signature_valid() {
+    let payload = b"Hello Sanctum Release 0.7.0 Security Testing\n";
+    let sig_text = "\
+untrusted comment: signature from minisign secret key\n\
+RUSsVphPgr8155LCucDq8RzDmWMzWElzhBmHrS5p+qJlOCGU4AQpn2F28MVPFrnoGPYEHx7/6TlKg2b45DlYuBQ0+ASeLIzMLwc=\n\
+trusted comment: timestamp:1789750897\tfile:test_payload.txt\thashed\n\
+0l7KsNJkDTo2uOKL8UAiaJOWuhwhGTVZ5fn0JFMdxXE9riYixQO9YnBpSVqz8iCDhWrz8hJBnmUrIWnaRaXVCA==\n";
+
+    let res = verify_minisign_signature(payload, sig_text, SANCTUM_RELEASE_PUBKEY);
+    assert!(
+        res.is_ok(),
+        "Gültige Minisign-Signatur muss erfolgreich verifiziert werden: {:?}",
+        res.err()
+    );
+}
+
+#[test]
+fn test_minisign_signature_tampered_payload() {
+    let tampered_payload = b"Hello Sanctum Release 0.7.0 Tampered Payload!\n";
+    let sig_text = "\
+untrusted comment: signature from minisign secret key\n\
+RUSsVphPgr8155LCucDq8RzDmWMzWElzhBmHrS5p+qJlOCGU4AQpn2F28MVPFrnoGPYEHx7/6TlKg2b45DlYuBQ0+ASeLIzMLwc=\n\
+trusted comment: timestamp:1789750897\tfile:test_payload.txt\thashed\n\
+0l7KsNJkDTo2uOKL8UAiaJOWuhwhGTVZ5fn0JFMdxXE9riYixQO9YnBpSVqz8iCDhWrz8hJBnmUrIWnaRaXVCA==\n";
+
+    let res = verify_minisign_signature(tampered_payload, sig_text, SANCTUM_RELEASE_PUBKEY);
+    assert!(
+        res.is_err(),
+        "Manipulierte Binärdaten müssen die Minisign-Prüfung verfehlen"
+    );
+    assert!(res.unwrap_err().to_string().contains("FEHLGESCHLAGEN"));
+}
+
+#[test]
+fn test_minisign_signature_wrong_key() {
+    let payload = b"Hello Sanctum Release 0.7.0 Security Testing\n";
+    let sig_text = "\
+untrusted comment: signature from minisign secret key\n\
+RUSsVphPgr8155LCucDq8RzDmWMzWElzhBmHrS5p+qJlOCGU4AQpn2F28MVPFrnoGPYEHx7/6TlKg2b45DlYuBQ0+ASeLIzMLwc=\n\
+trusted comment: timestamp:1789750897\tfile:test_payload.txt\thashed\n\
+0l7KsNJkDTo2uOKL8UAiaJOWuhwhGTVZ5fn0JFMdxXE9riYixQO9YnBpSVqz8iCDhWrz8hJBnmUrIWnaRaXVCA==\n";
+
+    // Ein anderer, unautorisierter Public Key
+    let other_key = "RWSb0a70vF1X8qIjc7xi28Gmw+cIWbMipOy4L6ToJEUPkWDw3c0qIjc7";
+    let res = verify_minisign_signature(payload, sig_text, other_key);
+    assert!(
+        res.is_err(),
+        "Signaturprüfung mit fremdem Schlüssel muss fehlschlagen"
+    );
+}
+
+#[test]
+fn test_upgrade_blocks_unofficial_url_without_insecure_flag() {
+    let options = UpgradeOptions {
+        check_only: true,
+        yes: false,
+        force: false,
+        base_url: "https://evil-attacker.org/sanctum".into(),
+        insecure_url: false,
+    };
+
+    let res = run_upgrade(&options);
+    assert!(
+        res.is_err(),
+        "Inoffizielle Server-URL ohne --insecure-url muss blockiert werden"
+    );
+    let err_msg = res.unwrap_err().to_string();
+    assert!(
+        err_msg.contains("Sicherheitsverstoß") || err_msg.contains("nicht vertrauenswürdig"),
+        "Fehler muss Sicherheitsverstoß anzeigen: {err_msg}"
+    );
+}
+
+#[test]
+fn test_u01_reject_legacy_unhashed_signature() {
+    let payload = b"Hello Sanctum Release 0.7.0 Security Testing\n";
+    let sig_text = "\
+untrusted comment: signature from minisign secret key\n\
+RUSsVphPgr8155LCucDq8RzDmWMzWElzhBmHrS5p+qJlOCGU4AQpn2F28MVPFrnoGPYEHx7/6TlKg2b45DlYuBQ0+ASeLIzMLwc=\n\
+trusted comment: timestamp:1789750897\tfile:test_payload.txt\thashed\n\
+0l7KsNJkDTo2uOKL8UAiaJOWuhwhGTVZ5fn0JFMdxXE9riYixQO9YnBpSVqz8iCDhWrz8hJBnmUrIWnaRaXVCA==\n";
+
+    // Gültige pre-hashed Signatur muss weiterhin erfolgreich geprüft werden
+    assert!(verify_minisign_signature(payload, sig_text, SANCTUM_RELEASE_PUBKEY).is_ok());
+
+    // Modifiziere die Signatur, um eine Legacy-Signatur (Ed statt ED) zu simulieren
+    // In Base64 entspricht 'ED' (0x45, 0x44) dem Präfix 'RU'
+    // 'Ed' (0x45, 0x64) entspricht in Base64 dem Präfix 'RW'
+    let lines: Vec<&str> = sig_text.lines().collect();
+    let mut sig_line = lines[1].to_string();
+    assert!(sig_line.starts_with("RU"));
+    sig_line.replace_range(0..2, "RW");
+
+    let legacy_sig_text = format!("{}\n{}\n{}\n{}\n", lines[0], sig_line, lines[2], lines[3]);
+
+    let res = verify_minisign_signature(payload, &legacy_sig_text, SANCTUM_RELEASE_PUBKEY);
+    assert!(
+        res.is_err(),
+        "U-01: Legacy-Signaturen (ohne Pre-Hashing) müssen strikt abgewiesen werden"
+    );
+}
+
+#[test]
+fn test_u02_validate_trusted_comment_version_matching() {
+    // Standard Minisign format with -t "version:0.8.0"
+    let tc1 = "timestamp:1789750897\tversion:0.8.0\tfile:SHA256SUMS.txt\thashed";
+    assert!(validate_trusted_comment_version(tc1, "0.8.0").is_ok());
+    assert!(validate_trusted_comment_version(tc1, "v0.8.0").is_ok());
+
+    // Alternative tags like tag:v0.8.0 or release:0.8.0
+    let tc2 = "release:0.8.0";
+    assert!(validate_trusted_comment_version(tc2, "0.8.0").is_ok());
+    let tc3 = "tag:v0.8.0";
+    assert!(validate_trusted_comment_version(tc3, "0.8.0").is_ok());
+}
+
+#[test]
+fn test_u02_reject_mismatched_release_tag_replay() {
+    // An attacker replays a valid signature from v0.7.0 for an update claiming to be v0.8.0
+    let tc_old = "timestamp:1789750897\tversion:0.7.0\tfile:SHA256SUMS.txt\thashed";
+    let res = validate_trusted_comment_version(tc_old, "v0.8.0");
+    assert!(
+        res.is_err(),
+        "U-02: Ältere oder abweichende Version im Trusted Comment muss abgewiesen werden"
+    );
+    let err_msg = res.unwrap_err().to_string();
+    assert!(
+        err_msg.contains("U-02") && err_msg.contains("Replay-Angriff"),
+        "Fehlermeldung muss auf Replay-Angriff und U-02 hinweisen: {err_msg}"
+    );
+
+    // Empty or completely missing version token
+    let tc_no_ver = "timestamp:1789750897\tfile:SHA256SUMS.txt\thashed";
+    let res2 = validate_trusted_comment_version(tc_no_ver, "0.8.0");
+    assert!(res2.is_err());
+}
+
+#[test]
+fn test_u03_verify_signature_with_backup_key_fallback() {
+    let payload = b"Hello Sanctum Release 0.8.0 Backup Key Testing\n";
+    let backup_sig = "\
+untrusted comment: signature from minisign secret key\n\
+RUQEeUSLlX2p4HrXDO2TYykyNK0C41Vdrq6MIts14mQgNDClGC2RkBV3jHRbP7IclWv+h/IuzvyYi9yz8/RqfhpDVwhqtvC02gk=\n\
+trusted comment: version:0.8.0\n\
+zjZAS4uy1PH+0S9KQ0EU435lpBczU3lULyS5SkWf093iCEBc1ULiscwE5gWkEkex3ecPdRugopT+fKaZBQQnBg==\n";
+
+    // 1. Direct verification against primary key MUST fail (key rotation scenario)
+    let prim_res = verify_minisign_signature(payload, backup_sig, SANCTUM_RELEASE_PUBKEY);
+    assert!(
+        prim_res.is_err(),
+        "Backup-Signatur darf nicht gegen den Primärschlüssel verifizieren"
+    );
+
+    // 2. Direct verification against backup key MUST succeed
+    let back_res = verify_minisign_signature(payload, backup_sig, SANCTUM_RELEASE_PUBKEY_BACKUP);
+    assert!(
+        back_res.is_ok(),
+        "Backup-Signatur muss gegen SANCTUM_RELEASE_PUBKEY_BACKUP gültig sein: {:?}",
+        back_res.err()
+    );
+
+    // 3. Fallback verification via verify_release_manifest_signature MUST succeed transparently
+    let fallback_res = verify_release_manifest_signature(payload, backup_sig);
+    assert!(
+        fallback_res.is_ok(),
+        "verify_release_manifest_signature muss via Backup-Schlüssel erfolgreich sein"
+    );
+    assert_eq!(fallback_res.unwrap(), "version:0.8.0");
+}
+
+#[test]
+fn test_u03_verify_signature_rejects_untrusted_third_party_key() {
+    let fake_sig = "\
+untrusted comment: signature from minisign secret key\n\
+RUQEeUSLlX2p4HrXDO2TYykyNK0C41Vdrq6MIts14mQgNDClGC2RkBV3jHRbP7IclWv+h/IuzvyYi9yz8/RqfhpDVwhqtvC02gk=\n\
+trusted comment: version:0.8.0\n\
+zjZAS4uy1PH+0S9KQ0EU435lpBczU3lULyS5SkWf093iCEBc1ULiscwE5gWkEkex3ecPdRugopT+fKaZBQQnBg==\n";
+
+    // Tampered payload with neither primary nor backup key matching
+    let tampered = b"Tampered data not signed by either key";
+    let res = verify_release_manifest_signature(tampered, fake_sig);
+    assert!(
+        res.is_err(),
+        "Weder Primär- noch Backup-Schlüssel dürfen manipulierte Nutzdaten akzeptieren"
+    );
+}

tests/upgrade_test.rs

@@ -0,0 +1,161 @@
+use std::fs::File;
+use std::io::Write;
+use std::path::Path;
+
+use sanctum::upgrade::{
+    detect_package_manager_from_path, is_newer_version, parse_checksum_for_asset,
+    parse_clean_version, GiteaRelease, PackageManager,
+};
+use sha2::{Digest, Sha256};
+
+#[test]
+fn test_parse_checksum_for_asset() {
+    let sample_checksums = r#"
+# Offizielle SHA-256 Prüfsummen für Sanctum Release
+2f069a8cc41f9fa6a2559e2952e5669523c21c175df15f6d80f0473bbe2fa60e  sanctum-v0.5.0-windows-x86_64.zip
+e0c64ecc12c7f49180487b638f1152eccaf5c90270a93880db52ca56eb1c1d63  sanctum.exe
+557dd84f339336899fdd67e69d894dcd6e32f3e0bff2ae8a3057df596eddf4b4  sanctum-v0.5.0-linux-x86_64.tar.gz
+2816f00cb15825d92f35f93fd667ed04d36501763a70b9399dd0ab9355c9448d  *sanctum
+"#;
+
+    // Windows Binary
+    let win_hash = parse_checksum_for_asset(sample_checksums, "sanctum.exe");
+    assert_eq!(
+        win_hash.as_deref(),
+        Some("e0c64ecc12c7f49180487b638f1152eccaf5c90270a93880db52ca56eb1c1d63")
+    );
+
+    // Linux Binary (mit führendem Asterisk im Format)
+    let linux_hash = parse_checksum_for_asset(sample_checksums, "sanctum");
+    assert_eq!(
+        linux_hash.as_deref(),
+        Some("2816f00cb15825d92f35f93fd667ed04d36501763a70b9399dd0ab9355c9448d")
+    );
+
+    // Nicht existentes Asset
+    let non_existent = parse_checksum_for_asset(sample_checksums, "nonexistent.exe");
+    assert_eq!(non_existent, None);
+}
+
+#[test]
+fn test_semver_comparisons() {
+    // Normaler Versionssprung
+    assert!(is_newer_version("0.5.0", "0.6.0"));
+    assert!(is_newer_version("0.5.0", "v0.6.0"));
+    assert!(is_newer_version("v0.5.0", "V0.5.1"));
+    assert!(is_newer_version("0.5.0", "1.0.0"));
+
+    // Gleiche Version
+    assert!(!is_newer_version("0.6.0", "0.6.0"));
+    assert!(!is_newer_version("0.6.0", "v0.6.0"));
+    assert!(!is_newer_version("v0.6.0", "0.6.0"));
+
+    // Ältere Version
+    assert!(!is_newer_version("0.6.0", "0.5.0"));
+    assert!(!is_newer_version("0.6.0", "v0.4.1"));
+
+    // Parsing mit führenden 'v' / 'V'
+    let v1 = parse_clean_version("v0.6.0").expect("Parse v0.6.0");
+    let v2 = parse_clean_version("V1.2.3").expect("Parse V1.2.3");
+    assert_eq!(v1.major, 0);
+    assert_eq!(v1.minor, 6);
+    assert_eq!(v2.major, 1);
+    assert_eq!(v2.minor, 2);
+}
+
+#[test]
+fn test_package_manager_detection() {
+    // Scoop Pfade
+    let scoop_path = Path::new(r"C:\Users\harald\scoop\apps\sanctum\current\sanctum.exe");
+    assert_eq!(
+        detect_package_manager_from_path(scoop_path),
+        Some(PackageManager::Scoop)
+    );
+
+    let scoop_shim = Path::new(r"C:\Users\harald\scoop\shims\sanctum.exe");
+    assert_eq!(
+        detect_package_manager_from_path(scoop_shim),
+        Some(PackageManager::Scoop)
+    );
+
+    // Winget Pfade
+    let winget_path = Path::new(
+        r"C:\Users\harald\AppData\Local\Microsoft\WinGet\Packages\HaraldPansi.Sanctum_Microsoft.Winget.Source_8wekyb3d8bbwe\sanctum.exe",
+    );
+    assert_eq!(
+        detect_package_manager_from_path(winget_path),
+        Some(PackageManager::Winget)
+    );
+
+    // Standard Standalone Pfade (kein Paketmanager)
+    let standalone = Path::new(r"C:\Tools\sanctum\sanctum.exe");
+    assert_eq!(detect_package_manager_from_path(standalone), None);
+
+    let linux_usr = Path::new("/usr/local/bin/sanctum");
+    assert_eq!(detect_package_manager_from_path(linux_usr), None);
+}
+
+#[test]
+fn test_hash_integrity_calculation() {
+    let test_file = std::env::temp_dir().join(format!("sanctum_test_{}.bin", std::process::id()));
+
+    let payload = b"Sanctum Standalone Binary Payload for Integrity Testing";
+    {
+        let mut f = File::create(&test_file).expect("create file");
+        f.write_all(payload).expect("write");
+    }
+
+    let mut hasher = Sha256::new();
+    hasher.update(payload);
+    let expected = hex::encode(hasher.finalize());
+
+    // Datei erneut lesen und hashen
+    let mut reader = File::open(&test_file).expect("open");
+    let mut file_hasher = Sha256::new();
+    std::io::copy(&mut reader, &mut file_hasher).expect("copy");
+    let calculated = hex::encode(file_hasher.finalize());
+
+    assert_eq!(expected, calculated);
+    let _ = std::fs::remove_file(&test_file);
+}
+
+#[test]
+fn test_json_deserialization_of_gitea_release() {
+    let gitea_json = r##"{
+        "id": 27,
+        "tag_name": "v0.5.0",
+        "name": "Sanctum v0.5.0 (Windows x86_64)",
+        "body": "Release v0.5.0 - sanctum sync",
+        "html_url": "https://gitea.pansi.eu/harald/sanctum/releases/tag/v0.5.0",
+        "published_at": "2026-09-16T10:44:18+02:00",
+        "assets": [
+            {
+                "id": 38,
+                "name": "sanctum.exe",
+                "size": 5467136,
+                "browser_download_url": "https://gitea.pansi.eu/harald/sanctum/releases/download/v0.5.0/sanctum.exe"
+            },
+            {
+                "id": 40,
+                "name": "sanctum",
+                "size": 5033952,
+                "browser_download_url": "https://gitea.pansi.eu/harald/sanctum/releases/download/v0.5.0/sanctum"
+            },
+            {
+                "id": 41,
+                "name": "SHA256SUMS.txt",
+                "size": 563,
+                "browser_download_url": "https://gitea.pansi.eu/harald/sanctum/releases/download/v0.5.0/SHA256SUMS.txt"
+            }
+        ]
+    }"##;
+
+    let release: GiteaRelease =
+        serde_json::from_str(gitea_json).expect("Deserialisierung erfolgreich");
+    assert_eq!(release.id, 27);
+    assert_eq!(release.tag_name, "v0.5.0");
+    assert_eq!(release.assets.len(), 3);
+    assert_eq!(release.assets[0].name, "sanctum.exe");
+    assert_eq!(release.assets[1].name, "sanctum");
+    assert_eq!(release.assets[2].name, "SHA256SUMS.txt");
+}