Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 harald
|
efb28c1c45 | ||
|
harald
|
a252393f96 | ||
|
harald
|
3693e03494 | ||
|
harald
|
167e4b65fc | ||
|
harald
|
02f731f57d | ||
|
harald
|
728ac008ae | ||
|
harald
|
8ff426d1b0 | ||
|
harald
|
efddc2c477 | ||
|
harald
|
dd6b6ff94d | ||
|
harald
|
c21d63ad28 | ||
|
harald
|
c606fa8132 | ||
|
harald
|
8455dc02db |
@@ -5,6 +5,80 @@ 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.9.1] - 2026-09-20
|
||||
|
||||
### Sicherheits-Härtung, Pfadvalidierung & Migration-Dokumentation
|
||||
Dieses Release behebt die im Prüfbericht für v0.9.0 identifizierten vier Minor Issues bezüglich Metadaten-Authentifizierung beim Mounten, strikter Eingabevalidierung von Dateinamen im Carrier-Dateisystem, Dokumentation der Carrier-V1-nach-V2-Migration sowie Schutz vor Swap-Attacks bei der Dateinamen-Entschlüsselung.
|
||||
|
||||
#### Behobene Minor Issues
|
||||
- **K-01 Metadaten-MAC-Validierung beim Mount**:
|
||||
- `mount_container` validiert vor dem Start des WebDAV-Dienstes die kryptografische HMAC-SHA-256 Integrität aller Metadaten für Container ab Format V3.
|
||||
- Registrierung des aktiven DEK (`set_active_slot_and_dek`), sodass fortlaufende Dateioperationen den Metadaten-MAC synchron halten.
|
||||
- **Lückenlose Pfadvalidierung (`validate_node_name`)**:
|
||||
- Konsequente Prüfung aller Dateinamen im Carrier-Dateisystem (`CarrierFs::open`, `CarrierFs::create_dir`, `CarrierFs::rename`, `CarrierFs::copy`) und VFS (`SanctumFs::copy`).
|
||||
- Zuverlässige Abweisung von Windows-reservierten Gerätenamen (`CON`, `PRN`, `AUX`, `NUL`, `COM1-9`, `LPT1-9`), ungültigen Zeichen (`<>:"/\|?*`), Steuerzeichen und Pfad-Traversal.
|
||||
- **Sicherheitsdokumentation & Runtime-Warnung für `--legacy-names`**:
|
||||
- Deutliche Warnung im CLI-Hilfetext, auf `stderr` und im Logging vor den Risiken von Swap-Attacks bei deaktivierter AAD-Bindung.
|
||||
- Aufnahme einer Risikobewertung in `README.md` und `THREAT_MODEL.md` (Abschnitt 7).
|
||||
- **Migration-Leitfaden (V1 → V2)**:
|
||||
- Schritt-für-Schritt-Anleitung in `README.md` (Abschnitt 10) zur transparenten Aktualisierung bestehender V1-Container auf das Paged-Manifest-Format V2.
|
||||
|
||||
## [0.9.0] - 2026-09-20
|
||||
|
||||
### Paged Manifest für den Hidden Vault (Aufhebung der Kapazitätsgrenze)
|
||||
Dieses Release führt das **Carrier-Format V2** für den Hidden Vault ein. Es hebt die bisherige Kapazitätsgrenze von ca. 7.000 Dateien vollständig auf, führt eine skalierbare Paged-Manifest-Architektur ein und optimiert Performanz sowie Resilienz signifikant.
|
||||
|
||||
#### Formaterweiterung Carrier V2 (D-01 bis D-05)
|
||||
- **Carrier-Format V2 mit Paged Manifest**:
|
||||
- Trennung von Superblock und Inode-Tabellen: Block 0 und Block 1 enthalten nur noch den leichtgewichtigen `CarrierSuperblock` (unter Erhalt der C-02 Dual-Block Redundanz).
|
||||
- Inodes werden in separaten Inode-Pages (`CarrierInodePage`, Magic `SANCTPAG`, ~1 MB Payload je Block, ca. 4.500–7.000 Inodes pro Seite) aus dem normalen Blockpool verwaltet.
|
||||
- Dynamische Skalierung: Die Inode-Kapazität skaliert linear mit den verfügbaren Trägerblöcken bis zu 2^32 Blöcken.
|
||||
- **D-01: Paged Loading & Fail-Soft Resilienz**:
|
||||
- Erkennt automatisch V1- vs. V2-Superblöcke auf Block 0 und 1.
|
||||
- Resiliente Fehlerisolation: Beschädigte oder unlesbare Inode-Seiten führen nicht zum Mount-Abbruch. Fehlerhafte Seiten werden geloggt (`error!`) und übersprungen, während alle intakten Inodes gemountet werden.
|
||||
- Neuer Zähler `corrupted_pages` warnt den Benutzer beim Mounten über partielle Datenbeschädigungen.
|
||||
- **D-02: Sekundärindex für Kindknoten (`children_index`)**:
|
||||
- In-Memory Index `children_index: HashMap<i64, Vec<i64>>` ordnet Elternknoten-IDs ihren Kindern zu.
|
||||
- Beschleunigt Pfadauflösung (`resolve_path`) und Verzeichnislisting (`read_dir`) von O(N) Tabellenscans auf O(Geschwister).
|
||||
- Konsistente Nachführung bei `open`, `create_dir`, `remove_file`, `remove_dir`, `rename` und `copy`.
|
||||
- **D-03: Transparente V1 → V2 Migration**:
|
||||
- V1-Container werden vollkommen transparent eingelesen.
|
||||
- Beim ersten Speichervorgang (`save_manifest()`) wird geprüft, ob genügend freie Blöcke für die Seitenaufteilung vorhanden sind.
|
||||
- Reicht der Platz nicht aus, bricht der Vorgang sauber ab, ohne den Container zu beschädigen. Reicht der Platz, wird der Container nahtlos auf Format V2 migriert.
|
||||
- Eine ausführliche Schritt-für-Schritt-Anleitung zur Migration findet sich in der [README.md](README.md#10-migration-von-carrier-format-v1-auf-v2-hidden-vault).
|
||||
- **D-04 & D-05: Deterministische Seitenaufteilung & Blockfreigabe**:
|
||||
- Deterministische Sortierung der Inodes nach ID garantiert reproduzierbare Seitenbelegungen.
|
||||
- Dynamische Blockfreigabe: Verringert sich die Inode-Anzahl (z. B. durch Löschungen), werden überzählige Seitenblöcke mittels kryptografischem Zufallsrauschen geschreddert (`shred_carrier_block`) und an den Freispeicher zurückgegeben.
|
||||
- Dynamische Block-Warnung: Die statische 80%-Manifestgrenze aus C-04 wird durch eine Warnung bei absolutem Träger-Blockmangel (< 20 Blöcke oder < 5% Restkapazität) ersetzt.
|
||||
|
||||
## [0.8.1] - 2026-09-19
|
||||
|
||||
### Carrier-Manifest-Resilienz & Storage-Hygiene (Dritte Audit-Runde)
|
||||
Dieses Release behebt sechs Findings aus der dritten Audit-Runde in `carrier.rs` (steganografisches Dateisystem des Hidden Vault) und `storage.rs`, schließt alle verbleibenden Punkte und erreicht 39/39 (100%) behobene Audit-Findings.
|
||||
|
||||
#### Steganografischer Hidden Vault & Carrier-Dateisystem (C-02, C-03, C-04)
|
||||
- **C-02 (HOCH): Rollierendes Dual-Block-Manifest & Failover-Recovery**:
|
||||
- Beseitigung des Single Point of Failure: Das Dateisystem-Manifest wird nun abwechselnd auf Block 0 und Block 1 geschrieben (`manifest_generation: u64`).
|
||||
- Beim Mounten liest Sanctum beide Blöcke, wählt die neuere Generation und stellt den Tresor selbst bei Beschädigung (z. B. Bitrot) eines Blocks transparent wieder her.
|
||||
- Vollständige Abwärtskompatibilität: Block 1 wird für bestehende Container automatisch reserviert.
|
||||
- **C-03 (MITTEL): Entkopplung der Manifest-Neuverschlüsselung via Dirty-Tracking**:
|
||||
- Metadatenänderungen (`create_dir`, `create_file`, `remove_file`, `remove_dir`, `rename`, `copy`, `drop`) markieren das Manifest als `dirty`, anstatt jedes Mal synchron 1 MB per AES-256-GCM neu zu verschlüsseln.
|
||||
- Synchrone Sicherung erfolgt gebündelt bei Datei-`flush()`, unmount/drop oder nach 50 Operationen.
|
||||
- Gewährleistet massive Performancesteigerung bei Massenoperationen im Hidden Vault.
|
||||
- **C-04 (NIEDRIG): Kapazitätsgrenze dokumentiert & Warnung bei Füllstand**:
|
||||
- Dokumentation der Obergrenze (~7.000 Dateien/Verzeichnisse pro 1-MB-Manifest-Block) in `README.md` und `QUICKSTART.md`.
|
||||
- Automatische Warnung beim Mounten und Speichern, wenn das Manifest mehr als 80% Füllstand (~838 KB) erreicht.
|
||||
|
||||
#### Storage-Hygiene & Fehlerbehandlung (ST-01, ST-02, ST-03)
|
||||
- **ST-01 (MITTEL): Fail-Closed bei Entschlüsselungsfehlern von Knotennamen**:
|
||||
- Beseitigung des Hex-Ciphertext-Leaks (`unwrap_or(enc_name)`): Bei Entschlüsselungsfehlern (z. B. Bitrot oder unlesbare Knoten) werden betroffene Einträge in `list_children_in_vault`, `resolve_path_in_vault` und `get_node_by_id_in_vault` übersprungen und geloggt (`warn!`), anstatt rohe Hex-Strings auszuliefern.
|
||||
- **ST-02 (NIEDRIG): Fehleraggregation bei rekursivem Löschen**:
|
||||
- `delete_node` verschluckt Fehler bei Kindknoten nicht mehr (`let _ =`).
|
||||
- Fehler werden gesammelt, protokolliert (`error!`) und führen zum Abbruch mit detaillierter Zusammenfassung, wodurch verwaiste Knoten (Orphans) verhindert werden.
|
||||
- **ST-03 (NIEDRIG): Atomare SQLite-Transaktion für rekursives Löschen**:
|
||||
- Das gesamte rekursive Löschen eines Baumes (inklusive kryptografischem Chunk-Shredding) wird nun in einer einzigen atomaren SQLite-Transaktion ausgeführt.
|
||||
- Schlägt das Löschen eines Teilbaums fehl, wird ein automatischer Rollback ausgeführt; Teilbaumlöschungen und inkonsistente Zustände sind ausgeschlossen.
|
||||
|
||||
## [0.8.0] - 2026-09-19
|
||||
|
||||
### Security Audit Remediation & Format V3 Release
|
||||
|
||||
Generated
+1
-1
@@ -1457,7 +1457,7 @@ checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
|
||||
|
||||
[[package]]
|
||||
name = "sanctum"
|
||||
version = "0.8.0"
|
||||
version = "0.9.1"
|
||||
dependencies = [
|
||||
"aes-gcm",
|
||||
"anyhow",
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "sanctum"
|
||||
version = "0.8.0"
|
||||
version = "0.9.1"
|
||||
edition = "2021"
|
||||
authors = ["Harald Pansi <harald@pansi.eu>", "Sanctum Engineering Team"]
|
||||
description = "Verschlüsselter Ein-Datei-Container unter Windows im reinen Userland via WebDAV"
|
||||
|
||||
@@ -37,6 +37,8 @@ Beim Erstellen eines Tresors wählst du zwischen zwei Sicherheitsstufen:
|
||||
1. **Decoy-Passwort**: Öffnet den äußeren Safe (enthält eine scheinbare Backup-Datei `system_backup.dat`).
|
||||
2. **Hidden-Passwort**: Öffnet den geheimen Zweittresor (Second Safe).
|
||||
* *(Hinweis: Schützt vor Schulterblick im Alltag; keine forensische Abstreitbarkeit gegen behördliche Entropieanalyse).*
|
||||
* **Kapazität & Skalierung (Format V2)**: Dank Paged-Manifest-Architektur dynamisch skalierbar (~4.500–7.000 Dateien je 1-MB-Manifestseite, keine starre 7.000er-Grenze mehr). Sanctum warnt beim Mounten automatisch bei Blockknappheit (< 20 freie Blöcke oder < 5% Restkapazität).
|
||||
* **Migration von V1-Containern**: Bestehende V1-Hidden-Vaults werden transparent unterstützt und können auf Format V2 migriert werden. Siehe [Schritt-für-Schritt-Anleitung in der README](README.md#10-migration-von-carrier-format-v1-auf-v2-hidden-vault).
|
||||
* **Wichtig**: Notiere dir die ausgegebenen **24 Wörter des Notfallschlüssels (BIP-39)** auf der untenstehenden Notfallkarte!
|
||||
|
||||
---
|
||||
|
||||
@@ -37,8 +37,11 @@ Sanctum ist eine eigenständige, speichersichere und hochperformante CLI-Anwendu
|
||||
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.
|
||||
- **Dual-Vault (Multi-Slot & Carrier)**:
|
||||
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 (Legacy-Kompatibilität über `--legacy-names`).
|
||||
*Carrier-Format V2 mit Paged Manifest*: Das steganografische Dateisystem des Hidden Vaults nutzt eine skalierbare Paged-Manifest-Architektur. Blöcke 0 und 1 speichern den redundanten Superblock (C-02), während Inodes über dedizierte Inode-Pages (~1 MB Nutzdaten je Seite, ca. 4.500–7.000 Inodes pro Seite) dynamisch aus dem Blockpool verwaltet werden. Die Kapazität ist nicht mehr auf 7.000 Dateien limitiert, sondern skaliert dynamisch mit den verfügbaren Trägerblöcken. Robuste Fail-Soft-Resilienz (D-01) isoliert Seitenbeschädigungen, ein In-Memory Sekundärindex (D-02) beschleunigt Pfadoperationen auf O(Geschwister), und Sanctum warnt beim Einbinden automatisch bei Blockknappheit (< 20 freie Blöcke oder < 5% Restkapazität).
|
||||
- **Dateinamen-Verschlüsselung & Schutz vor Swap-Attacks**:
|
||||
Dateinamen werden mit frischen CSPRNG-Nonces und AES-256-GCM verschlüsselt in der Datenbank gespeichert, wobei die übergeordnete Verzeichnis-ID (`parent_id`) als Additional Authenticated Data (AAD) eingebunden ist. Dies verhindert, dass Angreifer verschlüsselte Dateinamen zwischen Verzeichnissen vertauschen können.
|
||||
> [!WARNING]
|
||||
> **Sicherheitshinweis zu `--legacy-names`**: Das globale Flag `--legacy-names` deaktiviert die Prüfung der AAD-Bindung bei der Entschlüsselung von Dateinamen. Verwenden Sie dieses Flag **ausschließlich zur einmaligen Datenrettung oder Migration** älterer Container (vor Version 0.8.0), da es das Schutzniveau gegen Manipulationen reduziert.
|
||||
- **Kryptografisches Chunk-Shredding (Logisches Löschen vs. Physikalische Bereinigung)**:
|
||||
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.
|
||||
@@ -243,6 +246,46 @@ sanctum.exe upgrade --force
|
||||
|
||||
---
|
||||
|
||||
### 10. Migration von Carrier-Format V1 auf V2 (Hidden Vault)
|
||||
|
||||
Mit Sanctum v0.9.0 wurde das **Carrier-Format V2** eingeführt, das die vorherige Begrenzung von ca. 7.000 Dateien im Hidden Vault aufhebt. Bestehende V1-Container werden transparent unterstützt und können wie folgt auf V2 aktualisiert werden:
|
||||
|
||||
1. **Sicherheits-Backup erstellen**:
|
||||
Erstellen Sie vor der Migration eine Sicherungskopie Ihres Containers:
|
||||
```powershell
|
||||
sanctum.exe backup --path "C:\Pfad\tresor.sanctum" --output "C:\Pfad\tresor_backup.sanctum"
|
||||
# Oder manuell:
|
||||
Copy-Item "C:\Pfad\tresor.sanctum" "C:\Pfad\tresor_backup.sanctum"
|
||||
```
|
||||
|
||||
2. **Freispeicher prüfen**:
|
||||
Für die Migration wird mindestens ein freier Trägerblock (~1 MB) für die erste Inode-Page benötigt. Bei extrem vollen Trägerdateien (0 freie Blöcke) bricht Sanctum die Migration sicher ab (`Out of space`), ohne den V1-Container zu verändern oder zu beschädigen.
|
||||
|
||||
3. **Hidden Vault einbinden (`mount`)**:
|
||||
Öffnen Sie den Hidden Vault mit Ihrem Hidden-Passwort:
|
||||
```powershell
|
||||
sanctum.exe mount --path "C:\Pfad\tresor.sanctum" --drive S
|
||||
```
|
||||
Sanctum erkennt automatisch das V1-Format, liest das bisherige Manifest ein und bereitet die V2-Struktur im Speicher vor.
|
||||
|
||||
4. **Migration durch Schreiboperation auslösen**:
|
||||
Die Migration auf die V2-On-Disk-Struktur wird beim nächsten Speichervorgang des Manifests automatisch vollzogen. Sie können dies durch Anlegen und sofortiges Löschen einer temporären Datei anstoßen:
|
||||
```powershell
|
||||
New-Item "S:\.migrate" -ItemType File
|
||||
Remove-Item "S:\.migrate"
|
||||
sanctum.exe unmount --drive S
|
||||
```
|
||||
Beim Aushängen (`unmount`) wird das neue Paged-Manifest (V2-Superblock + Inode-Pages) atomar auf die Trägerdatei geschrieben.
|
||||
|
||||
5. **Integrität verifizieren**:
|
||||
Überprüfen Sie den migrierten Container:
|
||||
```powershell
|
||||
sanctum.exe verify --path "C:\Pfad\tresor.sanctum"
|
||||
```
|
||||
Beim nächsten Mounten des Hidden Vaults zeigt Sanctum die dynamische Block- und Seitenstatistik des V2-Formats an.
|
||||
|
||||
---
|
||||
|
||||
## 🛡️ OpSec & Explorer Anti-Leak Shield
|
||||
|
||||
Sanctum schützt vertrauliche Daten vor unbeabsichtigten Windows-Spuren:
|
||||
|
||||
+56
-8
@@ -1,16 +1,17 @@
|
||||
# Sanctum Security Audit & Remediation Log (v0.8.0)
|
||||
# Sanctum Security Audit & Remediation Log (v0.9.1)
|
||||
|
||||
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.
|
||||
Dieses Dokument fasst alle 39 Findings aus drei umfassenden externen Sicherheitsaudits zusammen, dokumentiert die angewandten Härtungsmaßnahmen, referenziert die jeweiligen Git-Commits und benennt die zugehörigen automatisierten Regressionstests. Abschnitt 5 dokumentiert die Formaterweiterung Carrier V2 (Paged Manifest) aus v0.9.0, und Abschnitt 6 die Nachbesserungen der Minor Issues aus v0.9.1.
|
||||
|
||||
---
|
||||
|
||||
## Audit-Zusammenfassung
|
||||
|
||||
- **Zielversion:** Sanctum v0.8.0
|
||||
- **Behobene Findings:** 33 / 33 (100%)
|
||||
- **Test-Ergebnis:** 117 / 117 Tests erfolgreich (100% Pass Rate)
|
||||
- **Zielversion:** Sanctum v0.9.1 (Basis v0.9.0)
|
||||
- **Behobene Findings:** 39 / 39 (100%)
|
||||
- **Test-Ergebnis:** 128 / 128 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).
|
||||
- **Container-Format:** Container-Format V3 mit kanonischer Metadaten-Authentifizierung (HMAC-SHA256) beim Mount und Chunk-Replay-Schutz (Generation-gebundenes AAD).
|
||||
- **Hidden Vault & Storage-Resilienz:** Carrier-Format V2 (Paged Manifest), Dual-Block rollierender Superblock (C-02), Manifest-Entkopplung mit Dirty-Tracking (C-03), Fail-Soft Inode-Isolation (D-01), Sekundärindex (D-02), lückenlose Pfadvalidierung (`validate_node_name`), dynamische Kapazitätsskalierung und Blockwarnung, Fail-Closed Node-Name-Decryption (ST-01), rekursive Fehleraggregation (ST-02) und atomare SQLite-Transaktionen für Baum-Löschungen (ST-03).
|
||||
|
||||
---
|
||||
|
||||
@@ -18,6 +19,12 @@ Dieses Dokument fasst alle 33 Findings aus zwei umfassenden externen Sicherheits
|
||||
|
||||
| Finding | Priorität | Modul | Kurzbeschreibung | Commit | Status & Regressionstest |
|
||||
|---|---|---|---|---|---|
|
||||
| **C-02** | HOCH | `carrier` | Single Point of Failure beseitigt: Rollierendes Dual-Block-Manifest (Block 0 & 1, `manifest_generation`) mit transparenter Failover-Wiederherstellung | `8455dc0` | ✅ Bestanden (`test_c02_dual_block_rolling_manifest_redundancy_and_recovery`) |
|
||||
| **C-03** | MITTEL | `carrier`, `vfs`, `mount` | Entkopplung der Manifest-Neuverschlüsselung via Dirty-Tracking; synchrone Sicherung bei File-Flush und Unmount | `c606fa8` | ✅ Bestanden (`test_c03_manifest_dirty_decoupling_and_unmount_flush`) |
|
||||
| **C-04** | NIEDRIG | `carrier`, `mount`, `doc` | Dokumentation der Hidden-Vault-Kapazität (~7.000 Inodes) & automatische 80%-Füllstandswarnung beim Mounten | `c21d63a` | ✅ Bestanden (`test_c04_manifest_capacity_limit_and_warning`) |
|
||||
| **ST-01** | MITTEL | `storage` | Fail-Closed bei Knotennamen-Entschlüsselung; Beseitigung von Hex-Ciphertext-Leaks bei Bitrot/Korruption | `dd6b6ff` | ✅ Bestanden (`test_st01_fail_closed_name_decryption_no_hex_leak`) |
|
||||
| **ST-02** | NIEDRIG | `storage` | Fehleraggregation beim rekursiven Löschen in `delete_node` ohne stilles Verschlucken | `efddc2c` | ✅ Bestanden (`test_st02_recursive_delete_error_propagation_not_swallowed`) |
|
||||
| **ST-03** | NIEDRIG | `storage` | Atomare SQLite-Transaktion (`tx.commit()` / Rollback) beim rekursiven Löschen in `delete_node` | `8ff426d` | ✅ Bestanden (`test_st03_recursive_delete_transaction_rollback`) |
|
||||
| **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`) |
|
||||
@@ -86,10 +93,51 @@ Dieses Dokument fasst alle 33 Findings aus zwei umfassenden externen Sicherheits
|
||||
- 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.
|
||||
### 4. Carrier-Manifest-Resilienz & Storage-Hygiene (Dritte Audit-Runde)
|
||||
- **Rollierendes Dual-Block-Manifest (C-02):**
|
||||
- Das Carrier-Manifest wird abwechselnd auf Block 0 und Block 1 geschrieben, geschützt durch ein monotones Generation-Attribut (`manifest_generation: u64`).
|
||||
- Beim Mounten liest Sanctum beide Blöcke. Ist ein Block korrumpiert (z. B. Bitrot oder unvollständiges Schreiben), stellt Sanctum den Hidden Vault transparent aus der intakten Kopie wieder her.
|
||||
- **Entkopplung der Manifest-Neuverschlüsselung (C-03):**
|
||||
- Vor v0.8.1 wurde bei jeder Metadatenänderung (Dateierstellung, Ordnererstellung, Löschen, Umbenennen, Drop) das gesamte 1-MB-Manifest synchron per AES-256-GCM neu verschlüsselt.
|
||||
- v0.8.1 führt Dirty-Tracking ein: Änderungen markieren das Manifest als `dirty`. Die tatsächliche Verschlüsselung erfolgt gebündelt bei Datei-`flush()`, Unmount/Drop oder nach 50 Operationen.
|
||||
- **Kapazitätsgrenze & Warnschwelle (C-04):**
|
||||
- Durch den 1-MB-Block für das Manifest ergibt sich eine empfohlene Obergrenze von ~7.000 Inodes im Hidden Vault.
|
||||
- Ab 80% Füllstand (~838 KB) warnt Sanctum beim Mounten und Speichern unübersehbar.
|
||||
- **Fail-Closed bei Knotennamen (ST-01):**
|
||||
- Bei Fehlschlagen der Entschlüsselung von Knotennamen werden keine Hex-Ciphertext-Fragmente mehr exponiert (`unwrap_or(enc_name)` eliminiert).
|
||||
- Unlesbare Knoten werden mit `warn!` geloggt und in `list_children_in_vault`, `resolve_path_in_vault` und `get_node_by_id_in_vault` fail-closed übersprungen.
|
||||
- **Fehleraggregation & Transaktions-Rollback bei rekursivem Löschen (ST-02 & ST-03):**
|
||||
- Fehler beim Löschen von Kindknoten werden nicht mehr ignoriert (`let _ =` eliminiert), sondern aggregiert und protokolliert.
|
||||
### 5. Sanctum v0.9.0 — Formaterweiterung Carrier V2 (Paged Manifest)
|
||||
- **Aufhebung der C-04 Manifest-Kapazitätsgrenze:**
|
||||
- In v0.8.1 war das Manifest ein einzelnes JSON-Objekt auf Block 0 und Block 1 (limitiert auf ca. 7.000 Inodes).
|
||||
- Mit Format V2 wird der `CarrierSuperblock` (Block 0 & 1, dual-block rollierend C-02) von den eigentlichen Inode-Daten entkoppelt.
|
||||
- Inodes werden in separaten `CarrierInodePage`-Blöcken (~1 MB Payload je Seite, ca. 4.500–7.000 Inodes pro Seite) verwaltet, dynamisch allokiert aus dem Blockpool.
|
||||
- **Paged Loading & Fail-Soft Resilienz (D-01):**
|
||||
- Isolierte Fehlerbehandlung: Beschädigte oder unlesbare Inode-Seiten führen nicht mehr zum Gesamtabbruch des Mounts.
|
||||
- Das System lädt alle lesbaren Seiten, loggt fehlerhafte Seiten als `error!` und führt einen Zähler `corrupted_pages`, der beim Einbinden gut sichtbar gemeldet wird.
|
||||
- **Sekundärindex für Kindknoten (`children_index`, D-02):**
|
||||
- `CarrierFsInner` pflegt einen `HashMap<i64, Vec<i64>>` In-Memory Index für Vater-Kind-Beziehungen.
|
||||
- Reduziert Pfadauflösung (`resolve_path`) und Verzeichnis-Listings (`read_dir`) von $O(N)$ Tabellenscans auf $O(\text{Geschwister})$.
|
||||
- **Transparente Migration & Allokations-Sicherheit (D-03, D-04, D-05):**
|
||||
- V1-Container werden transparent geladen und beim ersten Schreibvorgang nach V2 migriert — inklusive Vorabprüfung, ob genügend freie Blöcke vorhanden sind.
|
||||
- Freigabe überzähliger Seitenblöcke (`shred_carrier_block`) bei Inode-Löschungen.
|
||||
- Ersetzung der statischen 80%-Füllstandswarnung durch eine Block-Verfügbarkeitswarnung bei `< 20` freien Blöcken oder `< 5%` Restkapazität.
|
||||
- **Automatisierte Testabdeckung:** 7 neue Regressionstests in `tests/carrier_v2_paged_manifest_test.rs` decken Kapazität (>10.000 Inodes), Migration, Fail-Soft-Isolation, Sekundärindex-Konsistenz, Pfadauflösungs-Performance, Out-of-Space-Abbruch und Blockfreigabe ab (Gesamttests: 130/130 erfolgreich).
|
||||
|
||||
### 6. Sanctum v0.9.1 — Sicherheits-Härtung, Pfadvalidierung & Migration-Dokumentation
|
||||
- **Metadaten-MAC-Validierung beim Mount (K-01):**
|
||||
- `mount_container` validiert vor dem Bereitstellen des Dateisystems die Integrität der SQLite-Metadaten via `db.verify_metadata_mac_for_slot`.
|
||||
- Bei Manipulation bricht der Vorgang fail-closed ab; nachfolgende VFS-Operationen führen den MAC über den aktiven DEK fort.
|
||||
- **Lückenlose Pfadvalidierung (`validate_node_name`):**
|
||||
- Carrier-Dateisystem (`CarrierFs::open`, `CarrierFs::create_dir`, `CarrierFs::rename`, `CarrierFs::copy`) und VFS (`SanctumFs::copy`) validieren Knotennamen lückenlos gegen Windows-Reservierungen (`CON`, `PRN`, `AUX`, `NUL`, etc.) und verbotene Steuerzeichen.
|
||||
- **Dokumentation & Runtime-Warnung zu `--legacy-names`:**
|
||||
- Schutz vor Swap-Attacks bei der Dateinamen-Entschlüsselung; explizite Warnung im CLI-Hilfetext, auf stderr und im Logging bei Aktivierung.
|
||||
- **Migration-Dokumentation (V1 → V2):**
|
||||
- Detaillierte 5-stufige Dokumentation für Anwender zur Konvertierung auf das Paged-Manifest-Format V2.
|
||||
|
||||
---
|
||||
|
||||
## 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.
|
||||
Alle Unit- und Integrationstests wurden auf einem Windows x86_64 Host mit 100% Erfolgsquote ausgeführt (130 / 130 Tests). Die Release-Paketierung für Windows und Linux musl ist voll automatisiert und wird mit Minisign kryptografisch abgesichert.
|
||||
+40
-1
@@ -1,6 +1,6 @@
|
||||
# Threat Model & Sicherheitsarchitektur von Sanctum
|
||||
|
||||
Dieses Dokument beschreibt das Bedrohungsmodell, die Sicherheitsannahmen und die Schutzmechanismen von **Sanctum v0.8.0** im reinen Userland-Betrieb.
|
||||
Dieses Dokument beschreibt das Bedrohungsmodell, die Sicherheitsannahmen und die Schutzmechanismen von **Sanctum v0.9.1** im reinen Userland-Betrieb.
|
||||
|
||||
---
|
||||
|
||||
@@ -35,6 +35,8 @@ Dieses Dokument beschreibt das Bedrohungsmodell, die Sicherheitsannahmen und die
|
||||
| **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. |
|
||||
| **Dateinamen-Swap-Angriffe** | Angreifer vertauscht verschlüsselte Dateinamen zwischen Verzeichnissen. | AAD-Bindung an `parent_id` bei AES-256-GCM Verschlüsselung; Warnung vor `--legacy-names` (deaktiviert diesen Schutz). |
|
||||
| **Path-Traversal & Gerätenamen** | Angreifer schleust Pfad-Traversal (`..`), reservierte Namen (`CON`, `PRN`) oder Null-Bytes ein. | Strikte Validierung (`validate_node_name`) in allen Schichten (`storage.rs`, `vfs.rs`, `carrier.rs`, `sync.rs`). |
|
||||
|
||||
---
|
||||
|
||||
@@ -102,3 +104,40 @@ Wird der Rechner abrupt stromlos gemacht (`Hard Reset`), stürzt das Betriebssys
|
||||
- **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.
|
||||
|
||||
---
|
||||
|
||||
## 6. Hidden Vault Carrier-Dateisystem & Redundanzmodell (Format V2)
|
||||
|
||||
### 6.1 Redundanzhierarchie: Superblock vs. Inode-Pages
|
||||
Mit Sanctum v0.9.0 führt der Hidden Vault das Carrier-Format V2 (Paged Manifest) ein. Das Redundanzmodell unterscheidet bewusst zwischen Metadaten-Knotenpunkten und Inode-Seiten:
|
||||
|
||||
1. **Carrier-Superblock (Vollständige Redundanz auf Block 0 & Block 1)**:
|
||||
- Der Superblock enthält die essenziellen Dateisystem-Parameter (`root_id`, `next_inode_id`, `free_blocks`, `page_block_indices`) sowie einen monotonen Generationszähler (`manifest_generation`) und CRC32-Prüfsummen.
|
||||
- Er wird abwechselnd auf Block 0 und Block 1 geschrieben (rollierendes C-02-Schema). Ist einer der beiden Blöcke beschädigt oder unvollständig geschrieben, stellt Sanctum den Superblock transparent aus dem intakten Block wieder her.
|
||||
2. **Inode-Pages (Dynamisch allokiert, nicht redundant dupliziert)**:
|
||||
- Inodes werden in 1-MB-Seiten (`CarrierInodePage`, Magic `SANCTPAG`) im normalen Träger-Blockpool gespeichert.
|
||||
- Zur Maximierung der nutzbaren Speicherkapazität werden Inode-Pages **nicht** blockweise gespiegelt. Stattdessen schützt Sanctum die Konsistenz über Fail-Soft-Isolation (D-01): Fällt eine einzelne Seite durch Bitrot oder Entschlüsselungsfehler aus, wird ausschließlich diese Seite übersprungen. Das restliche Dateisystem bleibt vollständig mountbar und lesbar.
|
||||
- Erkannte Seitenbeschädigungen werden beim Mounten und in den Systemlogs (`corrupted_pages`) unübersehbar gemeldet.
|
||||
|
||||
### 6.2 Pfadauflösungs- und DoS-Schutz (`children_index`, D-02)
|
||||
- Bei sehr großen Dateisystemen (>10.000 Inodes) führt eine lineare Suche über alle Inodes bei jedem Pfadsegment zu quadratischer Laufzeitkomplexität ($O(N)$ pro Segment).
|
||||
- Sanctum v0.9.0 hält einen In-Memory-Sekundärindex (`children_index: HashMap<i64, Vec<i64>>`), der Pfadauflösungen auf $O(\text{Geschwister})$ reduziert. Dies verhindert CPU-Erschöpfungs-Angriffe (ReDoS/Algorithmic Complexity Attacks) beim Traversieren tiefer Verzeichnisstrukturen.
|
||||
|
||||
### 6.3 Speicherallokationsgrenzen & Transaktionssicherheit (D-03, D-05)
|
||||
- **Vorabprüfung bei Migration (D-03)**: Bei der transparenten Konvertierung alter V1-Manifeste nach V2 prüft Sanctum vorab, ob ausreichend freie Trägerblöcke vorhanden sind. Reicht der Speicherplatz nicht aus, wird der Speichervorgang ohne Beschädigung des V1-Containers abgebrochen.
|
||||
- **Kryptografische Blockfreigabe (D-05)**: Werden Inodes gelöscht und Inode-Pages überflüssig, werden die freigegebenen Trägerblöcke sofort mit CSPRNG-Rauschen überschrieben (`shred_carrier_block`), bevor sie an den Freispeicher-Pool zurückgegeben werden.
|
||||
|
||||
---
|
||||
|
||||
## 7. Dateinamen-Sicherheit und das `--legacy-names`-Flag
|
||||
|
||||
### 7.1 AAD-Bindung von Dateinamen
|
||||
In Sanctum werden Dateinamen mit AES-256-GCM verschlüsselt. Um Swap-Angriffe zu verhindern (bei denen ein Angreifer mit Dateisystem-Zugriff verschlüsselte Dateinamen zwischen Verzeichnissen austauscht), wird die `parent_id` als zusätzliche authentifizierte Daten (AAD) an die Verschlüsselung gebunden.
|
||||
|
||||
### 7.2 Sicherheitsrisiko des `--legacy-names`-Flags
|
||||
Frühere Versionen von Sanctum (vor v0.8.0) verwendeten leere AAD für Dateinamen. Das Flag `--legacy-names` erlaubt die Entschlüsselung von Dateinamen ohne AAD-Bindung als Fallback.
|
||||
- **Risiko**: Bei aktiviertem `--legacy-names` ist der Schutz vor Vertauschen von Dateinamen aufgehoben. Ein Angreifer könnte Dateien manipulieren, indem er verschlüsselte Namen zwischen verschiedenen Verzeichnissen vertauscht.
|
||||
- **Empfehlung**: Dieses Flag darf **ausschließlich** zur einmaligen Migration von Altdaten verwendet werden. Im regulären Betrieb muss es deaktiviert bleiben.
|
||||
|
||||
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
{
|
||||
"version": "0.8.0",
|
||||
"version": "0.9.1",
|
||||
"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.8.0/sanctum-v0.8.0-windows-x86_64.zip",
|
||||
"hash": "11fa00bdd0dd48599ee578202c09c86ccbb7b971932bf14c8b4d11817aa26419",
|
||||
"url": "https://gitea.pansi.eu/harald/sanctum/releases/download/v0.9.1/sanctum-v0.9.1-windows-x86_64.zip",
|
||||
"hash": "0409d5e67c173983693456620b217e9498dcdc1ae54a6bc67aa8e368ee3d0883",
|
||||
"bin": "sanctum.exe"
|
||||
}
|
||||
},
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# yaml-language-server: $schema=https://aka.ms/winget-manifest.singleton.1.6.0.schema.json
|
||||
PackageIdentifier: HaraldPansi.Sanctum
|
||||
PackageVersion: 0.8.0
|
||||
PackageVersion: 0.9.1
|
||||
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.8.0
|
||||
ReleaseNotesUrl: https://gitea.pansi.eu/harald/sanctum/releases/tag/v0.9.1
|
||||
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.8.0/sanctum-v0.8.0-windows-x86_64.zip
|
||||
InstallerSha256: 11fa00bdd0dd48599ee578202c09c86ccbb7b971932bf14c8b4d11817aa26419
|
||||
InstallerUrl: https://gitea.pansi.eu/harald/sanctum/releases/download/v0.9.1/sanctum-v0.9.1-windows-x86_64.zip
|
||||
InstallerSha256: 0409d5e67c173983693456620b217e9498dcdc1ae54a6bc67aa8e368ee3d0883
|
||||
ManifestType: singleton
|
||||
ManifestVersion: 1.6.0
|
||||
|
||||
+563
-46
@@ -18,7 +18,7 @@ use futures_util::stream;
|
||||
use rand::rngs::OsRng;
|
||||
use rand::RngCore;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use tracing::{error, warn};
|
||||
use tracing::{debug, error, warn};
|
||||
use zeroize::{Zeroize, Zeroizing};
|
||||
|
||||
use crate::crypto::{decrypt_chunk, encrypt_chunk, CHUNK_SIZE};
|
||||
@@ -27,15 +27,52 @@ use crate::vfs::{is_leak_file_with_custom, SanctumDirEntry, SanctumMetaData};
|
||||
|
||||
pub const CARRIER_MAGIC: &[u8; 8] = b"SANCTCAR";
|
||||
pub const CARRIER_VERSION: u32 = 1;
|
||||
pub const CARRIER_VERSION_V2: u32 = 2;
|
||||
pub const CARRIER_PAGE_MAGIC: &[u8; 8] = b"SANCTPAG";
|
||||
pub const CARRIER_MANIFEST_CAPACITY: usize = CHUNK_SIZE - 64; // 1,048,512 Bytes
|
||||
pub const CARRIER_MANIFEST_WARN_THRESHOLD: usize = CARRIER_MANIFEST_CAPACITY * 8 / 10; // 838,809 Bytes (80%, C-04)
|
||||
|
||||
/// Manifest für das steganografische Dateisystem innerhalb des Alibi-Carriers (Block 0).
|
||||
/// Superblock: globaler Zustand, redundant auf Block 0 und 1 (C-02, Format V2).
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct CarrierSuperblock {
|
||||
pub magic: [u8; 8],
|
||||
pub version: u32,
|
||||
pub manifest_generation: u64,
|
||||
pub total_blocks: u32,
|
||||
pub free_blocks: Vec<u32>,
|
||||
pub next_inode_id: i64,
|
||||
pub page_block_indices: Vec<u32>, // Reihenfolge = Seitenreihenfolge
|
||||
}
|
||||
|
||||
/// Eine Inode-Tabellenseite (~1 MB Budget, serialisiert in einen Carrier-Block).
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct CarrierInodePage {
|
||||
pub magic: [u8; 8], // eigenes Sub-Magic b"SANCTPAG"
|
||||
pub entries: Vec<CarrierInode>,
|
||||
}
|
||||
|
||||
/// Hilfsstruktur zur Typerkennung (V1 vs V2) in Block 0/1.
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct VersionProbe {
|
||||
#[allow(dead_code)]
|
||||
pub magic: [u8; 8],
|
||||
pub version: u32,
|
||||
}
|
||||
|
||||
/// In-Memory-Zustand des Carrier-Manifests.
|
||||
/// Hält Superblock-Felder und die vollständige Inode-Map für schnellen Zugriff.
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct CarrierManifest {
|
||||
pub magic: [u8; 8],
|
||||
pub version: u32,
|
||||
#[serde(default)]
|
||||
pub manifest_generation: u64,
|
||||
pub total_blocks: u32,
|
||||
pub free_blocks: Vec<u32>,
|
||||
pub next_inode_id: i64,
|
||||
#[serde(default)]
|
||||
pub page_block_indices: Vec<u32>,
|
||||
#[serde(default)]
|
||||
pub inodes: HashMap<i64, CarrierInode>,
|
||||
}
|
||||
|
||||
@@ -62,15 +99,28 @@ impl CarrierManifest {
|
||||
},
|
||||
);
|
||||
|
||||
// Block 0 ist für das Manifest reserviert. Nutzblöcke sind 1..total_blocks-1.
|
||||
let free_blocks = (1..total_blocks).collect();
|
||||
// Block 0 und Block 1 sind für den Superblock reserviert (C-02).
|
||||
// Block 2 wird für die erste Inode-Tabellenseite allokiert (falls total_blocks > 2).
|
||||
// Nutzblöcke starten ab Block 3.
|
||||
let page_block_indices = if total_blocks > 2 {
|
||||
vec![2]
|
||||
} else {
|
||||
Vec::new()
|
||||
};
|
||||
let free_blocks = if total_blocks > 3 {
|
||||
(3..total_blocks).collect()
|
||||
} else {
|
||||
Vec::new()
|
||||
};
|
||||
|
||||
Self {
|
||||
magic: *CARRIER_MAGIC,
|
||||
version: CARRIER_VERSION,
|
||||
version: CARRIER_VERSION_V2,
|
||||
manifest_generation: 0,
|
||||
total_blocks,
|
||||
free_blocks,
|
||||
next_inode_id: 2,
|
||||
page_block_indices,
|
||||
inodes,
|
||||
}
|
||||
}
|
||||
@@ -274,6 +324,12 @@ pub struct CarrierFsInner {
|
||||
pub custom_leak_rules: Arc<Vec<String>>,
|
||||
pub leak_counter: Arc<AtomicU64>,
|
||||
pub manifest: CarrierManifest,
|
||||
pub children_index: HashMap<i64, Vec<i64>>, // parent_id -> [child_id, ...] (D-02)
|
||||
pub corrupted_pages: usize, // Zähler für übersprungene/beschädigte Seiten (D-01)
|
||||
pub manifest_dirty: bool,
|
||||
pub manifest_save_count: u64,
|
||||
pub dirty_ops_count: u32,
|
||||
pub last_manifest_save: u64,
|
||||
pub last_activity: Arc<AtomicU64>,
|
||||
}
|
||||
|
||||
@@ -281,31 +337,227 @@ impl CarrierFsInner {
|
||||
pub fn is_leak(&self, name: &str) -> bool {
|
||||
self.anti_leak && is_leak_file_with_custom(name, &self.custom_leak_rules)
|
||||
}
|
||||
|
||||
/// Baut den Sekundärindex (parent_id -> [child_id, ...]) aus der Inode-Map auf (D-02).
|
||||
pub fn build_children_index(inodes: &HashMap<i64, CarrierInode>) -> HashMap<i64, Vec<i64>> {
|
||||
let mut index: HashMap<i64, Vec<i64>> = HashMap::new();
|
||||
for (&id, inode) in inodes {
|
||||
if let Some(parent_id) = inode.parent_id {
|
||||
index.entry(parent_id).or_default().push(id);
|
||||
}
|
||||
}
|
||||
index
|
||||
}
|
||||
|
||||
pub fn index_add_child(&mut self, parent_id: i64, child_id: i64) {
|
||||
let entry = self.children_index.entry(parent_id).or_default();
|
||||
if !entry.contains(&child_id) {
|
||||
entry.push(child_id);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn index_remove_child(&mut self, parent_id: i64, child_id: i64) {
|
||||
if let Some(children) = self.children_index.get_mut(&parent_id) {
|
||||
children.retain(|&id| id != child_id);
|
||||
}
|
||||
}
|
||||
|
||||
/// Markiert das Manifest als modifiziert (dirty) ohne teure synchrone Neuverschlüsselung (C-03).
|
||||
pub fn mark_dirty(&mut self) {
|
||||
self.manifest_dirty = true;
|
||||
self.dirty_ops_count += 1;
|
||||
if self.dirty_ops_count >= 50 {
|
||||
let _ = self.flush_manifest_if_dirty();
|
||||
}
|
||||
}
|
||||
|
||||
/// Schreibt das Manifest nur, wenn ungespeicherte Änderungen anstehen (C-03).
|
||||
pub fn flush_manifest_if_dirty(&mut self) -> Result<()> {
|
||||
if self.manifest_dirty {
|
||||
self.save_manifest()?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Ermittelt die aktuelle Bytegröße des Manifests, die Kapazität und den Füllstand in Prozent.
|
||||
pub fn manifest_usage(&self) -> (usize, usize, f64) {
|
||||
let pages_count = self.manifest.page_block_indices.len().max(1);
|
||||
let total_page_capacity = pages_count * CARRIER_MANIFEST_CAPACITY;
|
||||
let mut total_bytes = 0usize;
|
||||
for inode in self.manifest.inodes.values() {
|
||||
total_bytes += serde_json::to_vec(inode)
|
||||
.map(|v| v.len() + 2)
|
||||
.unwrap_or(200);
|
||||
}
|
||||
let pct = if total_page_capacity > 0 {
|
||||
(total_bytes as f64 / total_page_capacity as f64) * 100.0
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
(total_bytes, total_page_capacity, pct)
|
||||
}
|
||||
|
||||
pub fn free_blocks_count(&self) -> usize {
|
||||
self.manifest.free_blocks.len()
|
||||
}
|
||||
|
||||
pub fn total_blocks_count(&self) -> u32 {
|
||||
self.manifest.total_blocks
|
||||
}
|
||||
|
||||
pub fn page_count(&self) -> usize {
|
||||
self.manifest.page_block_indices.len()
|
||||
}
|
||||
|
||||
/// Speichert das Carrier-Manifest im Format V2 (Superblock + Inode-Tabellenseiten, D-04).
|
||||
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) {
|
||||
self.manifest_save_count += 1;
|
||||
self.manifest_dirty = false;
|
||||
self.dirty_ops_count = 0;
|
||||
self.last_manifest_save = SystemTime::now()
|
||||
.duration_since(UNIX_EPOCH)
|
||||
.map(|d| d.as_secs())
|
||||
.unwrap_or(0);
|
||||
self.manifest.manifest_generation += 1;
|
||||
|
||||
// D-04: Inodes auf Seiten aufteilen (deterministisch nach Inode-ID sortiert)
|
||||
let mut sorted_inodes: Vec<CarrierInode> = self.manifest.inodes.values().cloned().collect();
|
||||
sorted_inodes.sort_by_key(|i| i.id);
|
||||
|
||||
let mut pages: Vec<CarrierInodePage> = Vec::new();
|
||||
let mut current_entries = Vec::new();
|
||||
let mut current_bytes = 64usize; // Header-Overhead für CarrierInodePage JSON
|
||||
|
||||
for inode in sorted_inodes {
|
||||
let entry_len = serde_json::to_vec(&inode)
|
||||
.map(|v| v.len() + 2)
|
||||
.unwrap_or(256);
|
||||
if current_bytes + entry_len > CARRIER_MANIFEST_CAPACITY && !current_entries.is_empty()
|
||||
{
|
||||
pages.push(CarrierInodePage {
|
||||
magic: *CARRIER_PAGE_MAGIC,
|
||||
entries: std::mem::take(&mut current_entries),
|
||||
});
|
||||
current_bytes = 64;
|
||||
}
|
||||
current_bytes += entry_len;
|
||||
current_entries.push(inode);
|
||||
}
|
||||
if !current_entries.is_empty() || pages.is_empty() {
|
||||
pages.push(CarrierInodePage {
|
||||
magic: *CARRIER_PAGE_MAGIC,
|
||||
entries: current_entries,
|
||||
});
|
||||
}
|
||||
|
||||
let needed_pages = pages.len();
|
||||
let old_page_blocks = self.manifest.page_block_indices.clone();
|
||||
let old_page_count = old_page_blocks.len();
|
||||
|
||||
let mut new_page_blocks = old_page_blocks;
|
||||
|
||||
if needed_pages > old_page_count {
|
||||
let additional_needed = needed_pages - old_page_count;
|
||||
if self.manifest.free_blocks.len() < additional_needed {
|
||||
bail!(
|
||||
"Carrier-Manifest überschreitet die maximale Blockgröße ({} > {} Bytes).",
|
||||
manifest_bytes.len(),
|
||||
crate::crypto::CHUNK_SIZE - 64
|
||||
"Nicht genügend freie Blöcke für die Inode-Tabelle (benötigt: {}, frei: {}). Bitte Speicherplatz freigeben oder Container vergrößern.",
|
||||
additional_needed,
|
||||
self.manifest.free_blocks.len()
|
||||
);
|
||||
}
|
||||
if manifest_bytes.len() > 800_000 {
|
||||
warn!(
|
||||
"Carrier-Manifest erreicht 80% der Blockkapazität ({}/{} Bytes)",
|
||||
manifest_bytes.len(),
|
||||
crate::crypto::CHUNK_SIZE - 64
|
||||
for _ in 0..additional_needed {
|
||||
let block = self.manifest.free_blocks.pop().ok_or_else(|| {
|
||||
anyhow::anyhow!("Keine freien Blöcke mehr für Inode-Seitenallokation")
|
||||
})?;
|
||||
new_page_blocks.push(block);
|
||||
}
|
||||
} else if needed_pages < old_page_count {
|
||||
// D-05: Überzählige Seitenblöcke freigeben und schreddern
|
||||
let surplus = new_page_blocks.split_off(needed_pages);
|
||||
for b in surplus {
|
||||
let _ = shred_carrier_block(
|
||||
&self.db,
|
||||
self.carrier_node_id,
|
||||
b,
|
||||
&self.dek_outer,
|
||||
self.format_version,
|
||||
);
|
||||
self.manifest.free_blocks.push(b);
|
||||
}
|
||||
}
|
||||
|
||||
// Alle Inode-Tabellenseiten schreiben
|
||||
for (page_idx, page) in pages.iter().enumerate() {
|
||||
let block_idx = new_page_blocks[page_idx];
|
||||
let page_bytes = serde_json::to_vec(page)?;
|
||||
if page_bytes.len() > CARRIER_MANIFEST_CAPACITY {
|
||||
bail!(
|
||||
"Inode-Tabellenseite #{} überschreitet Blockgröße ({} > {} Bytes)",
|
||||
page_idx,
|
||||
page_bytes.len(),
|
||||
CARRIER_MANIFEST_CAPACITY
|
||||
);
|
||||
}
|
||||
write_carrier_block(
|
||||
&self.db,
|
||||
self.carrier_node_id,
|
||||
0,
|
||||
block_idx,
|
||||
&self.dek_outer,
|
||||
&self.dek_inner,
|
||||
&manifest_bytes,
|
||||
&page_bytes,
|
||||
self.format_version,
|
||||
)?;
|
||||
}
|
||||
|
||||
self.manifest.page_block_indices = new_page_blocks.clone();
|
||||
self.manifest.version = CARRIER_VERSION_V2;
|
||||
|
||||
// Superblock schreiben (C-02 Dual-Block Rolling Scheme)
|
||||
let superblock = CarrierSuperblock {
|
||||
magic: *CARRIER_MAGIC,
|
||||
version: CARRIER_VERSION_V2,
|
||||
manifest_generation: self.manifest.manifest_generation,
|
||||
total_blocks: self.manifest.total_blocks,
|
||||
free_blocks: self.manifest.free_blocks.clone(),
|
||||
next_inode_id: self.manifest.next_inode_id,
|
||||
page_block_indices: new_page_blocks,
|
||||
};
|
||||
|
||||
let sb_bytes = serde_json::to_vec(&superblock)?;
|
||||
if sb_bytes.len() > CARRIER_MANIFEST_CAPACITY {
|
||||
bail!(
|
||||
"Superblock überschreitet Blockgröße ({} > {} Bytes)",
|
||||
sb_bytes.len(),
|
||||
CARRIER_MANIFEST_CAPACITY
|
||||
);
|
||||
}
|
||||
|
||||
let target_block = if self.manifest.manifest_generation.is_multiple_of(2) {
|
||||
0
|
||||
} else {
|
||||
1
|
||||
};
|
||||
|
||||
write_carrier_block(
|
||||
&self.db,
|
||||
self.carrier_node_id,
|
||||
target_block,
|
||||
&self.dek_outer,
|
||||
&self.dek_inner,
|
||||
&sb_bytes,
|
||||
self.format_version,
|
||||
)?;
|
||||
|
||||
// Warnung bei knappem freiem Blockpool
|
||||
let free_len = self.manifest.free_blocks.len();
|
||||
let total = self.manifest.total_blocks;
|
||||
if total > 0 && (free_len < 20 || (free_len as f64 / total as f64) < 0.05) {
|
||||
warn!(
|
||||
"Warnung: Hidden-Vault hat nur noch {} freie Blöcke (von {}).",
|
||||
free_len, total
|
||||
);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -328,6 +580,7 @@ impl CarrierFsInner {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Löst einen Pfad anhand des Sekundärindex auf (D-02, O(Kindknoten) statt O(alle Inodes)).
|
||||
pub fn resolve_path(&self, raw_path: &str) -> Option<CarrierInode> {
|
||||
let trimmed = raw_path.trim_matches('/');
|
||||
if trimmed.is_empty() {
|
||||
@@ -338,10 +591,17 @@ impl CarrierFsInner {
|
||||
let mut current_id = 1i64;
|
||||
|
||||
for (idx, segment) in segments.iter().enumerate() {
|
||||
let child = self.manifest.inodes.values().find(|inode| {
|
||||
inode.parent_id == Some(current_id) && inode.name.as_str() == *segment
|
||||
let child_ids = self.children_index.get(¤t_id)?;
|
||||
let child_id = child_ids.iter().find(|&&cid| {
|
||||
self.manifest
|
||||
.inodes
|
||||
.get(&cid)
|
||||
.map(|inode| inode.name.as_str() == *segment)
|
||||
.unwrap_or(false)
|
||||
})?;
|
||||
|
||||
let child = self.manifest.inodes.get(child_id)?;
|
||||
|
||||
if idx + 1 < segments.len() && !child.is_dir {
|
||||
return None;
|
||||
}
|
||||
@@ -362,19 +622,43 @@ impl CarrierFsInner {
|
||||
|
||||
impl Drop for CarrierFsInner {
|
||||
fn drop(&mut self) {
|
||||
if self.manifest_dirty {
|
||||
if let Err(e) = self.save_manifest() {
|
||||
error!(
|
||||
"Fehler beim finalen Speichern des Carrier-Manifests im Drop: {:?}",
|
||||
e
|
||||
);
|
||||
}
|
||||
}
|
||||
crate::windows::unlock_memory(self.dek_outer.as_ptr(), 32);
|
||||
crate::windows::unlock_memory(self.dek_inner.as_ptr(), 32);
|
||||
}
|
||||
}
|
||||
|
||||
enum LoadedBlock {
|
||||
V1(CarrierManifest),
|
||||
V2(CarrierSuperblock),
|
||||
}
|
||||
|
||||
impl LoadedBlock {
|
||||
fn generation(&self) -> u64 {
|
||||
match self {
|
||||
LoadedBlock::V1(m) => m.manifest_generation,
|
||||
LoadedBlock::V2(sb) => sb.manifest_generation,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// WebDAV-Filesystem-Treiber für den steganografischen Alibi-Carrier (Hidden Vault).
|
||||
#[derive(Clone)]
|
||||
pub struct CarrierFs {
|
||||
inner: Arc<Mutex<CarrierFsInner>>,
|
||||
pub inner: Arc<Mutex<CarrierFsInner>>,
|
||||
}
|
||||
|
||||
impl CarrierFs {
|
||||
/// Lädt ein bestehendes Carrier-Dateisystem mit benutzerdefinierten Anti-Leak-Regeln (V-04).
|
||||
/// Lädt ein bestehendes Carrier-Dateisystem mit redundanter Superblock-Prüfung (C-02),
|
||||
/// seitenbasierter Inode-Tabelle (D-01), V1->V2 Migrationsunterstützung (D-03)
|
||||
/// und benutzerdefinierten Anti-Leak-Regeln (V-04).
|
||||
pub fn load_with_leak_rules(
|
||||
db: Database,
|
||||
carrier_node_id: i64,
|
||||
@@ -384,18 +668,166 @@ impl CarrierFs {
|
||||
anti_leak: bool,
|
||||
custom_leak_rules: Vec<String>,
|
||||
) -> Result<Self> {
|
||||
let manifest_bytes = read_carrier_block(
|
||||
let read_and_parse_block = |block_idx: u32| -> Result<LoadedBlock> {
|
||||
let bytes = read_carrier_block(
|
||||
&db,
|
||||
carrier_node_id,
|
||||
0,
|
||||
block_idx,
|
||||
&dek_outer,
|
||||
&dek_inner,
|
||||
format_version,
|
||||
)?;
|
||||
let probe: VersionProbe = serde_json::from_slice(&bytes)?;
|
||||
if probe.magic != *CARRIER_MAGIC {
|
||||
bail!("Ungültige Carrier-Magic-Bytes in Block {block_idx}");
|
||||
}
|
||||
if probe.version == CARRIER_VERSION {
|
||||
let m: CarrierManifest = serde_json::from_slice(&bytes)?;
|
||||
Ok(LoadedBlock::V1(m))
|
||||
} else if probe.version == CARRIER_VERSION_V2 {
|
||||
let sb: CarrierSuperblock = serde_json::from_slice(&bytes)?;
|
||||
Ok(LoadedBlock::V2(sb))
|
||||
} else {
|
||||
bail!("Unbekannte Carrier-Formatversion: {}", probe.version);
|
||||
}
|
||||
};
|
||||
|
||||
let manifest: CarrierManifest = serde_json::from_slice(&manifest_bytes)?;
|
||||
if manifest.magic != *CARRIER_MAGIC {
|
||||
bail!("Ungültige Carrier-Magic-Bytes in Block 0");
|
||||
let block_0_res = read_and_parse_block(0);
|
||||
let block_1_res = read_and_parse_block(1);
|
||||
|
||||
let loaded_block = match (block_0_res, block_1_res) {
|
||||
(Ok(b0), Ok(b1)) => {
|
||||
if b1.generation() > b0.generation() {
|
||||
debug!(
|
||||
"C-02: Beide Superblock-Kopien intakt. Wähle neuere Generation {} aus Block 1 (Block 0: Gen {})",
|
||||
b1.generation(), b0.generation()
|
||||
);
|
||||
b1
|
||||
} else {
|
||||
debug!(
|
||||
"C-02: Beide Superblock-Kopien intakt. Wähle Generation {} aus Block 0 (Block 1: Gen {})",
|
||||
b0.generation(), b1.generation()
|
||||
);
|
||||
b0
|
||||
}
|
||||
}
|
||||
(Ok(b0), Err(e1)) => {
|
||||
debug!(
|
||||
"C-02: Verwende primären Superblock aus Block 0 (Gen {}). Block 1 unlesbar oder uninitialisiert: {}",
|
||||
b0.generation(), e1
|
||||
);
|
||||
b0
|
||||
}
|
||||
(Err(e0), Ok(b1)) => {
|
||||
warn!(
|
||||
"C-02: Block 0 korrupt oder unlesbar ({})! Erfolgreiche Wiederherstellung aus redundanter Kopie in Block 1 (Gen {}).",
|
||||
e0, b1.generation()
|
||||
);
|
||||
b1
|
||||
}
|
||||
(Err(e0), Err(e1)) => {
|
||||
bail!(
|
||||
"Kritischer Datenverlust (C-02): Weder Block 0 ({}) noch Block 1 ({}) enthalten ein gültiges Carrier-Manifest! Hidden Vault nicht wiederherstellbar.",
|
||||
e0, e1
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
let mut corrupted_pages = 0usize;
|
||||
let manifest = match loaded_block {
|
||||
LoadedBlock::V1(mut m) => {
|
||||
// Rückwärtskompatibilität zu v0.8.0-Containern: Block 1 als redundante Kopie reservieren
|
||||
m.free_blocks.retain(|&b| b >= 2);
|
||||
m
|
||||
}
|
||||
LoadedBlock::V2(sb) => {
|
||||
let mut inodes = HashMap::new();
|
||||
for &page_block_idx in &sb.page_block_indices {
|
||||
match read_carrier_block(
|
||||
&db,
|
||||
carrier_node_id,
|
||||
page_block_idx,
|
||||
&dek_outer,
|
||||
&dek_inner,
|
||||
format_version,
|
||||
) {
|
||||
Ok(page_bytes) => {
|
||||
match serde_json::from_slice::<CarrierInodePage>(&page_bytes) {
|
||||
Ok(page) => {
|
||||
if page.magic != *CARRIER_PAGE_MAGIC {
|
||||
error!(
|
||||
"D-01: Ungültige Magic in Inode-Tabellenseite auf Block {} (erwartet SANCTPAG)",
|
||||
page_block_idx
|
||||
);
|
||||
corrupted_pages += 1;
|
||||
} else {
|
||||
for entry in page.entries {
|
||||
inodes.insert(entry.id, entry);
|
||||
}
|
||||
}
|
||||
}
|
||||
Err(e) => {
|
||||
error!(
|
||||
"D-01: Deserialisierungsfehler in Inode-Tabellenseite auf Block {}: {}",
|
||||
page_block_idx, e
|
||||
);
|
||||
corrupted_pages += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
Err(e) => {
|
||||
error!(
|
||||
"D-01: Lesefehler auf Inode-Tabellenseite Block {}: {}",
|
||||
page_block_idx, e
|
||||
);
|
||||
corrupted_pages += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Sicherstellen, dass das Wurzelverzeichnis '/' (Inode 1) vorhanden ist
|
||||
inodes.entry(1).or_insert_with(|| {
|
||||
warn!("Wurzelknoten (Inode 1) fehlt in geladenen Seiten, wird rekonstruiert.");
|
||||
let now = SystemTime::now()
|
||||
.duration_since(UNIX_EPOCH)
|
||||
.map(|d| d.as_secs())
|
||||
.unwrap_or(0);
|
||||
CarrierInode {
|
||||
id: 1,
|
||||
parent_id: None,
|
||||
name: String::new(),
|
||||
is_dir: true,
|
||||
size: 0,
|
||||
created_at: now,
|
||||
modified_at: now,
|
||||
blocks: Vec::new(),
|
||||
}
|
||||
});
|
||||
|
||||
CarrierManifest {
|
||||
magic: sb.magic,
|
||||
version: sb.version,
|
||||
manifest_generation: sb.manifest_generation,
|
||||
total_blocks: sb.total_blocks,
|
||||
free_blocks: sb.free_blocks,
|
||||
next_inode_id: sb.next_inode_id,
|
||||
page_block_indices: sb.page_block_indices,
|
||||
inodes,
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// D-02: Sekundärindex aufbauen
|
||||
let children_index = CarrierFsInner::build_children_index(&manifest.inodes);
|
||||
|
||||
// Warnung bei knappem freiem Blockpool
|
||||
let free_len = manifest.free_blocks.len();
|
||||
let total = manifest.total_blocks;
|
||||
if total > 0 && (free_len < 20 || (free_len as f64 / total as f64) < 0.05) {
|
||||
warn!(
|
||||
"Warnung: Hidden-Vault hat nur noch {} freie Blöcke (von {}).",
|
||||
free_len, total
|
||||
);
|
||||
}
|
||||
|
||||
let now = SystemTime::now()
|
||||
@@ -417,6 +849,12 @@ impl CarrierFs {
|
||||
custom_leak_rules: Arc::new(custom_leak_rules),
|
||||
leak_counter: Arc::new(AtomicU64::new(0)),
|
||||
manifest,
|
||||
children_index,
|
||||
corrupted_pages,
|
||||
manifest_dirty: false,
|
||||
manifest_save_count: 0,
|
||||
dirty_ops_count: 0,
|
||||
last_manifest_save: now,
|
||||
last_activity: Arc::new(AtomicU64::new(now)),
|
||||
};
|
||||
|
||||
@@ -445,6 +883,46 @@ impl CarrierFs {
|
||||
)
|
||||
}
|
||||
|
||||
pub fn sync_manifest(&self) -> Result<()> {
|
||||
let mut inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
|
||||
inner.flush_manifest_if_dirty()
|
||||
}
|
||||
|
||||
pub fn manifest_save_count(&self) -> u64 {
|
||||
let inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
|
||||
inner.manifest_save_count
|
||||
}
|
||||
|
||||
pub fn is_manifest_dirty(&self) -> bool {
|
||||
let inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
|
||||
inner.manifest_dirty
|
||||
}
|
||||
|
||||
pub fn manifest_usage(&self) -> (usize, usize, f64) {
|
||||
let inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
|
||||
inner.manifest_usage()
|
||||
}
|
||||
|
||||
pub fn corrupted_pages(&self) -> usize {
|
||||
let inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
|
||||
inner.corrupted_pages
|
||||
}
|
||||
|
||||
pub fn block_stats(&self) -> (usize, u32) {
|
||||
let inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
|
||||
(inner.free_blocks_count(), inner.total_blocks_count())
|
||||
}
|
||||
|
||||
pub fn page_count(&self) -> usize {
|
||||
let inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
|
||||
inner.page_count()
|
||||
}
|
||||
|
||||
pub fn resolve_path(&self, raw_path: &str) -> Option<CarrierInode> {
|
||||
let inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
|
||||
inner.resolve_path(raw_path)
|
||||
}
|
||||
|
||||
pub fn leak_counter(&self) -> Arc<AtomicU64> {
|
||||
let inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
|
||||
inner.leak_counter.clone()
|
||||
@@ -523,12 +1001,15 @@ impl DavFileSystem for CarrierFs {
|
||||
n.size = 0;
|
||||
n.modified_at = now;
|
||||
inner.manifest.inodes.insert(n.id, n.clone());
|
||||
let _ = inner.save_manifest();
|
||||
inner.mark_dirty();
|
||||
}
|
||||
n
|
||||
}
|
||||
None => {
|
||||
if options.create || options.create_new {
|
||||
crate::pathutil::validate_node_name(file_name)
|
||||
.map_err(|_| FsError::Forbidden)?;
|
||||
|
||||
let parent = inner.resolve_path(parent_path).ok_or(FsError::NotFound)?;
|
||||
if !parent.is_dir {
|
||||
return Err(FsError::Forbidden);
|
||||
@@ -554,7 +1035,8 @@ impl DavFileSystem for CarrierFs {
|
||||
};
|
||||
|
||||
inner.manifest.inodes.insert(new_id, new_inode.clone());
|
||||
let _ = inner.save_manifest();
|
||||
inner.index_add_child(parent.id, new_id);
|
||||
inner.mark_dirty();
|
||||
new_inode
|
||||
} else {
|
||||
return Err(FsError::NotFound);
|
||||
@@ -583,11 +1065,14 @@ impl DavFileSystem for CarrierFs {
|
||||
return Err(FsError::Forbidden);
|
||||
}
|
||||
|
||||
let entries: Vec<Result<Box<dyn DavDirEntry>, FsError>> = inner
|
||||
.manifest
|
||||
.inodes
|
||||
.values()
|
||||
.filter(|child| child.parent_id == Some(node.id))
|
||||
let child_ids = inner
|
||||
.children_index
|
||||
.get(&node.id)
|
||||
.cloned()
|
||||
.unwrap_or_default();
|
||||
let entries: Vec<Result<Box<dyn DavDirEntry>, FsError>> = child_ids
|
||||
.into_iter()
|
||||
.filter_map(|cid| inner.manifest.inodes.get(&cid))
|
||||
.filter(|child| {
|
||||
if inner.is_leak(&child.name) {
|
||||
inner.leak_counter.fetch_add(1, Ordering::Relaxed);
|
||||
@@ -647,6 +1132,8 @@ impl DavFileSystem for CarrierFs {
|
||||
return Err(FsError::Forbidden);
|
||||
}
|
||||
|
||||
crate::pathutil::validate_node_name(dir_name).map_err(|_| FsError::Forbidden)?;
|
||||
|
||||
if inner.resolve_path(&path_str).is_some() {
|
||||
return Err(FsError::Exists);
|
||||
}
|
||||
@@ -676,7 +1163,8 @@ impl DavFileSystem for CarrierFs {
|
||||
};
|
||||
|
||||
inner.manifest.inodes.insert(new_id, new_dir);
|
||||
inner.save_manifest().map_err(|_| FsError::GeneralFailure)?;
|
||||
inner.index_add_child(parent.id, new_id);
|
||||
inner.mark_dirty();
|
||||
|
||||
Ok(())
|
||||
})
|
||||
@@ -697,19 +1185,22 @@ impl DavFileSystem for CarrierFs {
|
||||
return Err(FsError::Forbidden);
|
||||
}
|
||||
|
||||
// Prüfe, ob das Verzeichnis leer ist
|
||||
// Prüfe, ob das Verzeichnis leer ist (via Sekundärindex)
|
||||
let has_children = inner
|
||||
.manifest
|
||||
.inodes
|
||||
.values()
|
||||
.any(|child| child.parent_id == Some(node.id));
|
||||
.children_index
|
||||
.get(&node.id)
|
||||
.is_some_and(|children| !children.is_empty());
|
||||
|
||||
if has_children {
|
||||
return Err(FsError::Forbidden);
|
||||
}
|
||||
|
||||
if let Some(p_id) = node.parent_id {
|
||||
inner.index_remove_child(p_id, node.id);
|
||||
}
|
||||
inner.children_index.remove(&node.id);
|
||||
inner.manifest.inodes.remove(&node.id);
|
||||
inner.save_manifest().map_err(|_| FsError::GeneralFailure)?;
|
||||
inner.mark_dirty();
|
||||
|
||||
Ok(())
|
||||
})
|
||||
@@ -737,8 +1228,11 @@ impl DavFileSystem for CarrierFs {
|
||||
inner.manifest.free_blocks.push(b);
|
||||
}
|
||||
|
||||
if let Some(p_id) = node.parent_id {
|
||||
inner.index_remove_child(p_id, node.id);
|
||||
}
|
||||
inner.manifest.inodes.remove(&node.id);
|
||||
inner.save_manifest().map_err(|_| FsError::GeneralFailure)?;
|
||||
inner.mark_dirty();
|
||||
|
||||
Ok(())
|
||||
})
|
||||
@@ -759,6 +1253,8 @@ impl DavFileSystem for CarrierFs {
|
||||
return Err(FsError::Forbidden);
|
||||
}
|
||||
|
||||
crate::pathutil::validate_node_name(to_name).map_err(|_| FsError::Forbidden)?;
|
||||
|
||||
let to_parent = inner
|
||||
.resolve_path(to_parent_path)
|
||||
.ok_or(FsError::NotFound)?;
|
||||
@@ -781,6 +1277,10 @@ impl DavFileSystem for CarrierFs {
|
||||
);
|
||||
inner.manifest.free_blocks.push(b);
|
||||
}
|
||||
if let Some(p_id) = dest.parent_id {
|
||||
inner.index_remove_child(p_id, dest.id);
|
||||
}
|
||||
inner.children_index.remove(&dest.id);
|
||||
inner.manifest.inodes.remove(&dest.id);
|
||||
}
|
||||
|
||||
@@ -789,13 +1289,20 @@ impl DavFileSystem for CarrierFs {
|
||||
.map(|d| d.as_secs())
|
||||
.unwrap_or(0);
|
||||
|
||||
let old_parent_id = node.parent_id;
|
||||
let new_parent_id = to_parent.id;
|
||||
if let Some(old_p) = old_parent_id {
|
||||
inner.index_remove_child(old_p, node.id);
|
||||
}
|
||||
inner.index_add_child(new_parent_id, node.id);
|
||||
|
||||
if let Some(inode) = inner.manifest.inodes.get_mut(&node.id) {
|
||||
inode.parent_id = Some(to_parent.id);
|
||||
inode.parent_id = Some(new_parent_id);
|
||||
inode.name = to_name.to_string();
|
||||
inode.modified_at = now;
|
||||
}
|
||||
|
||||
inner.save_manifest().map_err(|_| FsError::GeneralFailure)?;
|
||||
inner.mark_dirty();
|
||||
|
||||
Ok(())
|
||||
})
|
||||
@@ -824,6 +1331,8 @@ impl DavFileSystem for CarrierFs {
|
||||
return Err(FsError::Forbidden);
|
||||
}
|
||||
|
||||
crate::pathutil::validate_node_name(to_name).map_err(|_| FsError::Forbidden)?;
|
||||
|
||||
let to_parent = inner
|
||||
.resolve_path(to_parent_path)
|
||||
.ok_or(FsError::NotFound)?;
|
||||
@@ -846,6 +1355,10 @@ impl DavFileSystem for CarrierFs {
|
||||
);
|
||||
inner.manifest.free_blocks.push(b);
|
||||
}
|
||||
if let Some(p_id) = dest.parent_id {
|
||||
inner.index_remove_child(p_id, dest.id);
|
||||
}
|
||||
inner.children_index.remove(&dest.id);
|
||||
inner.manifest.inodes.remove(&dest.id);
|
||||
}
|
||||
|
||||
@@ -924,7 +1437,8 @@ impl DavFileSystem for CarrierFs {
|
||||
};
|
||||
|
||||
inner.manifest.inodes.insert(new_id, new_inode);
|
||||
inner.save_manifest().map_err(|_| FsError::GeneralFailure)?;
|
||||
inner.index_add_child(to_parent.id, new_id);
|
||||
inner.mark_dirty();
|
||||
|
||||
Ok(())
|
||||
})
|
||||
@@ -1231,7 +1745,10 @@ impl DavFile for CarrierFile {
|
||||
inode.modified_at = now;
|
||||
}
|
||||
|
||||
inner.save_manifest().map_err(|_| FsError::GeneralFailure)?;
|
||||
inner.mark_dirty();
|
||||
inner
|
||||
.flush_manifest_if_dirty()
|
||||
.map_err(|_| FsError::GeneralFailure)?;
|
||||
|
||||
self.meta.size = self.file_size;
|
||||
self.meta.modified_at = UNIX_EPOCH + Duration::from_secs(now);
|
||||
@@ -1261,7 +1778,7 @@ impl Drop for CarrierFile {
|
||||
inode.blocks = self.blocks.clone();
|
||||
inode.modified_at = now;
|
||||
}
|
||||
let _ = inner.save_manifest();
|
||||
inner.mark_dirty();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+3
-1
@@ -25,7 +25,7 @@ use sanctum::verify::verify_container;
|
||||
#[command(about = "Sanctum: Verschlüsselter Ein-Datei-Container unter Windows im reinen Userland", long_about = None)]
|
||||
#[command(version)]
|
||||
struct Cli {
|
||||
/// Erlaubt Legacy-Namensentschlüsselung ohne deterministisches AAD (S-07)
|
||||
/// SICHERHEITSHINWEIS: Unsicher! Deaktiviert die kryptografische Bindung (AAD) von Dateinamen (Gefahr von Swap-Attacks/Manipulation). Nur zur temporären Migration alter Container verwenden!
|
||||
#[arg(long, global = true, default_value_t = false)]
|
||||
legacy_names: bool,
|
||||
|
||||
@@ -1591,6 +1591,8 @@ async fn run() -> Result<()> {
|
||||
|
||||
if cli.legacy_names {
|
||||
set_allow_legacy_names(true);
|
||||
eprintln!("WARNUNG: Das Flag '--legacy-names' ist aktiv. Die kryptografische Authentifizierung von Dateinamen ist geschwächt (Gefahr von Swap-Attacks). Verwenden Sie dieses Flag nur zur Datenmigration!");
|
||||
tracing::warn!("Flag --legacy-names ist aktiv. Authenticated Associated Data (AAD) fuer Dateinamen ist abgeschwaecht.");
|
||||
}
|
||||
|
||||
match cli.command {
|
||||
|
||||
@@ -187,6 +187,28 @@ pub async fn mount_container(
|
||||
// S-06: Advisory Lock setzen, um parallele Mounts und schreibende Sync-Läufe abzuwehren
|
||||
let _advisory_lock = db.acquire_advisory_lock_guard(false)?;
|
||||
|
||||
// K-01: Metadaten-Integrität via HMAC-SHA256 validieren (Format V3)
|
||||
if version >= crate::crypto::FORMAT_VERSION_V3 {
|
||||
match db.verify_metadata_mac_for_slot(vault_id, &dek) {
|
||||
Ok(true) => {
|
||||
if !stealth {
|
||||
println!(
|
||||
" • Metadaten-MAC: ✔ Integrität erfolgreich verifiziert (HMAC-SHA256)"
|
||||
);
|
||||
}
|
||||
}
|
||||
Ok(false) => {
|
||||
bail!(
|
||||
"Metadaten-MAC-Verifikation fehlgeschlagen: Die Container-Metadaten wurden manipuliert oder sind beschädigt (K-01)."
|
||||
);
|
||||
}
|
||||
Err(e) => {
|
||||
bail!("Fehler bei der Metadaten-MAC-Verifikation: {e}");
|
||||
}
|
||||
}
|
||||
}
|
||||
db.set_active_slot_and_dek(vault_id, dek.clone());
|
||||
|
||||
// 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);
|
||||
@@ -225,6 +247,7 @@ pub async fn mount_container(
|
||||
);
|
||||
let fs_leak_counter = fs.leak_counter();
|
||||
let last_activity = fs.last_activity();
|
||||
let fs_clone = fs.clone();
|
||||
let dav_server = DavHandler::builder()
|
||||
.filesystem(Box::new(fs))
|
||||
.locksystem(FakeLs::new())
|
||||
@@ -282,6 +305,7 @@ pub async fn mount_container(
|
||||
|
||||
// Netzlaufwerk bzw. Verzeichnis einbinden
|
||||
if let Err(e) = run_mount_command(drive_letter, bound_port, &session_token) {
|
||||
let _ = fs_clone.sync_carrier_manifest();
|
||||
let _ = shutdown_tx.send(true);
|
||||
let _ = server_handle.await;
|
||||
return Err(e);
|
||||
@@ -420,6 +444,29 @@ pub async fn mount_container(
|
||||
if enable_tray {
|
||||
println!(" • System-Tray: Icon aktiv (Rechtsklick für Explorer/Trennen)");
|
||||
}
|
||||
if vault_id == 1 {
|
||||
if let Some(corrupted) = fs_clone.carrier_corrupted_pages() {
|
||||
if corrupted > 0 {
|
||||
println!(
|
||||
" {} Warnung (D-01): {} beschädigte Inode-Tabellenseite(n) im Hidden Vault übersprungen!",
|
||||
ui::red("[!]"),
|
||||
corrupted
|
||||
);
|
||||
}
|
||||
}
|
||||
if let Some((free_blocks, total_blocks)) = fs_clone.carrier_block_stats() {
|
||||
if total_blocks > 0
|
||||
&& (free_blocks < 20 || (free_blocks as f64 / total_blocks as f64) < 0.05)
|
||||
{
|
||||
println!(
|
||||
" {} Warnung: Hidden Vault hat nur noch {} freie Blöcke (von {}).",
|
||||
ui::yellow("[!]"),
|
||||
free_blocks,
|
||||
total_blocks
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
println!();
|
||||
#[cfg(windows)]
|
||||
println!(
|
||||
@@ -541,6 +588,7 @@ pub async fn mount_container(
|
||||
}
|
||||
|
||||
if stealth {
|
||||
let _ = fs_clone.sync_carrier_manifest();
|
||||
let _ = unmount_drive(drive_letter);
|
||||
let _ = shutdown_tx.send(true);
|
||||
let _ = server_handle.await;
|
||||
@@ -555,6 +603,7 @@ pub async fn mount_container(
|
||||
#[cfg(not(windows))]
|
||||
println!("Sanctum: Container geschlossen und WebDAV-Server beendet.");
|
||||
} else {
|
||||
let _ = fs_clone.sync_carrier_manifest();
|
||||
#[cfg(windows)]
|
||||
{
|
||||
print!(
|
||||
|
||||
+528
-74
@@ -6,6 +6,7 @@ use anyhow::{bail, Result};
|
||||
use rand::rngs::OsRng;
|
||||
use rand::RngCore;
|
||||
use rusqlite::{params, Connection, OptionalExtension};
|
||||
use tracing::{error, warn};
|
||||
|
||||
use crate::crypto::{
|
||||
compute_metadata_mac, decrypt_node_name, derive_kek, derive_metadata_mac_key,
|
||||
@@ -712,8 +713,8 @@ impl Database {
|
||||
)?;
|
||||
let c_id = conn.last_insert_rowid();
|
||||
|
||||
// Berechne Blockanzahl (min. 2 Blöcke: Block 0 für Manifest, Block 1+ für Nutzdaten)
|
||||
let total_blocks = c_size.div_ceil(CHUNK_SIZE as u64).max(2) as u32;
|
||||
// Berechne Blockanzahl (min. 3 Blöcke: Block 0/1 für Superblock, Block 2 für Inode-Seite)
|
||||
let total_blocks = c_size.div_ceil(CHUNK_SIZE as u64).max(3) as u32;
|
||||
|
||||
// Slot 1 (Hidden Vault) einfügen
|
||||
let params_json_1 = serde_json::to_string(h_params)?;
|
||||
@@ -731,36 +732,139 @@ impl Database {
|
||||
],
|
||||
)?;
|
||||
|
||||
// Initialisiere CarrierManifest für Block 0
|
||||
// Initialisiere Carrier-Format V2 (Superblock auf Block 0/1, Inode-Seite auf Block 2)
|
||||
let manifest = crate::carrier::CarrierManifest::new(total_blocks);
|
||||
let manifest_bytes = serde_json::to_vec(&manifest)?;
|
||||
|
||||
let (inner_ct, inner_nonce, inner_tag) =
|
||||
crate::crypto::encrypt_chunk(dek_1, c_id, 0, &manifest_bytes, FORMAT_VERSION, 0)?;
|
||||
let inner_ct_len = inner_ct.len() as u32;
|
||||
// 1. Block 2 schreiben: Erste Inode-Tabellenseite mit Wurzelverzeichnis '/'
|
||||
let root_page = crate::carrier::CarrierInodePage {
|
||||
magic: *crate::carrier::CARRIER_PAGE_MAGIC,
|
||||
entries: manifest.inodes.values().cloned().collect(),
|
||||
};
|
||||
let root_page_bytes = serde_json::to_vec(&root_page)?;
|
||||
|
||||
let mut outer_plaintext = vec![0u8; CHUNK_SIZE];
|
||||
OsRng.fill_bytes(&mut outer_plaintext);
|
||||
let (inner_ct_2, inner_nonce_2, inner_tag_2) =
|
||||
crate::crypto::encrypt_chunk(dek_1, c_id, 2, &root_page_bytes, FORMAT_VERSION, 0)?;
|
||||
let inner_ct_len_2 = inner_ct_2.len() as u32;
|
||||
|
||||
outer_plaintext[0..12].copy_from_slice(&inner_nonce);
|
||||
outer_plaintext[12..28].copy_from_slice(&inner_tag);
|
||||
outer_plaintext[28..32].copy_from_slice(&inner_ct_len.to_le_bytes());
|
||||
let ct_end = 32 + inner_ct.len();
|
||||
if ct_end > CHUNK_SIZE {
|
||||
bail!("Manifest-Payload zu groß für Block 0");
|
||||
let mut outer_plaintext_2 = vec![0u8; CHUNK_SIZE];
|
||||
OsRng.fill_bytes(&mut outer_plaintext_2);
|
||||
|
||||
outer_plaintext_2[0..12].copy_from_slice(&inner_nonce_2);
|
||||
outer_plaintext_2[12..28].copy_from_slice(&inner_tag_2);
|
||||
outer_plaintext_2[28..32].copy_from_slice(&inner_ct_len_2.to_le_bytes());
|
||||
let ct_end_2 = 32 + inner_ct_2.len();
|
||||
if ct_end_2 > CHUNK_SIZE {
|
||||
bail!("Inode-Page-Payload zu groß für Block 2");
|
||||
}
|
||||
outer_plaintext[32..ct_end].copy_from_slice(&inner_ct);
|
||||
outer_plaintext_2[32..ct_end_2].copy_from_slice(&inner_ct_2);
|
||||
|
||||
let (outer_ct, outer_nonce, outer_tag) =
|
||||
crate::crypto::encrypt_chunk(dek_0, c_id, 0, &outer_plaintext, FORMAT_VERSION, 0)?;
|
||||
let (outer_ct_2, outer_nonce_2, outer_tag_2) = crate::crypto::encrypt_chunk(
|
||||
dek_0,
|
||||
c_id,
|
||||
2,
|
||||
&outer_plaintext_2,
|
||||
FORMAT_VERSION,
|
||||
0,
|
||||
)?;
|
||||
|
||||
conn.execute(
|
||||
"INSERT INTO chunks (node_id, chunk_index, generation, nonce, tag, ciphertext)
|
||||
VALUES (?1, 2, 0, ?2, ?3, ?4)",
|
||||
params![
|
||||
c_id,
|
||||
outer_nonce_2.as_slice(),
|
||||
outer_tag_2.as_slice(),
|
||||
outer_ct_2
|
||||
],
|
||||
)?;
|
||||
|
||||
// 2. Superblock (Block 0 & 1, redundante Zweitkopie C-02, Format V2)
|
||||
let superblock = crate::carrier::CarrierSuperblock {
|
||||
magic: *crate::carrier::CARRIER_MAGIC,
|
||||
version: crate::carrier::CARRIER_VERSION_V2,
|
||||
manifest_generation: 0,
|
||||
total_blocks,
|
||||
free_blocks: manifest.free_blocks.clone(),
|
||||
next_inode_id: manifest.next_inode_id,
|
||||
page_block_indices: vec![2],
|
||||
};
|
||||
let sb_bytes = serde_json::to_vec(&superblock)?;
|
||||
|
||||
// Block 0 schreiben (Primärkopie)
|
||||
let (inner_ct_0, inner_nonce_0, inner_tag_0) =
|
||||
crate::crypto::encrypt_chunk(dek_1, c_id, 0, &sb_bytes, FORMAT_VERSION, 0)?;
|
||||
let inner_ct_len_0 = inner_ct_0.len() as u32;
|
||||
|
||||
let mut outer_plaintext_0 = vec![0u8; CHUNK_SIZE];
|
||||
OsRng.fill_bytes(&mut outer_plaintext_0);
|
||||
|
||||
outer_plaintext_0[0..12].copy_from_slice(&inner_nonce_0);
|
||||
outer_plaintext_0[12..28].copy_from_slice(&inner_tag_0);
|
||||
outer_plaintext_0[28..32].copy_from_slice(&inner_ct_len_0.to_le_bytes());
|
||||
let ct_end_0 = 32 + inner_ct_0.len();
|
||||
if ct_end_0 > CHUNK_SIZE {
|
||||
bail!("Superblock-Payload zu groß für Block 0");
|
||||
}
|
||||
outer_plaintext_0[32..ct_end_0].copy_from_slice(&inner_ct_0);
|
||||
|
||||
let (outer_ct_0, outer_nonce_0, outer_tag_0) = crate::crypto::encrypt_chunk(
|
||||
dek_0,
|
||||
c_id,
|
||||
0,
|
||||
&outer_plaintext_0,
|
||||
FORMAT_VERSION,
|
||||
0,
|
||||
)?;
|
||||
|
||||
conn.execute(
|
||||
"INSERT INTO chunks (node_id, chunk_index, generation, nonce, tag, ciphertext)
|
||||
VALUES (?1, 0, 0, ?2, ?3, ?4)",
|
||||
params![c_id, outer_nonce.as_slice(), outer_tag.as_slice(), outer_ct],
|
||||
params![
|
||||
c_id,
|
||||
outer_nonce_0.as_slice(),
|
||||
outer_tag_0.as_slice(),
|
||||
outer_ct_0
|
||||
],
|
||||
)?;
|
||||
|
||||
// Blöcke 1..total_blocks-1 mit DEK_0 vorallokieren
|
||||
// Block 1 schreiben (Redundante Zweitkopie, C-02)
|
||||
let (inner_ct_1, inner_nonce_1, inner_tag_1) =
|
||||
crate::crypto::encrypt_chunk(dek_1, c_id, 1, &sb_bytes, FORMAT_VERSION, 0)?;
|
||||
let inner_ct_len_1 = inner_ct_1.len() as u32;
|
||||
|
||||
let mut outer_plaintext_1 = vec![0u8; CHUNK_SIZE];
|
||||
OsRng.fill_bytes(&mut outer_plaintext_1);
|
||||
|
||||
outer_plaintext_1[0..12].copy_from_slice(&inner_nonce_1);
|
||||
outer_plaintext_1[12..28].copy_from_slice(&inner_tag_1);
|
||||
outer_plaintext_1[28..32].copy_from_slice(&inner_ct_len_1.to_le_bytes());
|
||||
let ct_end_1 = 32 + inner_ct_1.len();
|
||||
if ct_end_1 > CHUNK_SIZE {
|
||||
bail!("Superblock-Payload zu groß für Block 1");
|
||||
}
|
||||
outer_plaintext_1[32..ct_end_1].copy_from_slice(&inner_ct_1);
|
||||
|
||||
let (outer_ct_1, outer_nonce_1, outer_tag_1) = crate::crypto::encrypt_chunk(
|
||||
dek_0,
|
||||
c_id,
|
||||
1,
|
||||
&outer_plaintext_1,
|
||||
FORMAT_VERSION,
|
||||
0,
|
||||
)?;
|
||||
|
||||
conn.execute(
|
||||
"INSERT INTO chunks (node_id, chunk_index, generation, nonce, tag, ciphertext)
|
||||
VALUES (?1, 1, 0, ?2, ?3, ?4)",
|
||||
params![
|
||||
c_id,
|
||||
outer_nonce_1.as_slice(),
|
||||
outer_tag_1.as_slice(),
|
||||
outer_ct_1
|
||||
],
|
||||
)?;
|
||||
|
||||
// 3. Blöcke 3..total_blocks-1 mit DEK_0 vorallokieren
|
||||
let mut chunk_stmt = conn.prepare(
|
||||
"INSERT INTO chunks (node_id, chunk_index, generation, nonce, tag, ciphertext)
|
||||
VALUES (?1, ?2, 0, ?3, ?4, ?5)",
|
||||
@@ -770,7 +874,7 @@ impl Database {
|
||||
OsRng.fill_bytes(&mut dummy_noise);
|
||||
|
||||
conn.execute_batch("BEGIN TRANSACTION;")?;
|
||||
for b in 1..total_blocks {
|
||||
for b in 3..total_blocks {
|
||||
let (ct, nonce, tag) =
|
||||
crate::crypto::encrypt_chunk(dek_0, c_id, b, &dummy_noise, FORMAT_VERSION, 0)?;
|
||||
chunk_stmt.execute(params![c_id, b, nonce.as_slice(), tag.as_slice(), ct,])?;
|
||||
@@ -1384,8 +1488,16 @@ impl Database {
|
||||
let mut matched_record = None;
|
||||
for r in rows {
|
||||
let (id, p_id, enc_name, is_dir, size, c_at, m_at) = r?;
|
||||
let dec_name =
|
||||
decrypt_node_name(dek, p_id.unwrap_or(0), &enc_name).unwrap_or(enc_name);
|
||||
let dec_name = match decrypt_node_name(dek, p_id.unwrap_or(0), &enc_name) {
|
||||
Some(name) => name,
|
||||
None => {
|
||||
warn!(
|
||||
"Knoten {} in Pfadauflösung übersprungen: Name konnte nicht entschlüsselt werden (ST-01)",
|
||||
id
|
||||
);
|
||||
continue;
|
||||
}
|
||||
};
|
||||
if dec_name == *segment {
|
||||
matched_record = Some(NodeRecord {
|
||||
id,
|
||||
@@ -1433,29 +1545,49 @@ impl Database {
|
||||
FROM nodes WHERE id = ?1",
|
||||
)?;
|
||||
|
||||
let record = stmt
|
||||
let raw = stmt
|
||||
.query_row(params![id], |row| {
|
||||
let enc_name: String = row.get(2)?;
|
||||
let p_id: Option<i64> = row.get(1)?;
|
||||
let name = if vault_id == 1 {
|
||||
decrypt_node_name(dek, p_id.unwrap_or(0), &enc_name).unwrap_or(enc_name)
|
||||
Ok((
|
||||
row.get::<_, i64>(0)?,
|
||||
row.get::<_, Option<i64>>(1)?,
|
||||
row.get::<_, String>(2)?,
|
||||
row.get::<_, i32>(3)? != 0,
|
||||
row.get::<_, i64>(4)? as u64,
|
||||
row.get::<_, i64>(5)? as u64,
|
||||
row.get::<_, i64>(6)? as u64,
|
||||
))
|
||||
})
|
||||
.optional()?;
|
||||
|
||||
match raw {
|
||||
Some((id, parent_id, enc_name, is_dir, size, created_at, modified_at)) => {
|
||||
let name = if vault_id == 1 && parent_id.is_some() {
|
||||
match decrypt_node_name(dek, parent_id.unwrap_or(0), &enc_name) {
|
||||
Some(dec) => dec,
|
||||
None => {
|
||||
warn!(
|
||||
"Knoten {} kann nicht geladen werden: Name konnte nicht entschlüsselt werden (ST-01)",
|
||||
id
|
||||
);
|
||||
return Ok(None);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
enc_name
|
||||
};
|
||||
|
||||
Ok(NodeRecord {
|
||||
id: row.get(0)?,
|
||||
parent_id: row.get(1)?,
|
||||
Ok(Some(NodeRecord {
|
||||
id,
|
||||
parent_id,
|
||||
name,
|
||||
is_dir: row.get::<_, i32>(3)? != 0,
|
||||
size: row.get::<_, i64>(4)? as u64,
|
||||
created_at: row.get::<_, i64>(5)? as u64,
|
||||
modified_at: row.get::<_, i64>(6)? as u64,
|
||||
})
|
||||
})
|
||||
.optional()?;
|
||||
|
||||
Ok(record)
|
||||
is_dir,
|
||||
size,
|
||||
created_at,
|
||||
modified_at,
|
||||
}))
|
||||
}
|
||||
None => Ok(None),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_node_by_id(&self, id: i64) -> Result<Option<NodeRecord>> {
|
||||
@@ -1478,27 +1610,44 @@ impl Database {
|
||||
)?;
|
||||
|
||||
let rows = stmt.query_map(params![parent_id], |row| {
|
||||
let enc_name: String = row.get(2)?;
|
||||
let name = if vault_id == 1 {
|
||||
decrypt_node_name(dek, parent_id, &enc_name).unwrap_or(enc_name)
|
||||
} else {
|
||||
enc_name
|
||||
};
|
||||
|
||||
Ok(NodeRecord {
|
||||
id: row.get(0)?,
|
||||
parent_id: row.get(1)?,
|
||||
name,
|
||||
is_dir: row.get::<_, i32>(3)? != 0,
|
||||
size: row.get::<_, i64>(4)? as u64,
|
||||
created_at: row.get::<_, i64>(5)? as u64,
|
||||
modified_at: row.get::<_, i64>(6)? as u64,
|
||||
})
|
||||
Ok((
|
||||
row.get::<_, i64>(0)?,
|
||||
row.get::<_, Option<i64>>(1)?,
|
||||
row.get::<_, String>(2)?,
|
||||
row.get::<_, i32>(3)? != 0,
|
||||
row.get::<_, i64>(4)? as u64,
|
||||
row.get::<_, i64>(5)? as u64,
|
||||
row.get::<_, i64>(6)? as u64,
|
||||
))
|
||||
})?;
|
||||
|
||||
let mut entries = Vec::new();
|
||||
for r in rows {
|
||||
entries.push(r?);
|
||||
let (id, p_id, enc_name, is_dir, size, created_at, modified_at) = r?;
|
||||
let name = if vault_id == 1 {
|
||||
match decrypt_node_name(dek, parent_id, &enc_name) {
|
||||
Some(dec) => dec,
|
||||
None => {
|
||||
warn!(
|
||||
"Knoten {} in Verzeichnisauflistung übersprungen: Name konnte nicht entschlüsselt werden (ST-01)",
|
||||
id
|
||||
);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
enc_name
|
||||
};
|
||||
|
||||
entries.push(NodeRecord {
|
||||
id,
|
||||
parent_id: p_id,
|
||||
name,
|
||||
is_dir,
|
||||
size,
|
||||
created_at,
|
||||
modified_at,
|
||||
});
|
||||
}
|
||||
Ok(entries)
|
||||
}
|
||||
@@ -1586,24 +1735,54 @@ impl Database {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Löscht einen Knoten und shreddert alle assoziierten Chunks atomar.
|
||||
pub fn delete_node(&self, id: i64) -> Result<()> {
|
||||
self.assert_not_carrier(id)?;
|
||||
|
||||
// Verhindere auch das Löschen eines Verzeichnisses, das die Trägerdatei enthält
|
||||
if let Ok(Some(carrier_id)) = self.find_carrier_node_id() {
|
||||
if self.is_descendant_of(carrier_id, id).unwrap_or(false) {
|
||||
bail!("Verzeichnis enthält die Trägerdatei (Node-ID {}) und darf nicht gelöscht werden.", carrier_id);
|
||||
fn delete_subtree_tx(
|
||||
tx: &rusqlite::Transaction<'_>,
|
||||
id: i64,
|
||||
carrier_id: Option<i64>,
|
||||
) -> Result<()> {
|
||||
if let Some(cid) = carrier_id {
|
||||
if id == cid {
|
||||
bail!(
|
||||
"Operation auf Alibi-Trägerdatei (Carrier, Node-ID {}) ist strikt untersagt.",
|
||||
id
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// 1. Shredde Chunks dieses Knotens mit kryptografischem Zufallsrauschen
|
||||
let _ = self.shred_chunks_for_node(id);
|
||||
// 1. Chunks für diesen Knoten kryptografisch shreddern
|
||||
{
|
||||
let mut stmt = tx
|
||||
.prepare("SELECT chunk_index, length(ciphertext) FROM chunks WHERE node_id = ?1")?;
|
||||
let chunks: Vec<(u32, usize)> = stmt
|
||||
.query_map(params![id], |row| Ok((row.get(0)?, row.get(1)?)))?
|
||||
.filter_map(|r| r.ok())
|
||||
.collect();
|
||||
|
||||
// 2. Shredde auch rekursiv alle Unterknoten
|
||||
let mut update_stmt = tx.prepare(
|
||||
"UPDATE chunks SET nonce = ?1, tag = ?2, ciphertext = ?3, generation = 0 WHERE node_id = ?4 AND chunk_index = ?5",
|
||||
)?;
|
||||
|
||||
for (chunk_idx, ct_len) in chunks {
|
||||
let mut noise = vec![0u8; ct_len];
|
||||
let mut nonce_noise = [0u8; 12];
|
||||
let mut tag_noise = [0u8; 16];
|
||||
OsRng.fill_bytes(&mut noise);
|
||||
OsRng.fill_bytes(&mut nonce_noise);
|
||||
OsRng.fill_bytes(&mut tag_noise);
|
||||
|
||||
let _ = update_stmt.execute(params![
|
||||
nonce_noise.as_slice(),
|
||||
tag_noise.as_slice(),
|
||||
noise,
|
||||
id,
|
||||
chunk_idx
|
||||
]);
|
||||
}
|
||||
}
|
||||
|
||||
// 2. Kindknoten ermitteln und rekursiv innerhalb derselben Transaktion löschen
|
||||
let child_ids: Vec<i64> = {
|
||||
let conn = self.conn();
|
||||
let mut stmt = conn.prepare("SELECT id FROM nodes WHERE parent_id = ?1")?;
|
||||
let mut stmt = tx.prepare("SELECT id FROM nodes WHERE parent_id = ?1")?;
|
||||
let ids = stmt
|
||||
.query_map(params![id], |row| row.get(0))?
|
||||
.filter_map(|r| r.ok())
|
||||
@@ -1611,14 +1790,47 @@ impl Database {
|
||||
ids
|
||||
};
|
||||
|
||||
let mut errors = Vec::new();
|
||||
for child_id in child_ids {
|
||||
let _ = self.delete_node(child_id);
|
||||
if let Err(e) = Self::delete_subtree_tx(tx, child_id, carrier_id) {
|
||||
error!("Konnte Kindknoten {} nicht löschen: {e}", child_id);
|
||||
errors.push(e);
|
||||
}
|
||||
}
|
||||
if !errors.is_empty() {
|
||||
bail!(
|
||||
"Fehler beim rekursiven Löschen: {} Kindknoten konnten nicht gelöscht werden (ST-02)",
|
||||
errors.len()
|
||||
);
|
||||
}
|
||||
|
||||
let conn = self.conn();
|
||||
conn.execute("DELETE FROM chunks WHERE node_id = ?1", params![id])?;
|
||||
conn.execute("DELETE FROM nodes WHERE id = ?1", params![id])?;
|
||||
// 3. Chunks und Knoten aus der Datenbank löschen
|
||||
tx.execute("DELETE FROM chunks WHERE node_id = ?1", params![id])?;
|
||||
tx.execute("DELETE FROM nodes WHERE id = ?1", params![id])?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Löscht einen Knoten und shreddert alle assoziierten Chunks atomar in einer SQLite-Transaktion (ST-03).
|
||||
pub fn delete_node(&self, id: i64) -> Result<()> {
|
||||
self.assert_not_carrier(id)?;
|
||||
|
||||
// Verhindere auch das Löschen eines Verzeichnisses, das die Trägerdatei enthält
|
||||
let carrier_id = self.find_carrier_node_id().ok().flatten();
|
||||
if let Some(cid) = carrier_id {
|
||||
if self.is_descendant_of(cid, id).unwrap_or(false) {
|
||||
bail!(
|
||||
"Verzeichnis enthält die Trägerdatei (Node-ID {}) und darf nicht gelöscht werden.",
|
||||
cid
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
let mut conn = self.conn();
|
||||
let tx = conn.transaction()?;
|
||||
Self::delete_subtree_tx(&tx, id, carrier_id)?;
|
||||
tx.commit()?;
|
||||
drop(conn);
|
||||
|
||||
let _ = self.update_metadata_mac();
|
||||
Ok(())
|
||||
}
|
||||
@@ -2923,4 +3135,246 @@ mod tests {
|
||||
assert!(read_dek.is_some());
|
||||
assert_eq!(read_dek.unwrap()[0], 42);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_st01_fail_closed_name_decryption_no_hex_leak() {
|
||||
let db = Database::open_in_memory().unwrap();
|
||||
let (salt0, kdf0) = ([1u8; 16], KdfParams::default());
|
||||
let (salt1, kdf1) = ([2u8; 16], KdfParams::default());
|
||||
let (dek0, dek1) = ([10u8; 32], [20u8; 32]);
|
||||
let carrier_name = "backup.iso";
|
||||
let carrier_size = 5 * 1024 * 1024;
|
||||
|
||||
db.init_schema_with_carrier(
|
||||
&salt0,
|
||||
&kdf0,
|
||||
&[0u8; 40],
|
||||
&[0u8; 12],
|
||||
&[0u8; 16],
|
||||
Some((
|
||||
carrier_name,
|
||||
carrier_size,
|
||||
&salt1,
|
||||
&kdf1,
|
||||
&[1u8; 40],
|
||||
&[1u8; 12],
|
||||
&[1u8; 16],
|
||||
&dek0,
|
||||
&dek1,
|
||||
)),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let root1 = db.resolve_path_in_vault("/", 1, &dek1).unwrap().unwrap();
|
||||
assert_eq!(root1.id, 2);
|
||||
|
||||
// 1. Zwei Dateien in Vault 1 anlegen
|
||||
let node_valid = db
|
||||
.create_node_in_vault(1, root1.id, "secret_valid.txt", false, &dek1)
|
||||
.unwrap();
|
||||
let node_corrupt = db
|
||||
.create_node_in_vault(1, root1.id, "secret_corrupt.txt", false, &dek1)
|
||||
.unwrap();
|
||||
|
||||
// 2. Vor Korruption: Beide Dateien sichtbar
|
||||
let children_before = db.list_children_in_vault(root1.id, 1, &dek1).unwrap();
|
||||
assert_eq!(children_before.len(), 2);
|
||||
|
||||
// 3. Simuliere Bitrot / Manipulation: Überschreibe den verschlüsselten Namen in der DB
|
||||
{
|
||||
let conn = db.conn();
|
||||
conn.execute(
|
||||
"UPDATE nodes SET name = 'deadbeef_invalid_ciphertext_without_valid_tag' WHERE id = ?1",
|
||||
params![node_corrupt.id],
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
// 4. ST-01 Prüfungen (Fail-Closed):
|
||||
// a) list_children_in_vault filtert den korrupten Knoten heraus
|
||||
let children_after = db.list_children_in_vault(root1.id, 1, &dek1).unwrap();
|
||||
assert_eq!(
|
||||
children_after.len(),
|
||||
1,
|
||||
"ST-01: Korrupter Knoten muss aus der Liste herausgefiltert werden"
|
||||
);
|
||||
assert_eq!(children_after[0].id, node_valid.id);
|
||||
assert_eq!(children_after[0].name, "secret_valid.txt");
|
||||
assert!(
|
||||
!children_after.iter().any(|c| c.name.contains("deadbeef")),
|
||||
"Kein Hex-Ciphertext-Leak"
|
||||
);
|
||||
|
||||
// b) resolve_path_in_vault gibt None zurück (nicht den Hex-Namen)
|
||||
let resolved = db
|
||||
.resolve_path_in_vault("/secret_corrupt.txt", 1, &dek1)
|
||||
.unwrap();
|
||||
assert!(
|
||||
resolved.is_none(),
|
||||
"ST-01: Pfad mit korruptem Namen darf nicht aufgelöst werden"
|
||||
);
|
||||
|
||||
// c) get_node_by_id_in_vault gibt None zurück (fail-closed statt Hex-String)
|
||||
let by_id = db
|
||||
.get_node_by_id_in_vault(node_corrupt.id, 1, &dek1)
|
||||
.unwrap();
|
||||
assert!(
|
||||
by_id.is_none(),
|
||||
"ST-01: get_node_by_id_in_vault muss None zurückgeben, wenn Name unlesbar ist"
|
||||
);
|
||||
|
||||
// d) Gültiger Knoten kann normal geladen werden
|
||||
let valid_by_id = db.get_node_by_id_in_vault(node_valid.id, 1, &dek1).unwrap();
|
||||
assert!(valid_by_id.is_some());
|
||||
assert_eq!(valid_by_id.unwrap().name, "secret_valid.txt");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_st02_recursive_delete_error_propagation_not_swallowed() {
|
||||
let db = Database::open_in_memory().unwrap();
|
||||
let (salt, kdf, wrapped_dek, nonce, tag) = (
|
||||
[1u8; 16],
|
||||
KdfParams::default(),
|
||||
vec![2u8; 40],
|
||||
[3u8; 12],
|
||||
[4u8; 16],
|
||||
);
|
||||
db.init_schema(&salt, &kdf, &wrapped_dek, &nonce, &tag)
|
||||
.unwrap();
|
||||
|
||||
// Verzeichnisstruktur erstellen:
|
||||
// /parent (id=3)
|
||||
// /parent/normal.txt (id=4)
|
||||
// /parent/protected.txt (id=5)
|
||||
let parent = db.create_node(1, "parent", true).unwrap();
|
||||
let _child_normal = db.create_node(parent.id, "normal.txt", false).unwrap();
|
||||
let _child_protected = db.create_node(parent.id, "protected.txt", false).unwrap();
|
||||
|
||||
// SQLite-Trigger einrichten, der das Löschen von 'protected.txt' blockiert
|
||||
{
|
||||
let conn = db.conn();
|
||||
conn.execute(
|
||||
"CREATE TRIGGER block_delete_protected BEFORE DELETE ON nodes
|
||||
WHEN OLD.name = 'protected.txt'
|
||||
BEGIN
|
||||
SELECT RAISE(FAIL, 'Löschen von protected.txt blockiert');
|
||||
END;",
|
||||
[],
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
// ST-02: delete_node(parent.id) darf den Fehler nicht mehr mit `let _ =` verschlucken!
|
||||
let res = db.delete_node(parent.id);
|
||||
assert!(
|
||||
res.is_err(),
|
||||
"Löschen muss fehlschlagen, wenn ein Kindknoten nicht gelöscht werden kann"
|
||||
);
|
||||
let err_msg = res.unwrap_err().to_string();
|
||||
assert!(
|
||||
err_msg.contains(
|
||||
"Fehler beim rekursiven Löschen: 1 Kindknoten konnten nicht gelöscht werden"
|
||||
),
|
||||
"Fehlermeldung muss die Anzahl fehlgeschlagener Kindknoten exakt ausweisen: {}",
|
||||
err_msg
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_st03_recursive_delete_transaction_rollback() {
|
||||
let db = Database::open_in_memory().unwrap();
|
||||
let (salt, kdf, wrapped_dek, nonce, tag) = (
|
||||
[1u8; 16],
|
||||
KdfParams::default(),
|
||||
vec![2u8; 40],
|
||||
[3u8; 12],
|
||||
[4u8; 16],
|
||||
);
|
||||
db.init_schema(&salt, &kdf, &wrapped_dek, &nonce, &tag)
|
||||
.unwrap();
|
||||
|
||||
// 1. Ordner mit zwei Dateien anlegen
|
||||
let folder = db.create_node(1, "folder", true).unwrap();
|
||||
let file1 = db.create_node(folder.id, "file1.txt", false).unwrap();
|
||||
let file2 = db.create_node(folder.id, "file2.txt", false).unwrap();
|
||||
|
||||
// Chunks für file1 und file2 anlegen
|
||||
let chunk_data = vec![0x42u8; 1024];
|
||||
let nonce = [1u8; 12];
|
||||
let tag = [2u8; 16];
|
||||
db.write_chunk(file1.id, 0, 1, &nonce, &tag, &chunk_data)
|
||||
.unwrap();
|
||||
db.write_chunk(file2.id, 0, 1, &nonce, &tag, &chunk_data)
|
||||
.unwrap();
|
||||
|
||||
// 2. Trigger erstellen, der Löschen von file2 verhindert
|
||||
{
|
||||
let conn = db.conn();
|
||||
conn.execute(
|
||||
"CREATE TRIGGER prevent_del_file2 BEFORE DELETE ON nodes
|
||||
WHEN OLD.name = 'file2.txt'
|
||||
BEGIN
|
||||
SELECT RAISE(FAIL, 'file2 ist schreibgeschützt');
|
||||
END;",
|
||||
[],
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
// 3. Löschen des gesamten Ordners aufrufen -> schlägt fehl
|
||||
let res = db.delete_node(folder.id);
|
||||
assert!(res.is_err(), "delete_node muss fehlschlagen");
|
||||
|
||||
// 4. ST-03 Atomaritätsprüfung (Rollback):
|
||||
// Weder folder noch file1 noch file2 dürfen gelöscht worden sein!
|
||||
assert!(
|
||||
db.get_node_by_id(folder.id).unwrap().is_some(),
|
||||
"Folder darf nach Rollback nicht gelöscht sein"
|
||||
);
|
||||
assert!(
|
||||
db.get_node_by_id(file1.id).unwrap().is_some(),
|
||||
"file1 darf nach Rollback nicht gelöscht sein"
|
||||
);
|
||||
assert!(
|
||||
db.get_node_by_id(file2.id).unwrap().is_some(),
|
||||
"file2 darf nach Rollback nicht gelöscht sein"
|
||||
);
|
||||
|
||||
// Chunk von file1 muss unversehrt existieren
|
||||
let chunk1 = db.read_chunk(file1.id, 0).unwrap();
|
||||
assert!(
|
||||
chunk1.is_some(),
|
||||
"Chunk von file1 darf nach Rollback nicht gelöscht sein"
|
||||
);
|
||||
assert_eq!(
|
||||
chunk1.unwrap().ciphertext,
|
||||
chunk_data,
|
||||
"Chunk von file1 muss unversehrt sein"
|
||||
);
|
||||
|
||||
// 5. Trigger entfernen und erneut löschen -> muss jetzt vollständig gelingen
|
||||
{
|
||||
let conn = db.conn();
|
||||
conn.execute("DROP TRIGGER prevent_del_file2", []).unwrap();
|
||||
}
|
||||
db.delete_node(folder.id)
|
||||
.expect("delete_node nach Trigger-Entfernung muss gelingen");
|
||||
|
||||
assert!(
|
||||
db.get_node_by_id(folder.id).unwrap().is_none(),
|
||||
"Folder muss gelöscht sein"
|
||||
);
|
||||
assert!(
|
||||
db.get_node_by_id(file1.id).unwrap().is_none(),
|
||||
"file1 muss gelöscht sein"
|
||||
);
|
||||
assert!(
|
||||
db.get_node_by_id(file2.id).unwrap().is_none(),
|
||||
"file2 muss gelöscht sein"
|
||||
);
|
||||
assert!(
|
||||
db.read_chunk(file1.id, 0).unwrap().is_none(),
|
||||
"Chunk von file1 muss gelöscht sein"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
+26
@@ -788,6 +788,29 @@ impl SanctumFs {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn sync_carrier_manifest(&self) -> Result<()> {
|
||||
if let Some(ref cfs) = self.carrier_fs {
|
||||
cfs.sync_manifest()?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn carrier_manifest_usage(&self) -> Option<(usize, usize, f64)> {
|
||||
self.carrier_fs.as_ref().map(|cfs| cfs.manifest_usage())
|
||||
}
|
||||
|
||||
pub fn carrier_corrupted_pages(&self) -> Option<usize> {
|
||||
self.carrier_fs.as_ref().map(|cfs| cfs.corrupted_pages())
|
||||
}
|
||||
|
||||
pub fn carrier_block_stats(&self) -> Option<(usize, u32)> {
|
||||
self.carrier_fs.as_ref().map(|cfs| cfs.block_stats())
|
||||
}
|
||||
|
||||
pub fn carrier_page_count(&self) -> Option<usize> {
|
||||
self.carrier_fs.as_ref().map(|cfs| cfs.page_count())
|
||||
}
|
||||
|
||||
pub fn leak_count(&self) -> u64 {
|
||||
self.leak_counter().load(Ordering::Relaxed)
|
||||
}
|
||||
@@ -1222,6 +1245,9 @@ impl DavFileSystem for SanctumFs {
|
||||
return Err(FsError::Forbidden);
|
||||
}
|
||||
|
||||
validate_path_safety(to_name)?;
|
||||
crate::pathutil::validate_node_name(to_name).map_err(|_| FsError::Forbidden)?;
|
||||
|
||||
let to_parent = self
|
||||
.resolve_path(to_parent_path)?
|
||||
.ok_or(FsError::NotFound)?;
|
||||
|
||||
@@ -923,3 +923,541 @@ fn test_m05_deniability_schema_equality_standard_vs_hidden() {
|
||||
let _ = std::fs::remove_file(&path_std);
|
||||
let _ = std::fs::remove_file(&path_hidden);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_c02_dual_block_rolling_manifest_redundancy_and_recovery() {
|
||||
let path = temp_db_path("c02_rolling_manifest");
|
||||
let carrier_size_bytes = 10 * 1024 * 1024;
|
||||
let carrier_name = "test_rolling.dat";
|
||||
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");
|
||||
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 cfs = sanctum::carrier::CarrierFs::load(
|
||||
db.clone(),
|
||||
carrier_node_id,
|
||||
std::sync::Arc::new(auth_hidden.carrier_dek().unwrap().clone()),
|
||||
std::sync::Arc::new(auth_hidden.dek().clone()),
|
||||
auth_hidden.version(),
|
||||
true,
|
||||
)
|
||||
.expect("Initial load of dual-block manifest");
|
||||
|
||||
// Datei anlegen -> save_manifest() -> Gen 1 -> schreibt Block 1
|
||||
let file1_path = DavPath::new("/file_gen1.txt").unwrap();
|
||||
let open_write = OpenOptions {
|
||||
create_new: true,
|
||||
write: true,
|
||||
..Default::default()
|
||||
};
|
||||
let mut file1 = cfs
|
||||
.open(&file1_path, open_write)
|
||||
.await
|
||||
.expect("Create file1");
|
||||
file1
|
||||
.write_bytes(Bytes::from_static(b"generation 1 content"))
|
||||
.await
|
||||
.unwrap();
|
||||
file1.flush().await.unwrap();
|
||||
drop(file1);
|
||||
drop(cfs);
|
||||
|
||||
// Verifiziere: Block 1 hat jetzt Gen 1
|
||||
let cfs_reloaded = sanctum::carrier::CarrierFs::load(
|
||||
db.clone(),
|
||||
carrier_node_id,
|
||||
std::sync::Arc::new(auth_hidden.carrier_dek().unwrap().clone()),
|
||||
std::sync::Arc::new(auth_hidden.dek().clone()),
|
||||
auth_hidden.version(),
|
||||
true,
|
||||
)
|
||||
.expect("Reload higher generation from block 1");
|
||||
|
||||
// Zweite Datei anlegen -> save_manifest() -> Gen 2 -> schreibt Block 0
|
||||
let file2_path = DavPath::new("/file_gen2.txt").unwrap();
|
||||
let open_write2 = OpenOptions {
|
||||
create_new: true,
|
||||
write: true,
|
||||
..Default::default()
|
||||
};
|
||||
let mut file2 = cfs_reloaded
|
||||
.open(&file2_path, open_write2)
|
||||
.await
|
||||
.expect("Create file2");
|
||||
file2
|
||||
.write_bytes(Bytes::from_static(b"generation 2 content"))
|
||||
.await
|
||||
.unwrap();
|
||||
file2.flush().await.unwrap();
|
||||
drop(file2);
|
||||
drop(cfs_reloaded);
|
||||
|
||||
// 2. Simuliere Bitrot auf Block 0 (gezielt mit Rauschen überschreiben)
|
||||
{
|
||||
let conn = rusqlite::Connection::open(&path).unwrap();
|
||||
let mut noise = vec![0u8; 100];
|
||||
OsRng.fill_bytes(&mut noise);
|
||||
conn.execute(
|
||||
"UPDATE chunks SET ciphertext = ?1 WHERE node_id = ?2 AND chunk_index = 0",
|
||||
rusqlite::params![noise, carrier_node_id],
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
// Laden MUSS über Block 1 gelingen (Failover-Schutz)
|
||||
let cfs_recovered_from_b1 = sanctum::carrier::CarrierFs::load(
|
||||
db.clone(),
|
||||
carrier_node_id,
|
||||
std::sync::Arc::new(auth_hidden.carrier_dek().unwrap().clone()),
|
||||
std::sync::Arc::new(auth_hidden.dek().clone()),
|
||||
auth_hidden.version(),
|
||||
true,
|
||||
)
|
||||
.expect("Recovery from Block 1 must succeed despite damaged Block 0");
|
||||
|
||||
assert!(cfs_recovered_from_b1.metadata(&file1_path).await.is_ok());
|
||||
drop(cfs_recovered_from_b1);
|
||||
|
||||
// 3. Simuliere Beschädigung von Block 1, während Block 0 intakt ist
|
||||
let cfs_repair = sanctum::carrier::CarrierFs::load(
|
||||
db.clone(),
|
||||
carrier_node_id,
|
||||
std::sync::Arc::new(auth_hidden.carrier_dek().unwrap().clone()),
|
||||
std::sync::Arc::new(auth_hidden.dek().clone()),
|
||||
auth_hidden.version(),
|
||||
true,
|
||||
)
|
||||
.unwrap();
|
||||
let file3_path = DavPath::new("/file_gen3.txt").unwrap();
|
||||
let mut file3 = cfs_repair
|
||||
.open(
|
||||
&file3_path,
|
||||
OpenOptions {
|
||||
create_new: true,
|
||||
write: true,
|
||||
..Default::default()
|
||||
},
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
file3
|
||||
.write_bytes(Bytes::from_static(b"gen 3"))
|
||||
.await
|
||||
.unwrap();
|
||||
file3.flush().await.unwrap();
|
||||
drop(file3);
|
||||
drop(cfs_repair);
|
||||
|
||||
// Jetzt Block 1 beschädigen
|
||||
{
|
||||
let conn = rusqlite::Connection::open(&path).unwrap();
|
||||
let mut noise = vec![0u8; 100];
|
||||
OsRng.fill_bytes(&mut noise);
|
||||
conn.execute(
|
||||
"UPDATE chunks SET ciphertext = ?1 WHERE node_id = ?2 AND chunk_index = 1",
|
||||
rusqlite::params![noise, carrier_node_id],
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
// Laden MUSS über Block 0 gelingen
|
||||
let cfs_recovered_from_b0 = sanctum::carrier::CarrierFs::load(
|
||||
db.clone(),
|
||||
carrier_node_id,
|
||||
std::sync::Arc::new(auth_hidden.carrier_dek().unwrap().clone()),
|
||||
std::sync::Arc::new(auth_hidden.dek().clone()),
|
||||
auth_hidden.version(),
|
||||
true,
|
||||
)
|
||||
.expect("Recovery from Block 0 must succeed despite damaged Block 1");
|
||||
drop(cfs_recovered_from_b0);
|
||||
|
||||
// 4. Wenn BEIDE Blöcke zerstört sind: Totalverlust mit klarer Fehlermeldung
|
||||
{
|
||||
let conn = rusqlite::Connection::open(&path).unwrap();
|
||||
let mut noise = vec![0u8; 100];
|
||||
OsRng.fill_bytes(&mut noise);
|
||||
conn.execute(
|
||||
"UPDATE chunks SET ciphertext = ?1 WHERE node_id = ?2 AND chunk_index = 0",
|
||||
rusqlite::params![noise, carrier_node_id],
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
let both_damaged = sanctum::carrier::CarrierFs::load(
|
||||
db.clone(),
|
||||
carrier_node_id,
|
||||
std::sync::Arc::new(auth_hidden.carrier_dek().unwrap().clone()),
|
||||
std::sync::Arc::new(auth_hidden.dek().clone()),
|
||||
auth_hidden.version(),
|
||||
true,
|
||||
);
|
||||
let err_msg = match both_damaged {
|
||||
Ok(_) => panic!("Both blocks damaged must return Error"),
|
||||
Err(e) => e.to_string(),
|
||||
};
|
||||
assert!(
|
||||
err_msg.contains("Kritischer Datenverlust (C-02)"),
|
||||
"Error message must clearly identify C-02 failure: {}",
|
||||
err_msg
|
||||
);
|
||||
|
||||
drop(db);
|
||||
let _ = std::fs::remove_file(&path);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_c03_manifest_dirty_decoupling_and_unmount_flush() {
|
||||
let path = temp_db_path("c03_dirty");
|
||||
let carrier_size_bytes = 5 * 1024 * 1024; // 5 MB
|
||||
let carrier_name = "carrier_c03.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 cfs = sanctum::carrier::CarrierFs::load(
|
||||
db.clone(),
|
||||
carrier_node_id,
|
||||
std::sync::Arc::new(auth_hidden.carrier_dek().unwrap().clone()),
|
||||
std::sync::Arc::new(auth_hidden.dek().clone()),
|
||||
auth_hidden.version(),
|
||||
true,
|
||||
)
|
||||
.expect("CarrierFs load");
|
||||
|
||||
// 1. Unmittelbar nach Mounten: nicht dirty, 0 Saves
|
||||
assert_eq!(cfs.manifest_save_count(), 0);
|
||||
assert!(!cfs.is_manifest_dirty());
|
||||
|
||||
// 2. Metadaten-Operationen: 3 Ordner anlegen
|
||||
let dir1 = DavPath::new("/dir1").unwrap();
|
||||
let dir2 = DavPath::new("/dir2").unwrap();
|
||||
let dir3 = DavPath::new("/dir3").unwrap();
|
||||
cfs.create_dir(&dir1).await.expect("create_dir dir1");
|
||||
cfs.create_dir(&dir2).await.expect("create_dir dir2");
|
||||
cfs.create_dir(&dir3).await.expect("create_dir dir3");
|
||||
|
||||
// C-03 Verifikation: Manifest ist dirty, aber save_count ist IMMER NOCH 0!
|
||||
assert!(
|
||||
cfs.is_manifest_dirty(),
|
||||
"Manifest must be dirty after create_dir"
|
||||
);
|
||||
assert_eq!(
|
||||
cfs.manifest_save_count(),
|
||||
0,
|
||||
"No synchronous save_manifest on create_dir (C-03 decoupling)"
|
||||
);
|
||||
|
||||
// Datei im Verzeichnis erstellen
|
||||
let file_path = DavPath::new("/dir1/note.txt").unwrap();
|
||||
let open_write = OpenOptions {
|
||||
create_new: true,
|
||||
write: true,
|
||||
..Default::default()
|
||||
};
|
||||
let mut file = cfs.open(&file_path, open_write).await.expect("open create");
|
||||
assert_eq!(
|
||||
cfs.manifest_save_count(),
|
||||
0,
|
||||
"No synchronous save_manifest on file create"
|
||||
);
|
||||
|
||||
// 3. Expliziter Sync über sync_manifest()
|
||||
cfs.sync_manifest().expect("sync_manifest");
|
||||
assert!(
|
||||
!cfs.is_manifest_dirty(),
|
||||
"Manifest must be clean after sync"
|
||||
);
|
||||
assert_eq!(
|
||||
cfs.manifest_save_count(),
|
||||
1,
|
||||
"Save count incremented to 1 after sync"
|
||||
);
|
||||
|
||||
// Nochmal sync: da nicht dirty, kein unnötiger Save
|
||||
cfs.sync_manifest().expect("sync_manifest 2");
|
||||
assert_eq!(
|
||||
cfs.manifest_save_count(),
|
||||
1,
|
||||
"Save count remains 1 when not dirty"
|
||||
);
|
||||
|
||||
// 4. In Datei schreiben und flush() ausführen -> führt zu Manifest-Flush
|
||||
file.write_bytes(Bytes::from_static(b"carrier dirty test payload"))
|
||||
.await
|
||||
.unwrap();
|
||||
file.flush().await.expect("file flush");
|
||||
assert_eq!(
|
||||
cfs.manifest_save_count(),
|
||||
2,
|
||||
"File flush must flush manifest"
|
||||
);
|
||||
assert!(!cfs.is_manifest_dirty());
|
||||
drop(file);
|
||||
|
||||
// 5. Weiteren Ordner anlegen (mark_dirty), dann cfs droppen
|
||||
let dir4 = DavPath::new("/dir4").unwrap();
|
||||
cfs.create_dir(&dir4).await.expect("create_dir dir4");
|
||||
assert!(cfs.is_manifest_dirty());
|
||||
assert_eq!(cfs.manifest_save_count(), 2);
|
||||
|
||||
// Drop von CarrierFs (Drop-Garantie bei Unmount)
|
||||
drop(cfs);
|
||||
|
||||
// 6. Neu laden und prüfen, dass dir4 persistiert wurde
|
||||
let cfs_reloaded = sanctum::carrier::CarrierFs::load(
|
||||
db.clone(),
|
||||
carrier_node_id,
|
||||
std::sync::Arc::new(auth_hidden.carrier_dek().unwrap().clone()),
|
||||
std::sync::Arc::new(auth_hidden.dek().clone()),
|
||||
auth_hidden.version(),
|
||||
true,
|
||||
)
|
||||
.expect("CarrierFs reload");
|
||||
|
||||
assert!(
|
||||
cfs_reloaded
|
||||
.read_dir(&dir4, ReadDirMeta::None)
|
||||
.await
|
||||
.is_ok(),
|
||||
"Directory created before drop must exist"
|
||||
);
|
||||
|
||||
drop(cfs_reloaded);
|
||||
drop(db);
|
||||
let _ = std::fs::remove_file(&path);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_c04_manifest_capacity_limit_and_warning() {
|
||||
let path = temp_db_path("c04_capacity");
|
||||
let carrier_size_bytes = 10 * 1024 * 1024; // 10 MB
|
||||
let carrier_name = "carrier_c04.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 cfs = sanctum::carrier::CarrierFs::load(
|
||||
db.clone(),
|
||||
carrier_node_id,
|
||||
std::sync::Arc::new(auth_hidden.carrier_dek().unwrap().clone()),
|
||||
std::sync::Arc::new(auth_hidden.dek().clone()),
|
||||
auth_hidden.version(),
|
||||
true,
|
||||
)
|
||||
.expect("CarrierFs load");
|
||||
|
||||
// 1. Initialer Zustand: Manifest minimal (< 5 KB, << 80%)
|
||||
let (len, cap, pct) = cfs.manifest_usage();
|
||||
assert_eq!(cap, sanctum::carrier::CARRIER_MANIFEST_CAPACITY);
|
||||
assert!(len < 5_000);
|
||||
assert!(pct < 1.0);
|
||||
|
||||
// 2. Fülle Manifest gezielt auf > 80% (> 838.809 Bytes)
|
||||
// Erstelle Verzeichnisse mit langen Pfadnamen, bis die Größe über 840 KB liegt
|
||||
for i in 0..1000 {
|
||||
let dir_path = DavPath::new(&format!("/d_{:04}_{}", i, "a".repeat(1000))).unwrap();
|
||||
cfs.create_dir(&dir_path).await.expect("create_dir");
|
||||
let (current_len, _, _) = cfs.manifest_usage();
|
||||
if current_len >= sanctum::carrier::CARRIER_MANIFEST_WARN_THRESHOLD {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
let (len80, _, pct80) = cfs.manifest_usage();
|
||||
assert!(
|
||||
len80 >= sanctum::carrier::CARRIER_MANIFEST_WARN_THRESHOLD,
|
||||
"Manifest size must exceed 80% threshold, got: {}",
|
||||
len80
|
||||
);
|
||||
assert!(
|
||||
pct80 >= 80.0,
|
||||
"Manifest pct must be >= 80.0%, got: {}",
|
||||
pct80
|
||||
);
|
||||
|
||||
// Speichern (sync_manifest) muss mit Warnung gelingen
|
||||
cfs.sync_manifest()
|
||||
.expect("sync_manifest at > 80% must succeed");
|
||||
drop(cfs);
|
||||
|
||||
// Neu laden: muss erfolgreich laden und beim Laden die 80%-Warnung auslösen
|
||||
let cfs_loaded = sanctum::carrier::CarrierFs::load(
|
||||
db.clone(),
|
||||
carrier_node_id,
|
||||
std::sync::Arc::new(auth_hidden.carrier_dek().unwrap().clone()),
|
||||
std::sync::Arc::new(auth_hidden.dek().clone()),
|
||||
auth_hidden.version(),
|
||||
true,
|
||||
)
|
||||
.expect("CarrierFs load at > 80% must succeed");
|
||||
let (reloaded_len, _, reloaded_pct) = cfs_loaded.manifest_usage();
|
||||
assert!(reloaded_pct >= 80.0);
|
||||
assert_eq!(reloaded_len, len80);
|
||||
|
||||
// 3. Grenze überschreiten: weiter füllen bis > 1.048.512 Bytes
|
||||
for i in 1000..1500 {
|
||||
let dir_path = DavPath::new(&format!("/overflow_{:04}_{}", i, "x".repeat(1000))).unwrap();
|
||||
cfs_loaded
|
||||
.create_dir(&dir_path)
|
||||
.await
|
||||
.expect("create_dir overflow");
|
||||
let (cur_len, _, _) = cfs_loaded.manifest_usage();
|
||||
if cur_len > sanctum::carrier::CARRIER_MANIFEST_CAPACITY {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// In Format V2 (v0.9.0): Die 1-MB-Grenze bricht NICHT mehr ab, sondern allokiert eine zusätzliche Seite
|
||||
cfs_loaded
|
||||
.sync_manifest()
|
||||
.expect("sync_manifest with > 1 MB must succeed in V2 via paged manifest");
|
||||
assert!(
|
||||
cfs_loaded.page_count() >= 2,
|
||||
"Page count must expand to at least 2 pages"
|
||||
);
|
||||
|
||||
// Reloaden und prüfen, ob beide Seiten geladen werden
|
||||
drop(cfs_loaded);
|
||||
let cfs_paged = sanctum::carrier::CarrierFs::load(
|
||||
db.clone(),
|
||||
carrier_node_id,
|
||||
std::sync::Arc::new(auth_hidden.carrier_dek().unwrap().clone()),
|
||||
std::sync::Arc::new(auth_hidden.dek().clone()),
|
||||
auth_hidden.version(),
|
||||
true,
|
||||
)
|
||||
.expect("CarrierFs load paged manifest");
|
||||
assert!(cfs_paged.page_count() >= 2);
|
||||
drop(cfs_paged);
|
||||
drop(db);
|
||||
let _ = std::fs::remove_file(&path);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,686 @@
|
||||
use std::collections::HashMap;
|
||||
use std::path::PathBuf;
|
||||
use std::time::Instant;
|
||||
|
||||
use bytes::Bytes;
|
||||
use dav_server::davpath::DavPath;
|
||||
use dav_server::fs::{DavFileSystem, OpenOptions};
|
||||
use rand::rngs::OsRng;
|
||||
use rand::RngCore;
|
||||
|
||||
use sanctum::carrier::{
|
||||
write_carrier_block, CarrierFs, CarrierFsInner, CarrierInode, CarrierManifest, CARRIER_MAGIC,
|
||||
CARRIER_VERSION, CARRIER_VERSION_V2,
|
||||
};
|
||||
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, UnlockedKeys};
|
||||
|
||||
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_v2_{}_{}.sanctum", prefix, id));
|
||||
path
|
||||
}
|
||||
|
||||
struct TestEnv {
|
||||
pub path: PathBuf,
|
||||
pub db: Database,
|
||||
pub carrier_node_id: i64,
|
||||
pub auth_hidden: UnlockedKeys,
|
||||
}
|
||||
|
||||
impl Drop for TestEnv {
|
||||
fn drop(&mut self) {
|
||||
let _ = std::fs::remove_file(&self.path);
|
||||
}
|
||||
}
|
||||
|
||||
fn setup_carrier_env(prefix: &str, size_mb: usize) -> TestEnv {
|
||||
let path = temp_db_path(prefix);
|
||||
let carrier_size_bytes = (size_mb * 1024 * 1024) as u64;
|
||||
let carrier_name = "carrier_v2.dat";
|
||||
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");
|
||||
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");
|
||||
|
||||
TestEnv {
|
||||
path,
|
||||
db,
|
||||
carrier_node_id,
|
||||
auth_hidden,
|
||||
}
|
||||
}
|
||||
|
||||
fn load_carrier_fs(env: &TestEnv) -> CarrierFs {
|
||||
CarrierFs::load(
|
||||
env.db.clone(),
|
||||
env.carrier_node_id,
|
||||
std::sync::Arc::new(env.auth_hidden.carrier_dek().unwrap().clone()),
|
||||
std::sync::Arc::new(env.auth_hidden.dek().clone()),
|
||||
env.auth_hidden.version(),
|
||||
true,
|
||||
)
|
||||
.expect("Load CarrierFs")
|
||||
}
|
||||
|
||||
/// 1. Kapazitätstest: >10.000 Inodes künstlich erzeugen, über mehrere Seiten speichern und neu laden
|
||||
#[tokio::test]
|
||||
async fn test_capacity_large_inode_table() {
|
||||
let env = setup_carrier_env("capacity_large", 25);
|
||||
let cfs = load_carrier_fs(&env);
|
||||
|
||||
// Initial hat ein frischer Container 1 Seite (Block 2)
|
||||
assert_eq!(cfs.page_count(), 1);
|
||||
|
||||
// 10.000 Inodes direkt in den Speicher einfügen
|
||||
{
|
||||
let mut inner = cfs.inner.lock().unwrap();
|
||||
for i in 0..10_000 {
|
||||
let id = inner.manifest.next_inode_id;
|
||||
inner.manifest.next_inode_id += 1;
|
||||
let inode = CarrierInode {
|
||||
id,
|
||||
parent_id: Some(1),
|
||||
name: format!("file_{:05}.txt", i),
|
||||
is_dir: false,
|
||||
size: i % 500,
|
||||
created_at: 1_700_000_000 + i,
|
||||
modified_at: 1_700_000_000 + i,
|
||||
blocks: Vec::new(),
|
||||
};
|
||||
inner.manifest.inodes.insert(id, inode);
|
||||
inner.index_add_child(1, id);
|
||||
}
|
||||
inner.mark_dirty();
|
||||
}
|
||||
|
||||
// Speichern erzwingen
|
||||
cfs.sync_manifest().expect("Sync 10.000 inodes");
|
||||
|
||||
// In V2 müssen die 10.000 Inodes auf mindestens 2 Seiten aufgeteilt worden sein
|
||||
let pages_after_save = cfs.page_count();
|
||||
assert!(
|
||||
pages_after_save >= 2,
|
||||
"10.000 Inodes müssen auf mindestens 2 Seiten aufgeteilt werden, tatsächlich: {}",
|
||||
pages_after_save
|
||||
);
|
||||
|
||||
drop(cfs);
|
||||
|
||||
// Neu aus Trägerdatei laden
|
||||
let cfs_reloaded = load_carrier_fs(&env);
|
||||
assert_eq!(cfs_reloaded.page_count(), pages_after_save);
|
||||
assert_eq!(cfs_reloaded.corrupted_pages(), 0);
|
||||
|
||||
// Prüfe, dass beliebige Dateien korrekt existieren und Pfade auflösen
|
||||
let test_file_1 = cfs_reloaded.resolve_path("/file_00000.txt");
|
||||
assert!(test_file_1.is_some());
|
||||
assert_eq!(test_file_1.unwrap().name, "file_00000.txt");
|
||||
|
||||
let test_file_mid = cfs_reloaded.resolve_path("/file_04999.txt");
|
||||
assert!(test_file_mid.is_some());
|
||||
assert_eq!(test_file_mid.unwrap().name, "file_04999.txt");
|
||||
|
||||
let test_file_end = cfs_reloaded.resolve_path("/file_09999.txt");
|
||||
assert!(test_file_end.is_some());
|
||||
assert_eq!(test_file_end.unwrap().name, "file_09999.txt");
|
||||
|
||||
let nonexistent = cfs_reloaded.resolve_path("/file_10000.txt");
|
||||
assert!(nonexistent.is_none());
|
||||
}
|
||||
|
||||
/// 2. Migrationstest: Einen V1-Container laden, modifizieren, als V2 speichern und verifizieren
|
||||
#[tokio::test]
|
||||
async fn test_v1_to_v2_migration() {
|
||||
let env = setup_carrier_env("migration_v1_v2", 10);
|
||||
|
||||
// Einen V1-Container konstruieren: Block 0 und Block 1 halten CarrierManifest mit version = 1
|
||||
let mut v1_manifest = CarrierManifest {
|
||||
magic: *CARRIER_MAGIC,
|
||||
version: CARRIER_VERSION, // 1
|
||||
manifest_generation: 1,
|
||||
total_blocks: 10,
|
||||
free_blocks: (2..10).collect(),
|
||||
next_inode_id: 3,
|
||||
page_block_indices: Vec::new(),
|
||||
inodes: HashMap::new(),
|
||||
};
|
||||
v1_manifest.inodes.insert(
|
||||
1,
|
||||
CarrierInode {
|
||||
id: 1,
|
||||
parent_id: None,
|
||||
name: String::new(),
|
||||
is_dir: true,
|
||||
size: 0,
|
||||
created_at: 1000,
|
||||
modified_at: 1000,
|
||||
blocks: Vec::new(),
|
||||
},
|
||||
);
|
||||
v1_manifest.inodes.insert(
|
||||
2,
|
||||
CarrierInode {
|
||||
id: 2,
|
||||
parent_id: Some(1),
|
||||
name: "original_v1.txt".to_string(),
|
||||
is_dir: false,
|
||||
size: 128,
|
||||
created_at: 1000,
|
||||
modified_at: 1000,
|
||||
blocks: Vec::new(),
|
||||
},
|
||||
);
|
||||
|
||||
let v1_bytes = serde_json::to_vec(&v1_manifest).unwrap();
|
||||
let dek_outer = env.auth_hidden.carrier_dek().unwrap();
|
||||
let dek_inner = env.auth_hidden.dek();
|
||||
write_carrier_block(
|
||||
&env.db,
|
||||
env.carrier_node_id,
|
||||
0,
|
||||
&dek_outer,
|
||||
&dek_inner,
|
||||
&v1_bytes,
|
||||
env.auth_hidden.version(),
|
||||
)
|
||||
.unwrap();
|
||||
write_carrier_block(
|
||||
&env.db,
|
||||
env.carrier_node_id,
|
||||
1,
|
||||
&dek_outer,
|
||||
&dek_inner,
|
||||
&v1_bytes,
|
||||
env.auth_hidden.version(),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
// 1. Unter v0.9.0 laden: V1-Format wird transparent erkannt
|
||||
let cfs = load_carrier_fs(&env);
|
||||
{
|
||||
let inner = cfs.inner.lock().unwrap();
|
||||
assert_eq!(inner.manifest.version, CARRIER_VERSION);
|
||||
}
|
||||
let orig = cfs.resolve_path("/original_v1.txt");
|
||||
assert!(orig.is_some());
|
||||
assert_eq!(orig.unwrap().id, 2);
|
||||
|
||||
// 2. Änderung vornehmen: Datei hinzufügen (löst Dirty-Tracking aus)
|
||||
let new_file_path = DavPath::new("/new_v2.txt").unwrap();
|
||||
let mut file = cfs
|
||||
.open(
|
||||
&new_file_path,
|
||||
OpenOptions {
|
||||
create_new: true,
|
||||
write: true,
|
||||
..Default::default()
|
||||
},
|
||||
)
|
||||
.await
|
||||
.expect("Create new file in migrated container");
|
||||
file.write_bytes(Bytes::from_static(b"migrated to v2"))
|
||||
.await
|
||||
.unwrap();
|
||||
file.flush().await.unwrap();
|
||||
drop(file);
|
||||
|
||||
// Explizit synchronisieren
|
||||
cfs.sync_manifest().expect("Sync manifest during migration");
|
||||
drop(cfs);
|
||||
|
||||
// 3. Neu laden: Jetzt muss das Dateisystem im Format V2 vorliegen
|
||||
let cfs_reloaded = load_carrier_fs(&env);
|
||||
{
|
||||
let inner = cfs_reloaded.inner.lock().unwrap();
|
||||
assert_eq!(inner.manifest.version, CARRIER_VERSION_V2);
|
||||
assert!(!inner.manifest.page_block_indices.is_empty());
|
||||
}
|
||||
|
||||
// Beide Dateien müssen vorhanden sein
|
||||
assert!(cfs_reloaded.resolve_path("/original_v1.txt").is_some());
|
||||
assert!(cfs_reloaded.resolve_path("/new_v2.txt").is_some());
|
||||
}
|
||||
|
||||
/// 3. Teilausfalltest (D-01 Fail-Soft): Beschädigung einer einzelnen Inode-Seite führt nicht zum Totalverlust
|
||||
#[tokio::test]
|
||||
async fn test_partial_page_corruption_resilience() {
|
||||
let env = setup_carrier_env("partial_corruption", 20);
|
||||
let cfs = load_carrier_fs(&env);
|
||||
|
||||
// Genügend Inodes erzeugen, um 2 Seiten zu belegen
|
||||
{
|
||||
let mut inner = cfs.inner.lock().unwrap();
|
||||
for i in 0..1500 {
|
||||
let id = inner.manifest.next_inode_id;
|
||||
inner.manifest.next_inode_id += 1;
|
||||
let name = if i < 750 {
|
||||
format!("alpha_{:04}_{}", i, "a".repeat(800))
|
||||
} else {
|
||||
format!("omega_{:04}_{}", i, "z".repeat(800))
|
||||
};
|
||||
let inode = CarrierInode {
|
||||
id,
|
||||
parent_id: Some(1),
|
||||
name,
|
||||
is_dir: false,
|
||||
size: 10,
|
||||
created_at: 2000,
|
||||
modified_at: 2000,
|
||||
blocks: Vec::new(),
|
||||
};
|
||||
inner.manifest.inodes.insert(id, inode);
|
||||
inner.index_add_child(1, id);
|
||||
}
|
||||
inner.mark_dirty();
|
||||
}
|
||||
|
||||
cfs.sync_manifest().expect("Sync 2 pages");
|
||||
let page_blocks = {
|
||||
let inner = cfs.inner.lock().unwrap();
|
||||
inner.manifest.page_block_indices.clone()
|
||||
};
|
||||
assert!(
|
||||
page_blocks.len() >= 2,
|
||||
"Benötigt mindestens 2 Seiten, hat: {}",
|
||||
page_blocks.len()
|
||||
);
|
||||
|
||||
let second_page_block = page_blocks[1];
|
||||
drop(cfs);
|
||||
|
||||
// 2. Gezielte Beschädigung: Zweite Seite in SQLite mit Rauschen überschreiben
|
||||
{
|
||||
let conn = rusqlite::Connection::open(&env.path).unwrap();
|
||||
let mut noise = vec![0u8; 500];
|
||||
OsRng.fill_bytes(&mut noise);
|
||||
conn.execute(
|
||||
"UPDATE chunks SET ciphertext = ?1 WHERE node_id = ?2 AND chunk_index = ?3",
|
||||
rusqlite::params![noise, env.carrier_node_id, second_page_block],
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
// 3. Neu laden: Darf NICHT abbrechen (Fail-Soft), sondern überspringt die defekte Seite
|
||||
let cfs_reloaded = load_carrier_fs(&env);
|
||||
assert_eq!(
|
||||
cfs_reloaded.corrupted_pages(),
|
||||
1,
|
||||
"Muss genau 1 beschädigte Seite protokollieren"
|
||||
);
|
||||
|
||||
// Wurzelverzeichnis '/' muss intakt sein
|
||||
assert!(cfs_reloaded.resolve_path("/").is_some());
|
||||
|
||||
// Einträge der ersten, unbeschädigten Seite müssen weiterhin vollständig auffindbar sein
|
||||
let alpha_0 = cfs_reloaded.resolve_path(&format!("/alpha_0000_{}", "a".repeat(800)));
|
||||
assert!(
|
||||
alpha_0.is_some(),
|
||||
"Dateien aus der intakten Seite 0 müssen lesbar bleiben"
|
||||
);
|
||||
}
|
||||
|
||||
/// 4. Index-Konsistenztest (D-02): Operationsfolge gegen frisch aufgebauten Referenzindex abgleichen
|
||||
#[tokio::test]
|
||||
async fn test_children_index_consistency() {
|
||||
let env = setup_carrier_env("children_consistency", 10);
|
||||
let cfs = load_carrier_fs(&env);
|
||||
|
||||
// 1. Verzeichnisse anlegen
|
||||
cfs.create_dir(&DavPath::new("/docs").unwrap())
|
||||
.await
|
||||
.unwrap();
|
||||
cfs.create_dir(&DavPath::new("/docs/work").unwrap())
|
||||
.await
|
||||
.unwrap();
|
||||
cfs.create_dir(&DavPath::new("/photos").unwrap())
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
// 2. Dateien anlegen
|
||||
let opt = OpenOptions {
|
||||
create_new: true,
|
||||
write: true,
|
||||
..Default::default()
|
||||
};
|
||||
let mut f1 = cfs
|
||||
.open(&DavPath::new("/docs/report.txt").unwrap(), opt.clone())
|
||||
.await
|
||||
.unwrap();
|
||||
f1.write_bytes(Bytes::from_static(b"report")).await.unwrap();
|
||||
f1.flush().await.unwrap();
|
||||
drop(f1);
|
||||
|
||||
let mut f2 = cfs
|
||||
.open(&DavPath::new("/docs/work/notes.txt").unwrap(), opt.clone())
|
||||
.await
|
||||
.unwrap();
|
||||
f2.write_bytes(Bytes::from_static(b"notes")).await.unwrap();
|
||||
f2.flush().await.unwrap();
|
||||
drop(f2);
|
||||
|
||||
let mut f3 = cfs
|
||||
.open(&DavPath::new("/photos/pic.jpg").unwrap(), opt.clone())
|
||||
.await
|
||||
.unwrap();
|
||||
f3.write_bytes(Bytes::from_static(b"pic")).await.unwrap();
|
||||
f3.flush().await.unwrap();
|
||||
drop(f3);
|
||||
|
||||
// 3. Verschieben/Umbenennen
|
||||
cfs.rename(
|
||||
&DavPath::new("/docs/work/notes.txt").unwrap(),
|
||||
&DavPath::new("/photos/notes_moved.txt").unwrap(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
// 4. Datei löschen
|
||||
cfs.remove_file(&DavPath::new("/docs/report.txt").unwrap())
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
// 5. Verzeichnis löschen
|
||||
cfs.remove_dir(&DavPath::new("/docs/work").unwrap())
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
// 6. Abgleich: children_index gegen frisch aufgebauten Referenzindex prüfen
|
||||
{
|
||||
let inner = cfs.inner.lock().unwrap();
|
||||
let reference_index = CarrierFsInner::build_children_index(&inner.manifest.inodes);
|
||||
|
||||
for (parent_id, ref_children) in &reference_index {
|
||||
let actual_children = inner.children_index.get(parent_id);
|
||||
assert!(
|
||||
actual_children.is_some(),
|
||||
"Parent {} fehlt im children_index",
|
||||
parent_id
|
||||
);
|
||||
let mut ref_sorted = ref_children.clone();
|
||||
ref_sorted.sort();
|
||||
let mut act_sorted = actual_children.unwrap().clone();
|
||||
act_sorted.sort();
|
||||
assert_eq!(
|
||||
ref_sorted, act_sorted,
|
||||
"Inkonsistenz der Kinder für Parent {}",
|
||||
parent_id
|
||||
);
|
||||
}
|
||||
|
||||
// Auch die Umkehrung prüfen (keine Geister-Einträge)
|
||||
for (parent_id, actual_children) in &inner.children_index {
|
||||
if actual_children.is_empty() {
|
||||
continue;
|
||||
}
|
||||
assert!(
|
||||
reference_index.contains_key(parent_id),
|
||||
"children_index enthält verwaisten Parent {}",
|
||||
parent_id
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 5. Performance-Sanity-Check: Pfadauflösung bei 5.000 Geschwistern muss sub-millisekündlich sein (D-02)
|
||||
#[tokio::test]
|
||||
async fn test_secondary_index_path_resolution_speed() {
|
||||
let env = setup_carrier_env("perf_resolution", 15);
|
||||
let cfs = load_carrier_fs(&env);
|
||||
|
||||
cfs.create_dir(&DavPath::new("/big_dir").unwrap())
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let big_dir_node = cfs.resolve_path("/big_dir").expect("big_dir node");
|
||||
|
||||
// 5.000 Kindknoten in /big_dir anlegen
|
||||
{
|
||||
let mut inner = cfs.inner.lock().unwrap();
|
||||
for i in 0..5_000 {
|
||||
let id = inner.manifest.next_inode_id;
|
||||
inner.manifest.next_inode_id += 1;
|
||||
let inode = CarrierInode {
|
||||
id,
|
||||
parent_id: Some(big_dir_node.id),
|
||||
name: format!("child_{:04}.txt", i),
|
||||
is_dir: false,
|
||||
size: 10,
|
||||
created_at: 3000,
|
||||
modified_at: 3000,
|
||||
blocks: Vec::new(),
|
||||
};
|
||||
inner.manifest.inodes.insert(id, inode);
|
||||
inner.index_add_child(big_dir_node.id, id);
|
||||
}
|
||||
inner.mark_dirty();
|
||||
}
|
||||
|
||||
// Messung: Pfadauflösung für den letzten Eintrag
|
||||
let start = Instant::now();
|
||||
let target = cfs.resolve_path("/big_dir/child_4999.txt");
|
||||
let elapsed = start.elapsed();
|
||||
|
||||
assert!(target.is_some());
|
||||
assert_eq!(target.unwrap().name, "child_4999.txt");
|
||||
|
||||
// Der Sekundärindex muss den Eintrag in unter 50 Millisekunden finden (typisch < 0.2 ms, O(1) statt O(N))
|
||||
assert!(
|
||||
elapsed.as_millis() < 50,
|
||||
"Pfadauflösung dauerte zu lange: {:?}",
|
||||
elapsed
|
||||
);
|
||||
}
|
||||
|
||||
/// 6. Platzmangel-Migrationstest: Migration eines Containers ohne freie Blöcke bricht sauber ab (D-03)
|
||||
#[tokio::test]
|
||||
async fn test_out_of_space_migration_aborts_cleanly() {
|
||||
let env = setup_carrier_env("migration_no_space", 5);
|
||||
|
||||
// V1-Manifest mit 0 freien Blöcken (free_blocks ist leer)
|
||||
let mut v1_manifest = CarrierManifest {
|
||||
magic: *CARRIER_MAGIC,
|
||||
version: CARRIER_VERSION,
|
||||
manifest_generation: 1,
|
||||
total_blocks: 2,
|
||||
free_blocks: Vec::new(), // Keine freien Blöcke!
|
||||
next_inode_id: 2,
|
||||
page_block_indices: Vec::new(),
|
||||
inodes: HashMap::new(),
|
||||
};
|
||||
v1_manifest.inodes.insert(
|
||||
1,
|
||||
CarrierInode {
|
||||
id: 1,
|
||||
parent_id: None,
|
||||
name: String::new(),
|
||||
is_dir: true,
|
||||
size: 0,
|
||||
created_at: 1000,
|
||||
modified_at: 1000,
|
||||
blocks: Vec::new(),
|
||||
},
|
||||
);
|
||||
|
||||
let v1_bytes = serde_json::to_vec(&v1_manifest).unwrap();
|
||||
let dek_outer = env.auth_hidden.carrier_dek().unwrap();
|
||||
let dek_inner = env.auth_hidden.dek();
|
||||
write_carrier_block(
|
||||
&env.db,
|
||||
env.carrier_node_id,
|
||||
0,
|
||||
&dek_outer,
|
||||
&dek_inner,
|
||||
&v1_bytes,
|
||||
env.auth_hidden.version(),
|
||||
)
|
||||
.unwrap();
|
||||
write_carrier_block(
|
||||
&env.db,
|
||||
env.carrier_node_id,
|
||||
1,
|
||||
&dek_outer,
|
||||
&dek_inner,
|
||||
&v1_bytes,
|
||||
env.auth_hidden.version(),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let cfs = load_carrier_fs(&env);
|
||||
|
||||
// Versuch zu speichern muss mit klarer Fehlermeldung fehlschlagen
|
||||
let res = {
|
||||
let mut inner = cfs.inner.lock().unwrap();
|
||||
inner.mark_dirty();
|
||||
inner.save_manifest()
|
||||
};
|
||||
|
||||
assert!(res.is_err());
|
||||
let err_msg = res.unwrap_err().to_string();
|
||||
assert!(
|
||||
err_msg.contains("Nicht genügend freie Blöcke"),
|
||||
"Fehlermeldung muss auf Speichermangel hinweisen: {}",
|
||||
err_msg
|
||||
);
|
||||
|
||||
drop(cfs);
|
||||
|
||||
// Trägerdatei muss weiterhin intakt als V1 ladbar sein
|
||||
let cfs_recheck = load_carrier_fs(&env);
|
||||
{
|
||||
let inner = cfs_recheck.inner.lock().unwrap();
|
||||
assert_eq!(inner.manifest.version, CARRIER_VERSION);
|
||||
}
|
||||
}
|
||||
|
||||
/// 7. Seitenfreigabe (D-05): Überzählige Seitenblöcke werden bei Schrumpfung geschreddert und freigegeben
|
||||
#[tokio::test]
|
||||
async fn test_page_block_reclaiming_on_shrink() {
|
||||
let env = setup_carrier_env("page_reclaiming", 25);
|
||||
let cfs = load_carrier_fs(&env);
|
||||
|
||||
let initial_free = {
|
||||
let inner = cfs.inner.lock().unwrap();
|
||||
inner.manifest.free_blocks.len()
|
||||
};
|
||||
|
||||
// 1. Viele Inodes erzeugen, sodass mindestens 3 Seiten belegt werden
|
||||
let mut added_ids = Vec::new();
|
||||
{
|
||||
let mut inner = cfs.inner.lock().unwrap();
|
||||
for i in 0..2500 {
|
||||
let id = inner.manifest.next_inode_id;
|
||||
inner.manifest.next_inode_id += 1;
|
||||
added_ids.push(id);
|
||||
let inode = CarrierInode {
|
||||
id,
|
||||
parent_id: Some(1),
|
||||
name: format!("large_item_{:04}_{}", i, "x".repeat(800)),
|
||||
is_dir: false,
|
||||
size: 10,
|
||||
created_at: 4000,
|
||||
modified_at: 4000,
|
||||
blocks: Vec::new(),
|
||||
};
|
||||
inner.manifest.inodes.insert(id, inode);
|
||||
inner.index_add_child(1, id);
|
||||
}
|
||||
inner.mark_dirty();
|
||||
}
|
||||
|
||||
cfs.sync_manifest().expect("Sync 3 pages");
|
||||
let pages_before = cfs.page_count();
|
||||
assert!(
|
||||
pages_before >= 3,
|
||||
"Muss mindestens 3 Seiten belegen, hat: {}",
|
||||
pages_before
|
||||
);
|
||||
|
||||
let free_after_expand = {
|
||||
let inner = cfs.inner.lock().unwrap();
|
||||
inner.manifest.free_blocks.len()
|
||||
};
|
||||
assert_eq!(free_after_expand, initial_free - (pages_before - 1));
|
||||
|
||||
// 2. Fast alle Inodes entfernen, sodass nur noch 1 Seite benötigt wird
|
||||
{
|
||||
let mut inner = cfs.inner.lock().unwrap();
|
||||
for id in added_ids {
|
||||
inner.manifest.inodes.remove(&id);
|
||||
inner.index_remove_child(1, id);
|
||||
}
|
||||
inner.mark_dirty();
|
||||
}
|
||||
|
||||
cfs.sync_manifest().expect("Sync after shrink");
|
||||
|
||||
// 3. Verifizieren: page_count ist wieder 1, freie Blöcke wurden zurückgegeben
|
||||
let pages_after = cfs.page_count();
|
||||
assert_eq!(
|
||||
pages_after, 1,
|
||||
"Nach Schrumpfung darf nur noch 1 Seite belegt sein"
|
||||
);
|
||||
|
||||
let free_after_shrink = {
|
||||
let inner = cfs.inner.lock().unwrap();
|
||||
inner.manifest.free_blocks.len()
|
||||
};
|
||||
assert_eq!(
|
||||
free_after_shrink, initial_free,
|
||||
"Alle überzähligen Seitenblöcke müssen an free_blocks zurückgegeben worden sein"
|
||||
);
|
||||
|
||||
drop(cfs);
|
||||
|
||||
// Trägerdatei neu laden und Integrität prüfen
|
||||
let cfs_reloaded = load_carrier_fs(&env);
|
||||
assert_eq!(cfs_reloaded.page_count(), 1);
|
||||
assert_eq!(cfs_reloaded.corrupted_pages(), 0);
|
||||
assert!(cfs_reloaded.resolve_path("/").is_some());
|
||||
}
|
||||
@@ -309,3 +309,85 @@ async fn test_z04_webdav_quota_report() {
|
||||
drop(db);
|
||||
let _ = std::fs::remove_file(&container_path);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_mount_rejects_tampered_metadata_mac() {
|
||||
let temp_dir = std::env::temp_dir();
|
||||
let container_path: PathBuf = temp_dir.join(format!(
|
||||
"test_mount_tampered_mac_{}.sanctum",
|
||||
std::process::id()
|
||||
));
|
||||
if container_path.exists() {
|
||||
let _ = std::fs::remove_file(&container_path);
|
||||
}
|
||||
|
||||
let password = "TestTamperedMacPassword2026!";
|
||||
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(&container_path).unwrap();
|
||||
db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag)
|
||||
.unwrap();
|
||||
db.set_active_slot_and_dek(0, dek.clone());
|
||||
|
||||
// Erstelle einen Testknoten
|
||||
let node = db.create_node(1, "original.txt", false).unwrap();
|
||||
db.update_metadata_mac().unwrap();
|
||||
|
||||
// Vor Manipulation: verify_metadata_mac muss erfolgreich sein
|
||||
assert!(db.verify_metadata_mac_for_slot(0, &dek).unwrap());
|
||||
|
||||
// Manipuliere SQLite-Metadaten direkt (Böswilliger Angreifer)
|
||||
{
|
||||
let conn = rusqlite::Connection::open(&container_path).unwrap();
|
||||
conn.execute(
|
||||
"UPDATE nodes SET name = 'hacked.exe' WHERE id = ?1",
|
||||
[node.id],
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
// Nach Manipulation: Direkte Verifikation meldet 'false' (Integritätsbruch)
|
||||
assert!(!db.verify_metadata_mac_for_slot(0, &dek).unwrap());
|
||||
|
||||
drop(db);
|
||||
|
||||
// Aufruf von mount_container muss fail-closed abbrechen
|
||||
let auth =
|
||||
sanctum::mount::ContainerAuth::Password(zeroize::Zeroizing::new(password.to_string()));
|
||||
let res = sanctum::mount::mount_container(
|
||||
&container_path,
|
||||
'Z',
|
||||
None,
|
||||
Some(18943),
|
||||
auth,
|
||||
false,
|
||||
false,
|
||||
None,
|
||||
false,
|
||||
false,
|
||||
None,
|
||||
true,
|
||||
)
|
||||
.await;
|
||||
|
||||
assert!(
|
||||
res.is_err(),
|
||||
"Mount mit manipulierten Metadaten muss fehlschlagen!"
|
||||
);
|
||||
let err_msg = res.unwrap_err().to_string();
|
||||
assert!(
|
||||
err_msg.contains("Metadaten-MAC-Verifikation fehlgeschlagen") || err_msg.contains("K-01"),
|
||||
"Erwartete Fehlermeldung zu K-01 Metadaten-MAC, erhalten: {}",
|
||||
err_msg
|
||||
);
|
||||
|
||||
let _ = std::fs::remove_file(&container_path);
|
||||
}
|
||||
|
||||
@@ -127,3 +127,200 @@ fn test_storage_create_and_rename_reject_invalid_names() {
|
||||
|
||||
let _ = std::fs::remove_file(&path);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_carrier_fs_rejects_invalid_names() {
|
||||
use dav_server::davpath::DavPath;
|
||||
use dav_server::fs::{DavFileSystem, FsError, OpenOptions};
|
||||
use rand::rngs::OsRng;
|
||||
use rand::RngCore;
|
||||
use sanctum::carrier::CarrierFs;
|
||||
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 std::sync::Arc;
|
||||
|
||||
let mut path = std::env::temp_dir();
|
||||
let id: u64 = OsRng.next_u64();
|
||||
path.push(format!("sanctum_test_carrier_pathval_{}.sanctum", id));
|
||||
if path.exists() {
|
||||
let _ = std::fs::remove_file(&path);
|
||||
}
|
||||
|
||||
let carrier_size_bytes = 10 * 1024 * 1024;
|
||||
let carrier_name = "system_backup.dat";
|
||||
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");
|
||||
|
||||
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");
|
||||
|
||||
let cfs = CarrierFs::load(
|
||||
db.clone(),
|
||||
carrier_node_id,
|
||||
Arc::new(dek_0),
|
||||
Arc::new(dek_1),
|
||||
3,
|
||||
false,
|
||||
)
|
||||
.expect("Load CarrierFs");
|
||||
|
||||
// 1. create_dir mit ungültigem Namen (Windows-Reservierung CON, PRN)
|
||||
let p_con = DavPath::new("/CON").unwrap();
|
||||
assert_eq!(cfs.create_dir(&p_con).await, Err(FsError::Forbidden));
|
||||
|
||||
let p_aux = DavPath::new("/aux.txt").unwrap();
|
||||
assert_eq!(cfs.create_dir(&p_aux).await, Err(FsError::Forbidden));
|
||||
|
||||
// 2. open (create) mit ungültigem Namen
|
||||
let p_nul = DavPath::new("/NUL").unwrap();
|
||||
let mut opt_create = OpenOptions::default();
|
||||
opt_create.create = true;
|
||||
opt_create.write = true;
|
||||
assert_eq!(
|
||||
cfs.open(&p_nul, opt_create.clone()).await.err(),
|
||||
Some(FsError::Forbidden)
|
||||
);
|
||||
|
||||
let p_ctrl = DavPath::new("/prn.pdf").unwrap();
|
||||
assert_eq!(
|
||||
cfs.open(&p_ctrl, opt_create.clone()).await.err(),
|
||||
Some(FsError::Forbidden)
|
||||
);
|
||||
|
||||
// 3. Gültige Datei erstellen
|
||||
let p_valid = DavPath::new("/valid.txt").unwrap();
|
||||
let file = cfs.open(&p_valid, opt_create).await;
|
||||
assert!(file.is_ok(), "Valid file should be created");
|
||||
drop(file);
|
||||
|
||||
// 4. rename mit ungültigem Zielnamen
|
||||
let p_com1 = DavPath::new("/COM1.txt").unwrap();
|
||||
assert_eq!(cfs.rename(&p_valid, &p_com1).await, Err(FsError::Forbidden));
|
||||
|
||||
// 5. copy mit ungültigem Zielnamen
|
||||
let p_lpt1 = DavPath::new("/LPT1").unwrap();
|
||||
assert_eq!(cfs.copy(&p_valid, &p_lpt1).await, Err(FsError::Forbidden));
|
||||
|
||||
let _ = std::fs::remove_file(&path);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_vfs_rejects_invalid_names() {
|
||||
use dav_server::davpath::DavPath;
|
||||
use dav_server::fs::{DavFileSystem, FsError, OpenOptions};
|
||||
use rand::rngs::OsRng;
|
||||
use rand::RngCore;
|
||||
use sanctum::crypto::{
|
||||
derive_kek, generate_dek, generate_salt, wrap_dek, KdfParams, FORMAT_VERSION,
|
||||
MIN_MEMORY_COST_KIB, MIN_TIME_COST,
|
||||
};
|
||||
use sanctum::storage::Database;
|
||||
use sanctum::vfs::SanctumFs;
|
||||
|
||||
let mut path = std::env::temp_dir();
|
||||
let id: u64 = OsRng.next_u64();
|
||||
path.push(format!("sanctum_test_vfs_pathval_{}.sanctum", id));
|
||||
if path.exists() {
|
||||
let _ = std::fs::remove_file(&path);
|
||||
}
|
||||
|
||||
let password = "TestPassword1234!";
|
||||
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, nonce, tag) = wrap_dek(&kek, &dek).unwrap();
|
||||
|
||||
let db = Database::open(&path).unwrap();
|
||||
db.init_schema(&salt, &kdf_params, &wrapped, &nonce, &tag)
|
||||
.unwrap();
|
||||
db.set_active_slot_and_dek(0, dek.clone());
|
||||
|
||||
let fs = SanctumFs::new(db.clone(), dek, FORMAT_VERSION);
|
||||
|
||||
// 1. create_dir mit ungültigem Namen
|
||||
let p_con = DavPath::new("/CON").unwrap();
|
||||
assert_eq!(fs.create_dir(&p_con).await, Err(FsError::Forbidden));
|
||||
|
||||
let p_aux = DavPath::new("/aux.txt").unwrap();
|
||||
assert_eq!(fs.create_dir(&p_aux).await, Err(FsError::Forbidden));
|
||||
|
||||
// 2. open (create) mit ungültigem Namen
|
||||
let p_nul = DavPath::new("/NUL").unwrap();
|
||||
let mut opt_create = OpenOptions::default();
|
||||
opt_create.create = true;
|
||||
opt_create.write = true;
|
||||
assert_eq!(
|
||||
fs.open(&p_nul, opt_create.clone()).await.err(),
|
||||
Some(FsError::Forbidden)
|
||||
);
|
||||
|
||||
let p_prn = DavPath::new("/prn.pdf").unwrap();
|
||||
assert_eq!(
|
||||
fs.open(&p_prn, opt_create.clone()).await.err(),
|
||||
Some(FsError::Forbidden)
|
||||
);
|
||||
|
||||
// 3. Gültige Datei erstellen
|
||||
let p_valid = DavPath::new("/valid.txt").unwrap();
|
||||
let file = fs.open(&p_valid, opt_create).await;
|
||||
assert!(file.is_ok(), "Valid file should be created");
|
||||
drop(file);
|
||||
|
||||
// 4. rename mit ungültigem Zielnamen
|
||||
let p_com1 = DavPath::new("/COM1.txt").unwrap();
|
||||
assert_eq!(fs.rename(&p_valid, &p_com1).await, Err(FsError::Forbidden));
|
||||
|
||||
// 5. copy mit ungültigem Zielnamen
|
||||
let p_lpt1 = DavPath::new("/LPT1").unwrap();
|
||||
assert_eq!(fs.copy(&p_valid, &p_lpt1).await, Err(FsError::Forbidden));
|
||||
|
||||
drop(fs);
|
||||
drop(db);
|
||||
let _ = std::fs::remove_file(&path);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user