1190 lines
35 KiB
Rust
1190 lines
35 KiB
Rust
use std::fs::{self, File};
|
|
use std::io::Write;
|
|
use std::path::Path;
|
|
|
|
use sanctum::crypto::{
|
|
derive_kek, generate_dek, generate_salt, wrap_dek, KdfParams, CHUNK_SIZE, FORMAT_VERSION,
|
|
};
|
|
use sanctum::storage::Database;
|
|
use sanctum::sync::{run_sync, SyncDirection, SyncOptions};
|
|
|
|
fn create_test_container(path: &Path) -> (Database, [u8; 32]) {
|
|
if path.exists() {
|
|
let _ = fs::remove_file(path);
|
|
}
|
|
let db = Database::open(path).expect("Open database");
|
|
let salt = generate_salt();
|
|
let kdf_params = KdfParams {
|
|
memory_cost: sanctum::crypto::MIN_MEMORY_COST_KIB,
|
|
time_cost: sanctum::crypto::MIN_TIME_COST,
|
|
parallelism: 1,
|
|
};
|
|
let kek = derive_kek("sync_password", &salt, &kdf_params).unwrap();
|
|
let dek = generate_dek();
|
|
let (wrapped_dek, header_nonce, header_tag) = wrap_dek(&kek, &dek).unwrap();
|
|
db.init_schema(&salt, &kdf_params, &wrapped_dek, &header_nonce, &header_tag)
|
|
.unwrap();
|
|
(db, *dek)
|
|
}
|
|
|
|
#[test]
|
|
fn test_sync_push_and_pull_basic() {
|
|
let temp_root =
|
|
std::env::temp_dir().join(format!("sanctum_sync_test_{}", rand::random::<u64>()));
|
|
let container_path = temp_root.join("test.sanctum");
|
|
let source_dir = temp_root.join("source");
|
|
let target_dir = temp_root.join("restored");
|
|
|
|
fs::create_dir_all(&source_dir).unwrap();
|
|
fs::create_dir_all(source_dir.join("sub")).unwrap();
|
|
|
|
// Testdateien anlegen
|
|
fs::write(source_dir.join("file1.txt"), b"Hello Sanctum Sync!").unwrap();
|
|
fs::write(
|
|
source_dir.join("sub").join("file2.bin"),
|
|
vec![0x42u8; 100_000],
|
|
)
|
|
.unwrap();
|
|
|
|
let (db, dek) = create_test_container(&container_path);
|
|
|
|
// 1. Push
|
|
let mut opts = SyncOptions::default();
|
|
opts.direction = SyncDirection::Push;
|
|
opts.quiet = true;
|
|
|
|
let stats = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
source_dir.to_str().unwrap(),
|
|
"/Backup",
|
|
&opts,
|
|
)
|
|
.expect("Sync push");
|
|
|
|
assert_eq!(stats.files_scanned, 2);
|
|
assert_eq!(stats.files_transferred, 2);
|
|
assert_eq!(stats.files_skipped, 0);
|
|
|
|
// 2. Erneuter Push (Fast check / Delta): Muss 0 übertragen, 2 überspringen
|
|
let stats_delta = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
source_dir.to_str().unwrap(),
|
|
"/Backup",
|
|
&opts,
|
|
)
|
|
.expect("Sync push delta");
|
|
|
|
assert_eq!(stats_delta.files_transferred, 0);
|
|
assert_eq!(stats_delta.files_skipped, 2);
|
|
|
|
// 3. Dry-Run mit neuer Datei
|
|
fs::write(source_dir.join("new_file.txt"), b"Brand new file").unwrap();
|
|
let mut dry_opts = opts.clone();
|
|
dry_opts.dry_run = true;
|
|
|
|
let stats_dry = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
source_dir.to_str().unwrap(),
|
|
"/Backup",
|
|
&dry_opts,
|
|
)
|
|
.expect("Sync push dry-run");
|
|
|
|
assert_eq!(stats_dry.files_transferred, 1);
|
|
assert_eq!(stats_dry.files_skipped, 2);
|
|
|
|
// Verifizieren, dass new_file.txt im Tresor tatsächlich NICHT existiert
|
|
let node = db
|
|
.resolve_path_in_vault("/Backup/new_file.txt", 0, &dek)
|
|
.unwrap();
|
|
assert!(node.is_none());
|
|
|
|
// 4. Pull
|
|
let mut pull_opts = SyncOptions::default();
|
|
pull_opts.direction = SyncDirection::Pull;
|
|
pull_opts.quiet = true;
|
|
|
|
let stats_pull = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
"/Backup",
|
|
target_dir.to_str().unwrap(),
|
|
&pull_opts,
|
|
)
|
|
.expect("Sync pull");
|
|
|
|
assert_eq!(stats_pull.files_transferred, 2);
|
|
|
|
// Inhalt vergleichen
|
|
let c1 = fs::read(target_dir.join("file1.txt")).unwrap();
|
|
assert_eq!(c1, b"Hello Sanctum Sync!");
|
|
let c2 = fs::read(target_dir.join("sub").join("file2.bin")).unwrap();
|
|
assert_eq!(c2, vec![0x42u8; 100_000]);
|
|
|
|
// Aufräumen
|
|
let _ = fs::remove_dir_all(&temp_root);
|
|
}
|
|
|
|
#[test]
|
|
fn test_sync_multi_megabyte_large_file() {
|
|
let temp_root =
|
|
std::env::temp_dir().join(format!("sanctum_sync_large_{}", rand::random::<u64>()));
|
|
let container_path = temp_root.join("test_large.sanctum");
|
|
let source_dir = temp_root.join("source");
|
|
let target_dir = temp_root.join("restored");
|
|
|
|
fs::create_dir_all(&source_dir).unwrap();
|
|
|
|
// 3.5 MB große Datei erzeugen (geht über 4 Chunks: 0, 1, 2, 3)
|
|
let large_file_path = source_dir.join("large_payload.bin");
|
|
let mut large_file = File::create(&large_file_path).unwrap();
|
|
let chunk_sample = vec![0xA5u8; CHUNK_SIZE];
|
|
for _ in 0..3 {
|
|
large_file.write_all(&chunk_sample).unwrap();
|
|
}
|
|
large_file.write_all(&vec![0x5Au8; 512 * 1024]).unwrap(); // 3.5 MB
|
|
large_file.flush().unwrap();
|
|
drop(large_file);
|
|
|
|
let (db, dek) = create_test_container(&container_path);
|
|
|
|
// Push
|
|
let mut opts = SyncOptions::default();
|
|
opts.direction = SyncDirection::Push;
|
|
opts.quiet = true;
|
|
|
|
let stats = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
source_dir.to_str().unwrap(),
|
|
"/LargeTest",
|
|
&opts,
|
|
)
|
|
.expect("Sync push large");
|
|
|
|
assert_eq!(stats.files_transferred, 1);
|
|
assert_eq!(
|
|
stats.bytes_transferred,
|
|
3 * (CHUNK_SIZE as u64) + 512 * 1024
|
|
);
|
|
|
|
// Pull
|
|
let mut pull_opts = SyncOptions::default();
|
|
pull_opts.direction = SyncDirection::Pull;
|
|
pull_opts.quiet = true;
|
|
|
|
run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
"/LargeTest",
|
|
target_dir.to_str().unwrap(),
|
|
&pull_opts,
|
|
)
|
|
.expect("Sync pull large");
|
|
|
|
let restored = fs::read(target_dir.join("large_payload.bin")).unwrap();
|
|
let original = fs::read(&large_file_path).unwrap();
|
|
assert_eq!(restored.len(), original.len());
|
|
assert_eq!(restored, original);
|
|
|
|
let _ = fs::remove_dir_all(&temp_root);
|
|
}
|
|
|
|
#[test]
|
|
fn test_sync_delete_and_exclude_flags() {
|
|
let temp_root =
|
|
std::env::temp_dir().join(format!("sanctum_sync_flags_{}", rand::random::<u64>()));
|
|
let container_path = temp_root.join("test_flags.sanctum");
|
|
let source_dir = temp_root.join("source");
|
|
|
|
fs::create_dir_all(&source_dir).unwrap();
|
|
fs::write(source_dir.join("keep.txt"), b"Keep this").unwrap();
|
|
fs::write(source_dir.join("remove_me.txt"), b"Will be deleted later").unwrap();
|
|
fs::write(source_dir.join("ignore.tmp"), b"Temporary file").unwrap();
|
|
|
|
let (db, dek) = create_test_container(&container_path);
|
|
|
|
let mut opts = SyncOptions::default();
|
|
opts.direction = SyncDirection::Push;
|
|
opts.exclude_patterns = vec!["*.tmp".to_string()];
|
|
opts.quiet = true;
|
|
|
|
// 1. Initialer Push mit Exclude
|
|
let stats = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
source_dir.to_str().unwrap(),
|
|
"/Files",
|
|
&opts,
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(stats.files_transferred, 2); // keep.txt und remove_me.txt
|
|
assert!(db
|
|
.resolve_path_in_vault("/Files/ignore.tmp", 0, &dek)
|
|
.unwrap()
|
|
.is_none());
|
|
|
|
// 2. Lokale Datei löschen und Sync mit --delete ausführen
|
|
fs::remove_file(source_dir.join("remove_me.txt")).unwrap();
|
|
opts.delete = true;
|
|
|
|
let stats_del = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
source_dir.to_str().unwrap(),
|
|
"/Files",
|
|
&opts,
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(stats_del.files_deleted, 1);
|
|
assert!(db
|
|
.resolve_path_in_vault("/Files/remove_me.txt", 0, &dek)
|
|
.unwrap()
|
|
.is_none());
|
|
assert!(db
|
|
.resolve_path_in_vault("/Files/keep.txt", 0, &dek)
|
|
.unwrap()
|
|
.is_some());
|
|
|
|
let _ = fs::remove_dir_all(&temp_root);
|
|
}
|
|
|
|
#[test]
|
|
fn test_s01_delete_preserves_excluded_files_and_directories() {
|
|
let temp_root =
|
|
std::env::temp_dir().join(format!("sanctum_s01_test_{}", rand::random::<u64>()));
|
|
let container_path = temp_root.join("test_s01.sanctum");
|
|
let source_dir = temp_root.join("source");
|
|
|
|
fs::create_dir_all(&source_dir).unwrap();
|
|
fs::create_dir_all(source_dir.join("excluded_dir")).unwrap();
|
|
fs::write(source_dir.join("normal.txt"), b"Normal file").unwrap();
|
|
fs::write(source_dir.join("document.pdf"), b"Important PDF").unwrap();
|
|
fs::write(
|
|
source_dir.join("excluded_dir").join("subfile.txt"),
|
|
b"Subfile in excluded dir",
|
|
)
|
|
.unwrap();
|
|
|
|
let (db, dek) = create_test_container(&container_path);
|
|
|
|
// 1. Initialer Push ALLER Dateien (ohne Exclude)
|
|
let mut opts = SyncOptions::default();
|
|
opts.direction = SyncDirection::Push;
|
|
opts.quiet = true;
|
|
|
|
run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
source_dir.to_str().unwrap(),
|
|
"/Data",
|
|
&opts,
|
|
)
|
|
.unwrap();
|
|
assert!(db
|
|
.resolve_path_in_vault("/Data/document.pdf", 0, &dek)
|
|
.unwrap()
|
|
.is_some());
|
|
assert!(db
|
|
.resolve_path_in_vault("/Data/excluded_dir/subfile.txt", 0, &dek)
|
|
.unwrap()
|
|
.is_some());
|
|
|
|
// 2. Lokale Kopie von document.pdf und excluded_dir entfernen
|
|
fs::remove_file(source_dir.join("document.pdf")).unwrap();
|
|
fs::remove_dir_all(source_dir.join("excluded_dir")).unwrap();
|
|
|
|
// 3. Sync Push mit --delete aber MIT --exclude "*.pdf" und --exclude "excluded_dir*"
|
|
opts.delete = true;
|
|
opts.delete_excluded = false;
|
|
opts.exclude_patterns = vec!["*.pdf".to_string(), "excluded_dir*".to_string()];
|
|
|
|
let stats = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
source_dir.to_str().unwrap(),
|
|
"/Data",
|
|
&opts,
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
stats.files_deleted, 0,
|
|
"Ausgeschlossene Dateien/Ordner dürfen NICHT gelöscht werden!"
|
|
);
|
|
|
|
// PDF und excluded_dir Teilbaum müssen im Tresor überlebt haben!
|
|
assert!(
|
|
db.resolve_path_in_vault("/Data/document.pdf", 0, &dek)
|
|
.unwrap()
|
|
.is_some(),
|
|
"PDF im Tresor muss überleben"
|
|
);
|
|
assert!(
|
|
db.resolve_path_in_vault("/Data/excluded_dir/subfile.txt", 0, &dek)
|
|
.unwrap()
|
|
.is_some(),
|
|
"Teilbaum in excluded_dir muss überleben"
|
|
);
|
|
|
|
// 4. Jetzt Push mit --delete UND --delete-excluded
|
|
opts.delete_excluded = true;
|
|
let stats_del = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
source_dir.to_str().unwrap(),
|
|
"/Data",
|
|
&opts,
|
|
)
|
|
.unwrap();
|
|
assert!(
|
|
stats_del.files_deleted >= 2,
|
|
"Mit --delete-excluded müssen die verwaisten ausgeschlossenen Dateien gelöscht werden"
|
|
);
|
|
assert!(
|
|
db.resolve_path_in_vault("/Data/document.pdf", 0, &dek)
|
|
.unwrap()
|
|
.is_none(),
|
|
"PDF muss mit --delete-excluded gelöscht sein"
|
|
);
|
|
assert!(
|
|
db.resolve_path_in_vault("/Data/excluded_dir/subfile.txt", 0, &dek)
|
|
.unwrap()
|
|
.is_none(),
|
|
"excluded_dir Inhalt muss gelöscht sein"
|
|
);
|
|
|
|
let _ = fs::remove_dir_all(&temp_root);
|
|
}
|
|
|
|
#[test]
|
|
fn test_s01_pull_delete_preserves_local_excluded_and_leak_files() {
|
|
let temp_root =
|
|
std::env::temp_dir().join(format!("sanctum_s01_pull_{}", rand::random::<u64>()));
|
|
let container_path = temp_root.join("test_s01_pull.sanctum");
|
|
let restore_dir = temp_root.join("restored");
|
|
|
|
fs::create_dir_all(&restore_dir).unwrap();
|
|
// Lokale Dateien anlegen, die im Vault NICHT existieren: folder.jpg (Leak file) und local_notes.pdf (Ausschluss)
|
|
fs::write(
|
|
restore_dir.join("folder.jpg"),
|
|
b"Album Art or Explorer Cache",
|
|
)
|
|
.unwrap();
|
|
fs::write(restore_dir.join("local_notes.pdf"), b"Private Local Notes").unwrap();
|
|
|
|
let (db, dek) = create_test_container(&container_path);
|
|
|
|
// Eine Datei im Vault anlegen
|
|
let root_node = db.get_node_by_id_in_vault(1, 0, &dek).unwrap().unwrap();
|
|
let _ = db
|
|
.create_node_in_vault(0, root_node.id, "vault_file.txt", false, &dek)
|
|
.unwrap();
|
|
|
|
// Pull mit --delete und --exclude "*.pdf"
|
|
let mut opts = SyncOptions::default();
|
|
opts.direction = SyncDirection::Pull;
|
|
opts.delete = true;
|
|
opts.delete_excluded = false;
|
|
opts.exclude_patterns = vec!["*.pdf".to_string()];
|
|
opts.quiet = true;
|
|
|
|
let stats = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
"/",
|
|
restore_dir.to_str().unwrap(),
|
|
&opts,
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
stats.files_deleted, 0,
|
|
"folder.jpg und local_notes.pdf dürfen bei Pull mit --delete NICHT gelöscht werden!"
|
|
);
|
|
assert!(
|
|
restore_dir.join("folder.jpg").exists(),
|
|
"folder.jpg muss auf dem Host erhalten bleiben"
|
|
);
|
|
assert!(
|
|
restore_dir.join("local_notes.pdf").exists(),
|
|
"local_notes.pdf muss auf dem Host erhalten bleiben"
|
|
);
|
|
|
|
// Pull mit --delete UND --delete-excluded
|
|
opts.delete_excluded = true;
|
|
run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
"/",
|
|
restore_dir.to_str().unwrap(),
|
|
&opts,
|
|
)
|
|
.unwrap();
|
|
assert!(
|
|
!restore_dir.join("local_notes.pdf").exists(),
|
|
"local_notes.pdf muss mit --delete-excluded gelöscht werden"
|
|
);
|
|
|
|
let _ = fs::remove_dir_all(&temp_root);
|
|
}
|
|
|
|
#[test]
|
|
fn test_s02_platform_independent_path_construction_and_traversal_rejection() {
|
|
let temp_root =
|
|
std::env::temp_dir().join(format!("sanctum_s02_test_{}", rand::random::<u64>()));
|
|
let container_path = temp_root.join("test.sanctum");
|
|
let source_dir = temp_root.join("source");
|
|
let target_dir = temp_root.join("restored");
|
|
|
|
fs::create_dir_all(&source_dir).unwrap();
|
|
let deep_dir = source_dir.join("level1").join("level2").join("level3");
|
|
fs::create_dir_all(&deep_dir).unwrap();
|
|
fs::write(deep_dir.join("deep_doc.txt"), b"Deeply nested content").unwrap();
|
|
|
|
let (db, dek) = create_test_container(&container_path);
|
|
|
|
// 1. Push: Übertrage mehrstufige Verzeichnisstruktur in den Tresor
|
|
let mut push_opts = SyncOptions::default();
|
|
push_opts.direction = SyncDirection::Push;
|
|
push_opts.quiet = true;
|
|
|
|
run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
source_dir.to_str().unwrap(),
|
|
"/MultiLevel",
|
|
&push_opts,
|
|
)
|
|
.expect("Sync push multi-level");
|
|
|
|
// 2. Pull: Prüfe, dass mehrstufige Pfade plattformunabhängig rekonstruiert werden
|
|
let mut pull_opts = SyncOptions::default();
|
|
pull_opts.direction = SyncDirection::Pull;
|
|
pull_opts.quiet = true;
|
|
|
|
run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
"/MultiLevel",
|
|
target_dir.to_str().unwrap(),
|
|
&pull_opts,
|
|
)
|
|
.expect("Sync pull multi-level");
|
|
|
|
let restored_file = target_dir
|
|
.join("level1")
|
|
.join("level2")
|
|
.join("level3")
|
|
.join("deep_doc.txt");
|
|
assert!(
|
|
restored_file.exists(),
|
|
"Mehrstufige Datei muss korrekt auf dem Host angelegt worden sein"
|
|
);
|
|
assert_eq!(fs::read(restored_file).unwrap(), b"Deeply nested content");
|
|
|
|
// 3. Traversal-Abwehr: Bösartiger Knoten mit relativem Ausbruchsversuch
|
|
// Simuliere manipulierten Knoten im Tresor
|
|
{
|
|
let conn = rusqlite::Connection::open(&container_path).unwrap();
|
|
// Erstelle Knoten mit manipuliertem Namen '../evil.txt'
|
|
conn.execute(
|
|
"INSERT INTO nodes (id, parent_id, name, is_dir, size, created_at, modified_at, is_carrier)
|
|
VALUES (9999, 1, '../evil.txt', 0, 10, 100, 100, 0)",
|
|
[],
|
|
)
|
|
.unwrap();
|
|
}
|
|
|
|
let malicious_target = temp_root.join("malicious_target");
|
|
fs::create_dir_all(&malicious_target).unwrap();
|
|
|
|
let pull_res = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
"/",
|
|
malicious_target.to_str().unwrap(),
|
|
&pull_opts,
|
|
);
|
|
|
|
assert!(
|
|
pull_res.is_err(),
|
|
"Sync Pull muss bei manipuliertem Traversal-Pfad abbrechen"
|
|
);
|
|
let err_msg = pull_res.unwrap_err().to_string();
|
|
assert!(
|
|
err_msg.contains("Path traversal")
|
|
|| err_msg.contains("Ungültiger Dateiname")
|
|
|| err_msg.contains("unzulässige Trennzeichen"),
|
|
"Fehlermeldung muss Traversal-Erkennung ausweisen: {}",
|
|
err_msg
|
|
);
|
|
assert!(
|
|
!temp_root.join("evil.txt").exists(),
|
|
"Es darf niemals eine Datei außerhalb des Zielverzeichnisses erzeugt werden"
|
|
);
|
|
|
|
// Aufräumen
|
|
let _ = fs::remove_dir_all(&temp_root);
|
|
}
|
|
|
|
#[test]
|
|
fn test_s03_symlink_skipping_and_cycle_protection() {
|
|
let temp_root =
|
|
std::env::temp_dir().join(format!("sanctum_s03_test_{}", rand::random::<u64>()));
|
|
let container_path = temp_root.join("test.sanctum");
|
|
let source_dir = temp_root.join("source");
|
|
let sub_dir = source_dir.join("sub");
|
|
|
|
fs::create_dir_all(&sub_dir).unwrap();
|
|
fs::write(source_dir.join("regular.txt"), b"Regular content").unwrap();
|
|
|
|
// Erzeuge eine rekursive Verknüpfung (Junction unter Windows / Symlink unter Unix)
|
|
let loop_path = sub_dir.join("cycle");
|
|
#[cfg(windows)]
|
|
{
|
|
let status = std::process::Command::new("powershell")
|
|
.args([
|
|
"-Command",
|
|
&format!(
|
|
"New-Item -ItemType Junction -Path '{}' -Target '{}'",
|
|
loop_path.display(),
|
|
source_dir.display()
|
|
),
|
|
])
|
|
.status();
|
|
if status.is_err() || !status.unwrap().success() {
|
|
eprintln!("Junction creation skipped (not supported in current environment)");
|
|
let _ = fs::remove_dir_all(&temp_root);
|
|
return;
|
|
}
|
|
}
|
|
#[cfg(unix)]
|
|
{
|
|
if let Err(e) = std::os::unix::fs::symlink(&source_dir, &loop_path) {
|
|
eprintln!("Symlink creation skipped: {e}");
|
|
let _ = fs::remove_dir_all(&temp_root);
|
|
return;
|
|
}
|
|
}
|
|
|
|
let (db, dek) = create_test_container(&container_path);
|
|
|
|
let mut opts = SyncOptions::default();
|
|
opts.direction = SyncDirection::Push;
|
|
opts.quiet = true;
|
|
|
|
// Ohne S-03 Fix würde der Sync endlos in die Schleife laufen und mit Stack-Overflow abstürzen.
|
|
// Mit Fix wird der Symlink übersprungen und gezählt.
|
|
let stats = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
source_dir.to_str().unwrap(),
|
|
"/SafePush",
|
|
&opts,
|
|
)
|
|
.expect("Sync push must succeed despite symlink cycle");
|
|
|
|
assert_eq!(
|
|
stats.files_transferred, 1,
|
|
"Nur reguläre Datei darf übertragen werden"
|
|
);
|
|
assert!(
|
|
stats.files_skipped_symlinks >= 1,
|
|
"Symlink/Junction muss erkannt und in files_skipped_symlinks gezählt werden"
|
|
);
|
|
|
|
// Aufräumen: Unter Windows Junction vor dem remove_dir_all entfernen
|
|
#[cfg(windows)]
|
|
{
|
|
let _ = std::process::Command::new("powershell")
|
|
.args([
|
|
"-Command",
|
|
&format!("[System.IO.Directory]::Delete('{}')", loop_path.display()),
|
|
])
|
|
.status();
|
|
}
|
|
let _ = fs::remove_dir_all(&temp_root);
|
|
}
|
|
|
|
#[test]
|
|
fn test_s04_toctou_file_size_uses_bytes_written() {
|
|
let temp_root =
|
|
std::env::temp_dir().join(format!("sanctum_s04_test_{}", rand::random::<u64>()));
|
|
let container_path = temp_root.join("test.sanctum");
|
|
let file_path = temp_root.join("race_file.bin");
|
|
|
|
fs::create_dir_all(&temp_root).unwrap();
|
|
let initial_data = vec![0xABu8; 12345];
|
|
fs::write(&file_path, &initial_data).unwrap();
|
|
|
|
let (db, dek) = create_test_container(&container_path);
|
|
|
|
// Sync file to vault
|
|
let res = sanctum::sync::sync_single_file_to_vault(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
&file_path,
|
|
1,
|
|
"race_file.bin",
|
|
false,
|
|
false,
|
|
)
|
|
.expect("Sync single file to vault");
|
|
|
|
match res {
|
|
sanctum::sync::FileTransferResult::Transferred { size } => {
|
|
assert_eq!(size, 12345);
|
|
}
|
|
_ => panic!("Expected FileTransferResult::Transferred"),
|
|
}
|
|
|
|
let node = db
|
|
.resolve_path_in_vault("/race_file.bin", 0, &dek)
|
|
.unwrap()
|
|
.expect("Node must exist");
|
|
assert_eq!(
|
|
node.size, 12345,
|
|
"Knotengröße muss exakt bytes_written entsprechen"
|
|
);
|
|
|
|
let _ = fs::remove_dir_all(&temp_root);
|
|
}
|
|
|
|
#[test]
|
|
fn test_s05_zero_byte_file_truncate_removes_all_chunks() {
|
|
let temp_root =
|
|
std::env::temp_dir().join(format!("sanctum_s05_test_{}", rand::random::<u64>()));
|
|
let container_path = temp_root.join("test.sanctum");
|
|
let file_path = temp_root.join("truncate_file.bin");
|
|
|
|
fs::create_dir_all(&temp_root).unwrap();
|
|
// 1. Zuerst große Datei mit 2.5 Chunks (> 2 MB) anlegen
|
|
let large_payload = vec![0xEEu8; 2_500_000];
|
|
fs::write(&file_path, &large_payload).unwrap();
|
|
|
|
let (db, dek) = create_test_container(&container_path);
|
|
|
|
// Initialer Push
|
|
sanctum::sync::sync_single_file_to_vault(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
&file_path,
|
|
1,
|
|
"truncate_file.bin",
|
|
false,
|
|
false,
|
|
)
|
|
.expect("Initial push of large file");
|
|
|
|
let node = db
|
|
.resolve_path_in_vault("/truncate_file.bin", 0, &dek)
|
|
.unwrap()
|
|
.expect("Node must exist");
|
|
assert_eq!(node.size, 2_500_000);
|
|
|
|
// Prüfe, dass Chunks existieren (3 Chunks: 0, 1, 2)
|
|
{
|
|
let conn = rusqlite::Connection::open(&container_path).unwrap();
|
|
let count: i64 = conn
|
|
.query_row(
|
|
"SELECT COUNT(*) FROM chunks WHERE node_id = ?1",
|
|
rusqlite::params![node.id],
|
|
|r| r.get(0),
|
|
)
|
|
.unwrap();
|
|
assert_eq!(count, 3, "Datei muss 3 Chunks besitzen");
|
|
}
|
|
|
|
// 2. Jetzt: Lokale Datei durch 0-Byte Datei ersetzen (Truncate auf 0 Bytes)
|
|
std::thread::sleep(std::time::Duration::from_millis(1100)); // Timestamp ändern
|
|
fs::write(&file_path, b"").unwrap();
|
|
|
|
let res = sanctum::sync::sync_single_file_to_vault(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
&file_path,
|
|
1,
|
|
"truncate_file.bin",
|
|
false,
|
|
false,
|
|
)
|
|
.expect("Push of 0-byte file");
|
|
|
|
match res {
|
|
sanctum::sync::FileTransferResult::Transferred { size } => {
|
|
assert_eq!(size, 0);
|
|
}
|
|
_ => panic!("Expected Transferred {{ size: 0 }}"),
|
|
}
|
|
|
|
// 3. Verifiziere: In SQLite darf KEIN EINZIGER Chunk mehr für diesen Knoten existieren!
|
|
// (Ohne den S-05 Fix blieb Chunk 0 fälschlicherweise in der Tabelle zurück)
|
|
{
|
|
let conn = rusqlite::Connection::open(&container_path).unwrap();
|
|
let count: i64 = conn
|
|
.query_row(
|
|
"SELECT COUNT(*) FROM chunks WHERE node_id = ?1",
|
|
rusqlite::params![node.id],
|
|
|r| r.get(0),
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
count, 0,
|
|
"Bei 0-Byte Datei müssen ALLE Chunks (inkl. Chunk 0) gelöscht sein (S-05)"
|
|
);
|
|
}
|
|
|
|
let updated_node = db
|
|
.resolve_path_in_vault("/truncate_file.bin", 0, &dek)
|
|
.unwrap()
|
|
.expect("Node must exist");
|
|
assert_eq!(updated_node.size, 0);
|
|
|
|
let _ = fs::remove_dir_all(&temp_root);
|
|
}
|
|
|
|
#[test]
|
|
fn test_s06_advisory_lock_blocks_sync_and_force_overrides() {
|
|
let temp_root =
|
|
std::env::temp_dir().join(format!("sanctum_s06_test_{}", rand::random::<u64>()));
|
|
let container_path = temp_root.join("test.sanctum");
|
|
let source_dir = temp_root.join("source");
|
|
|
|
fs::create_dir_all(&source_dir).unwrap();
|
|
fs::write(source_dir.join("test_lock.txt"), b"Locked content").unwrap();
|
|
|
|
let (db, dek) = create_test_container(&container_path);
|
|
|
|
// 1. Initial: Kein Lock aktiv
|
|
assert!(db.check_advisory_lock().unwrap().is_none());
|
|
|
|
// 2. Lock setzen (simuliert laufenden Mount)
|
|
db.acquire_advisory_lock(false)
|
|
.expect("Acquire advisory lock");
|
|
let active_lock = db.check_advisory_lock().unwrap();
|
|
assert!(active_lock.is_some());
|
|
let (pid, _host, _time) = active_lock.unwrap();
|
|
assert_eq!(pid, std::process::id());
|
|
|
|
let mut opts = SyncOptions::default();
|
|
opts.direction = SyncDirection::Push;
|
|
opts.quiet = true;
|
|
opts.force = false;
|
|
|
|
// 3. Sync ohne --force muss mit Lock-Fehler abbrechen
|
|
let sync_res = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
source_dir.to_str().unwrap(),
|
|
"/",
|
|
&opts,
|
|
);
|
|
assert!(
|
|
sync_res.is_err(),
|
|
"Sync ohne --force muss bei aktivem Advisory Lock abbrechen"
|
|
);
|
|
let err_msg = sync_res.unwrap_err().to_string();
|
|
assert!(
|
|
err_msg.contains("Container ist gesperrt"),
|
|
"Fehlermeldung muss Lock-Hinweis enthalten: {}",
|
|
err_msg
|
|
);
|
|
|
|
// 4. Sync mit --force muss trotz Lock erfolgreich durchlaufen
|
|
opts.force = true;
|
|
let sync_force_res = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
source_dir.to_str().unwrap(),
|
|
"/",
|
|
&opts,
|
|
);
|
|
assert!(
|
|
sync_force_res.is_ok(),
|
|
"Sync mit --force muss trotz aktivem Advisory Lock gelingen"
|
|
);
|
|
|
|
// 5. Lock freigeben
|
|
db.release_advisory_lock().expect("Release advisory lock");
|
|
assert!(db.check_advisory_lock().unwrap().is_none());
|
|
|
|
// 6. Sync ohne --force gelingt jetzt wieder
|
|
opts.force = false;
|
|
let sync_unlocked = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
source_dir.to_str().unwrap(),
|
|
"/",
|
|
&opts,
|
|
);
|
|
assert!(sync_unlocked.is_ok());
|
|
|
|
// 7. Stale Lock Test: Lock mit nicht mehr existierender PID wird automatisch bereinigt
|
|
{
|
|
let conn = rusqlite::Connection::open(&container_path).unwrap();
|
|
let current_host = std::env::var("COMPUTERNAME")
|
|
.or_else(|_| std::env::var("HOSTNAME"))
|
|
.unwrap_or_else(|_| "localhost".to_string());
|
|
conn.execute(
|
|
"UPDATE meta SET lock_pid = 99999999, lock_host = ?1, lock_time = 1000 WHERE slot_id = 0",
|
|
rusqlite::params![current_host],
|
|
)
|
|
.unwrap();
|
|
}
|
|
|
|
// check_advisory_lock erkennt den toten Prozess und räumt den Lock auf
|
|
assert!(
|
|
db.check_advisory_lock().unwrap().is_none(),
|
|
"Stale Lock eines toten Prozesses muss automatisch als None bewertet werden"
|
|
);
|
|
let sync_stale = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
source_dir.to_str().unwrap(),
|
|
"/",
|
|
&opts,
|
|
);
|
|
assert!(
|
|
sync_stale.is_ok(),
|
|
"Sync muss bei verwaistem Lock eines toten Prozesses ohne --force gelingen"
|
|
);
|
|
|
|
let _ = fs::remove_dir_all(&temp_root);
|
|
}
|
|
|
|
#[test]
|
|
fn test_s07_skip_invalid_windows_filenames_push_and_pull() {
|
|
let temp_root =
|
|
std::env::temp_dir().join(format!("sanctum_s07_test_{}", rand::random::<u64>()));
|
|
let container_path = temp_root.join("s07.sanctum");
|
|
let source_dir = temp_root.join("source");
|
|
let restore_dir = temp_root.join("restore");
|
|
|
|
fs::create_dir_all(&source_dir).unwrap();
|
|
fs::create_dir_all(&restore_dir).unwrap();
|
|
|
|
let (db, dek) = create_test_container(&container_path);
|
|
|
|
// Erstelle valide Dateien
|
|
fs::write(source_dir.join("valid1.txt"), b"Content 1").unwrap();
|
|
fs::write(source_dir.join("valid2.txt"), b"Content 2").unwrap();
|
|
|
|
// Versuche eine Datei mit ungültigem Namen anzulegen
|
|
// Unter Windows via extended path r"\\?\"
|
|
let extended_aux = format!(r"\\?\{}\aux.txt", source_dir.display());
|
|
let created_aux = fs::write(&extended_aux, b"reserved aux file").is_ok();
|
|
|
|
let mut opts = SyncOptions::default();
|
|
opts.direction = SyncDirection::Push;
|
|
opts.quiet = true;
|
|
|
|
// 1. Push: Darf bei Vorhandensein von aux.txt nicht abbrechen
|
|
let push_stats = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
source_dir.to_str().unwrap(),
|
|
"/",
|
|
&opts,
|
|
)
|
|
.expect("Push sync must not abort when encountering invalid filenames");
|
|
|
|
assert_eq!(push_stats.files_transferred, 2);
|
|
if created_aux {
|
|
assert!(push_stats.files_skipped_invalid >= 1);
|
|
}
|
|
|
|
// 2. Jetzt fügen wir manuell einen ungültigen Knoten in die Datenbank ein
|
|
// (z. B. von Linux oder externem Container importiert: "aux.txt")
|
|
{
|
|
let conn = rusqlite::Connection::open(&container_path).unwrap();
|
|
let root_id = Database::get_root_node_id_for_vault(0);
|
|
let now = 123456789;
|
|
conn.execute(
|
|
"INSERT INTO nodes (parent_id, name, is_dir, size, created_at, modified_at)
|
|
VALUES (?1, ?2, 0, 0, ?3, ?4)",
|
|
rusqlite::params![root_id, "aux.txt", now, now],
|
|
)
|
|
.unwrap();
|
|
}
|
|
|
|
// 3. Pull: Darf bei unzulässigem Knotennamen im Tresor nicht abbrechen
|
|
opts.direction = SyncDirection::Pull;
|
|
let pull_stats = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
"/",
|
|
restore_dir.to_str().unwrap(),
|
|
&opts,
|
|
)
|
|
.expect("Pull sync must not abort when encountering invalid filenames in vault");
|
|
|
|
// Valide Dateien müssen wiederhergestellt worden sein
|
|
assert!(restore_dir.join("valid1.txt").exists());
|
|
assert!(restore_dir.join("valid2.txt").exists());
|
|
assert_eq!(pull_stats.files_transferred, 2);
|
|
assert_eq!(pull_stats.files_skipped_invalid, 1);
|
|
|
|
if created_aux {
|
|
let _ = fs::remove_file(&extended_aux);
|
|
}
|
|
let _ = fs::remove_dir_all(&temp_root);
|
|
}
|
|
|
|
#[test]
|
|
fn test_s08_refined_glob_and_directory_exclusions() {
|
|
let temp_root =
|
|
std::env::temp_dir().join(format!("sanctum_s08_test_{}", rand::random::<u64>()));
|
|
let container_path = temp_root.join("s08.sanctum");
|
|
let source_dir = temp_root.join("source");
|
|
let restore_dir = temp_root.join("restore");
|
|
|
|
fs::create_dir_all(&source_dir).unwrap();
|
|
fs::create_dir_all(source_dir.join("build")).unwrap();
|
|
fs::create_dir_all(source_dir.join("logs")).unwrap();
|
|
fs::create_dir_all(source_dir.join("node_modules").join("dep")).unwrap();
|
|
fs::create_dir_all(&restore_dir).unwrap();
|
|
|
|
let (db, dek) = create_test_container(&container_path);
|
|
|
|
// Dateien anlegen
|
|
fs::write(source_dir.join("main.rs"), b"fn main() {}").unwrap();
|
|
fs::write(source_dir.join("temp_1.tmp"), b"junk 1").unwrap();
|
|
fs::write(source_dir.join("build").join("output.bin"), b"binary").unwrap();
|
|
fs::write(source_dir.join("build").join("notes.txt"), b"keep notes").unwrap();
|
|
fs::write(source_dir.join("logs").join("sync.log"), b"log data").unwrap();
|
|
fs::write(
|
|
source_dir.join("node_modules").join("dep").join("lib.js"),
|
|
b"module code",
|
|
)
|
|
.unwrap();
|
|
|
|
let mut opts = SyncOptions::default();
|
|
opts.direction = SyncDirection::Push;
|
|
opts.quiet = true;
|
|
opts.exclude_patterns = vec![
|
|
"*.tmp".to_string(),
|
|
"build/*.bin".to_string(),
|
|
"logs/".to_string(),
|
|
"node_modules".to_string(),
|
|
];
|
|
|
|
// 1. Push
|
|
let push_stats = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
source_dir.to_str().unwrap(),
|
|
"/",
|
|
&opts,
|
|
)
|
|
.expect("Push sync with refined glob exclusions");
|
|
|
|
// Übertragen werden dürfen nur: main.rs und build/notes.txt (2 Dateien)
|
|
// Ausgeschlossen: temp_1.tmp (*.tmp), build/output.bin (build/*.bin), logs/sync.log (logs/), node_modules/dep/lib.js (node_modules)
|
|
assert_eq!(push_stats.files_transferred, 2);
|
|
|
|
// 2. Pull
|
|
opts.direction = SyncDirection::Pull;
|
|
let pull_stats = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
"/",
|
|
restore_dir.to_str().unwrap(),
|
|
&opts,
|
|
)
|
|
.expect("Pull sync with refined glob exclusions");
|
|
|
|
assert_eq!(pull_stats.files_transferred, 2);
|
|
assert!(restore_dir.join("main.rs").exists());
|
|
assert!(restore_dir.join("build").join("notes.txt").exists());
|
|
assert!(!restore_dir.join("temp_1.tmp").exists());
|
|
assert!(!restore_dir.join("build").join("output.bin").exists());
|
|
assert!(!restore_dir.join("logs").join("sync.log").exists());
|
|
assert!(!restore_dir.join("node_modules").exists());
|
|
|
|
let _ = fs::remove_dir_all(&temp_root);
|
|
}
|
|
|
|
#[test]
|
|
fn test_s09_pull_backup_and_update_conflict_safety() {
|
|
let temp_root =
|
|
std::env::temp_dir().join(format!("sanctum_s09_test_{}", rand::random::<u64>()));
|
|
let container_path = temp_root.join("s09.sanctum");
|
|
let source_dir = temp_root.join("source");
|
|
let local_dest_dir = temp_root.join("dest");
|
|
|
|
fs::create_dir_all(&source_dir).unwrap();
|
|
fs::create_dir_all(&local_dest_dir).unwrap();
|
|
|
|
let (db, dek) = create_test_container(&container_path);
|
|
|
|
// Datei in den Tresor laden
|
|
fs::write(source_dir.join("document.txt"), b"Vault Version 2.0").unwrap();
|
|
fs::write(source_dir.join("notes.txt"), b"Older Vault Notes").unwrap();
|
|
|
|
let mut push_opts = SyncOptions::default();
|
|
push_opts.direction = SyncDirection::Push;
|
|
push_opts.quiet = true;
|
|
run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
source_dir.to_str().unwrap(),
|
|
"/",
|
|
&push_opts,
|
|
)
|
|
.unwrap();
|
|
|
|
// 1. Test Backup-Erstellung (--backup):
|
|
// Lokale Datei anlegen mit eigenem Inhalt
|
|
let local_doc = local_dest_dir.join("document.txt");
|
|
fs::write(&local_doc, b"Local Version 1.0 (Must be backed up)").unwrap();
|
|
|
|
let mut pull_opts = SyncOptions::default();
|
|
pull_opts.direction = SyncDirection::Pull;
|
|
pull_opts.quiet = true;
|
|
pull_opts.backup = true;
|
|
|
|
let pull_stats = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
"/",
|
|
local_dest_dir.to_str().unwrap(),
|
|
&pull_opts,
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(pull_stats.files_backed_up, 1);
|
|
assert_eq!(fs::read(&local_doc).unwrap(), b"Vault Version 2.0");
|
|
|
|
let backup_doc = local_dest_dir.join("document.txt.bak");
|
|
assert!(
|
|
backup_doc.exists(),
|
|
"Backup-Datei .bak muss angelegt worden sein"
|
|
);
|
|
assert_eq!(
|
|
fs::read(&backup_doc).unwrap(),
|
|
b"Local Version 1.0 (Must be backed up)"
|
|
);
|
|
|
|
// 2. Test Konfliktschutz (--update):
|
|
// Erzeuge lokale notes.txt mit neuerem Timestamp
|
|
let local_notes = local_dest_dir.join("notes.txt");
|
|
fs::write(&local_notes, b"Newer Local Notes").unwrap();
|
|
let future_time = std::time::UNIX_EPOCH + std::time::Duration::from_secs(2_000_000_000);
|
|
fs::OpenOptions::new()
|
|
.write(true)
|
|
.open(&local_notes)
|
|
.unwrap()
|
|
.set_times(std::fs::FileTimes::new().set_modified(future_time))
|
|
.expect("Set modified time on local_notes");
|
|
|
|
let mut update_opts = SyncOptions::default();
|
|
update_opts.direction = SyncDirection::Pull;
|
|
update_opts.quiet = true;
|
|
update_opts.update = true;
|
|
|
|
let update_stats = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
"/",
|
|
local_dest_dir.to_str().unwrap(),
|
|
&update_opts,
|
|
)
|
|
.unwrap();
|
|
|
|
// notes.txt darf NICHT überschrieben worden sein
|
|
assert_eq!(
|
|
fs::read(&local_notes).unwrap(),
|
|
b"Newer Local Notes",
|
|
"Neuere lokale Datei darf mit --update nicht überschrieben werden"
|
|
);
|
|
assert!(update_stats.files_skipped >= 1);
|
|
|
|
// Mit --force muss sie überschrieben werden
|
|
update_opts.force = true;
|
|
let force_stats = run_sync(
|
|
&db,
|
|
0,
|
|
&dek,
|
|
FORMAT_VERSION,
|
|
"/",
|
|
local_dest_dir.to_str().unwrap(),
|
|
&update_opts,
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(
|
|
fs::read(&local_notes).unwrap(),
|
|
b"Older Vault Notes",
|
|
"Mit --force muss die neuere Datei dennoch überschrieben werden"
|
|
);
|
|
assert_eq!(force_stats.files_transferred, 1);
|
|
|
|
let _ = fs::remove_dir_all(&temp_root);
|
|
}
|