release: v0.7.2 — Security Audit Remediation (SA-01 bis SA-07)

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

src/verify.rs

@@ -43,11 +43,13 @@ pub fn verify_container(
     full_chunks: bool,
 ) -> Result<VerificationReport> {
     if !container_path.exists() {
-        bail!("Containerdatei '{}' existiert nicht.", container_path.display());
+        bail!(
+            "Containerdatei '{}' existiert nicht.",
+            container_path.display()
+        );
     }
 
-    let db = Database::open(container_path)
-        .context("Konnte Container-Datenbank nicht öffnen")?;
+    let db = Database::open(container_path).context("Konnte Container-Datenbank nicht öffnen")?;
 
     let mut report = VerificationReport {
         container_path: container_path.display().to_string(),
@@ -67,7 +69,8 @@ pub fn verify_container(
     };
 
     // 1. SQLite B-Tree & Foreign Key Prüfung
-    let sqlite_issues = db.run_sqlite_integrity_check()
+    let sqlite_issues = db
+        .run_sqlite_integrity_check()
         .context("Fehler bei der Ausführung des SQLite integrity_check")?;
     if !sqlite_issues.is_empty() {
         report.sqlite_ok = false;
@@ -96,13 +99,16 @@ pub fn verify_container(
     };
 
     // 3. Node-Hierarchie & Strukturprüfung
-    let (dirs, files, chunks_count) = db.count_nodes_and_chunks()
+    let (dirs, files, chunks_count) = db
+        .count_nodes_and_chunks()
         .context("Fehler beim Zählen der Knoten und Chunks")?;
     report.total_dirs = dirs;
     report.total_files = files;
     report.total_chunks = chunks_count;
 
-    let all_nodes = db.list_all_nodes().context("Fehler beim Laden der Knotenliste")?;
+    let all_nodes = db
+        .list_all_nodes()
+        .context("Fehler beim Laden der Knotenliste")?;
     report.total_nodes = all_nodes.len();
 
     let mut node_map = HashMap::new();
@@ -114,23 +120,33 @@ pub fn verify_container(
     match node_map.get(&1) {
         Some(root) => {
             if !root.is_dir {
-                report.errors.push("Root-Knoten (id=1) ist nicht als Verzeichnis markiert!".to_string());
+                report
+                    .errors
+                    .push("Root-Knoten (id=1) ist nicht als Verzeichnis markiert!".to_string());
             }
             if root.parent_id.is_some() {
-                report.errors.push("Root-Knoten (id=1) darf keinen Parent haben!".to_string());
+                report
+                    .errors
+                    .push("Root-Knoten (id=1) darf keinen Parent haben!".to_string());
             }
         }
         None => {
-            report.errors.push("Root-Knoten (id=1) fehlt in der nodes-Tabelle!".to_string());
+            report
+                .errors
+                .push("Root-Knoten (id=1) fehlt in der nodes-Tabelle!".to_string());
         }
     }
 
     if let Some(root2) = node_map.get(&2) {
         if !root2.is_dir {
-            report.errors.push("Root-Knoten (id=2) ist nicht als Verzeichnis markiert!".to_string());
+            report
+                .errors
+                .push("Root-Knoten (id=2) ist nicht als Verzeichnis markiert!".to_string());
         }
         if root2.parent_id.is_some() {
-            report.errors.push("Root-Knoten (id=2) darf keinen Parent haben!".to_string());
+            report
+                .errors
+                .push("Root-Knoten (id=2) darf keinen Parent haben!".to_string());
         }
     }
 
@@ -232,10 +248,14 @@ pub fn verify_container(
     };
 
     // 4. Kryptografische Chunk- & AEAD-Authentifizierungsprüfung
-    let chunk_headers = db.list_all_chunk_headers()
+    let chunk_headers = db
+        .list_all_chunk_headers()
         .context("Fehler beim Abrufen der Chunk-Liste")?;
 
-    let format_version = meta.as_ref().map(|m| m.version).unwrap_or(FORMAT_VERSION_V2);
+    let format_version = meta
+        .as_ref()
+        .map(|m| m.version)
+        .unwrap_or(FORMAT_VERSION_V2);
 
     for (node_id, chunk_index) in chunk_headers {
         if !node_map.contains_key(&node_id) {
@@ -319,7 +339,8 @@ mod tests {
         let (wrapped_dek, nonce, tag) = wrap_dek(&kek, &dek).unwrap();
 
         let db = Database::open(&container_path).unwrap();
-        db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag).unwrap();
+        db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag)
+            .unwrap();
 
         // Verzeichnis & Datei anlegen
         let folder = db.create_node(1, "photos", true).unwrap();
@@ -334,12 +355,21 @@ mod tests {
         let (ct1, n1, t1) = encrypt_chunk(&dek, file.id, 1, chunk1_data, FORMAT_VERSION).unwrap();
         db.write_chunk(file.id, 1, &n1, &t1, &ct1).unwrap();
 
-        db.update_node_size_and_time(file.id, (chunk0_data.len() + chunk1_data.len()) as u64, 1000).unwrap();
+        db.update_node_size_and_time(
+            file.id,
+            (chunk0_data.len() + chunk1_data.len()) as u64,
+            1000,
+        )
+        .unwrap();
         db.checkpoint().unwrap();
 
         // Verifizieren
         let report = verify_container(&container_path, Some(&dek), true).expect("Verify container");
-        assert!(report.is_healthy(), "Container must be healthy, report: {:?}", report);
+        assert!(
+            report.is_healthy(),
+            "Container must be healthy, report: {:?}",
+            report
+        );
         assert_eq!(report.total_files, 1);
         assert_eq!(report.total_dirs, 3); // Root 1 + Root 2 (Dual-Vault) + photos
         assert_eq!(report.total_chunks, 2);
@@ -371,7 +401,8 @@ mod tests {
         let (wrapped_dek, nonce, tag) = wrap_dek(&kek, &dek).unwrap();
 
         let db = Database::open(&container_path).unwrap();
-        db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag).unwrap();
+        db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag)
+            .unwrap();
 
         let file = db.create_node(1, "document.pdf", false).unwrap();
         let chunk_data = b"Vital documents that must not be corrupted";
@@ -387,14 +418,24 @@ mod tests {
         conn.execute(
             "UPDATE chunks SET ciphertext = ?1 WHERE node_id = ?2 AND chunk_index = 0",
             rusqlite::params![corrupted_ct, file.id],
-        ).unwrap();
+        )
+        .unwrap();
         drop(conn);
 
         // Verifizieren: Muss Bitrot via AEAD Tag-Fehler sofort entlarven!
         let report = verify_container(&container_path, Some(&dek), true).expect("Verify container");
-        assert!(!report.is_healthy(), "Container must report unhealthy due to bitrot");
-        assert_eq!(report.corrupted_chunks, 1, "Must detect exactly 1 corrupted chunk");
-        assert!(report.errors.iter().any(|e| e.contains("AEAD/Integritätsfehler")));
+        assert!(
+            !report.is_healthy(),
+            "Container must report unhealthy due to bitrot"
+        );
+        assert_eq!(
+            report.corrupted_chunks, 1,
+            "Must detect exactly 1 corrupted chunk"
+        );
+        assert!(report
+            .errors
+            .iter()
+            .any(|e| e.contains("AEAD/Integritätsfehler")));
 
         let _ = fs::remove_file(&container_path);
     }