harald/sanctum
1
0
Fork 0
Code Issues Pull Requests Actions 5 Packages Projects Releases 12 Wiki Activity

fix(vfs): V-03 — raii memory lock guard prevents premature memory unlock on fs clone

Browse Source
This commit is contained in:
harald
2026-09-19 09:10:35 +02:00
parent f9733dfc73
commit 52859623c2
3 changed files with 136 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/crypto.rs
+19 -6
View File
@@ -104,7 +104,20 @@ pub fn check_password_prefix_collision(pass0: &str, pass1: &str) -> Result<()> {
}
/// Leitet aus dem Master-Passwort und dem Salt einen 256-Bit Key Encryption Key (KEK) via Argon2id ab.
pub fn derive_kek(password: &str, salt: &[u8], params: &KdfParams) -> Result<Zeroizing<[u8; 32]>> {
/// RAII-Guard für kurzzeitige Stack-Puffer, um Lock-Leaks bei Fehlern oder Rückgabe zu verhindern (V-03).
struct ScopedMemoryLock(*const u8, usize);
impl Drop for ScopedMemoryLock {
fn drop(&mut self) {
crate::windows::unlock_memory(self.0, self.1);
}
}
pub fn derive_kek(
password: &str,
salt: &[u8; 16],
params: &KdfParams,
) -> Result<Zeroizing<[u8; 32]>> {
validate_kdf_params(params)?;
let argon2_params = Params::new(
@@ -118,12 +131,11 @@ pub fn derive_kek(password: &str, salt: &[u8], params: &KdfParams) -> Result<Zer
let argon2 = Argon2::new(Algorithm::Argon2id, Version::V0x13, argon2_params);
let mut kek = Zeroizing::new([0u8; 32]);
let _ = crate::windows::lock_memory(kek.as_ptr(), 32);
let _lock_guard = ScopedMemoryLock(kek.as_ptr(), 32);
let res = argon2.hash_password_into(password.as_bytes(), salt, &mut *kek);
if let Err(e) = res {
let _ = crate::windows::unlock_memory(kek.as_ptr(), 32);
bail!("Argon2id KDF-Berechnung fehlgeschlagen: {e}");
}
argon2
.hash_password_into(password.as_bytes(), salt, &mut *kek)
.map_err(|e| anyhow::anyhow!("Argon2id KDF-Berechnung fehlgeschlagen: {e}"))?;
Ok(kek)
}
@@ -132,6 +144,7 @@ pub fn derive_kek(password: &str, salt: &[u8], params: &KdfParams) -> Result<Zer
pub fn generate_dek() -> Zeroizing<[u8; 32]> {
let mut dek = Zeroizing::new([0u8; 32]);
let _ = crate::windows::lock_memory(dek.as_ptr(), 32);
let _lock_guard = ScopedMemoryLock(dek.as_ptr(), 32);
OsRng.fill_bytes(&mut *dek);
dek
}
src/vfs.rs
+52 -27
View File
@@ -94,6 +94,42 @@ impl DavDirEntry for SanctumDirEntry {
}
}
/// RAII-Guard für im physischen RAM verriegelte Schlüssel (VirtualLock / mlock).
/// Entriegelt den Speicherbereich via VirtualUnlock / munlock erst beim Drop der letzten verbleibenden Referenz (V-03).
#[derive(Debug)]
pub struct MemoryLockGuard(Zeroizing<[u8; 32]>);
impl MemoryLockGuard {
pub fn new(key: Zeroizing<[u8; 32]>) -> Self {
crate::windows::lock_memory(key.as_ptr(), 32);
Self(key)
}
pub fn key(&self) -> &Zeroizing<[u8; 32]> {
&self.0
}
}
impl std::ops::Deref for MemoryLockGuard {
type Target = Zeroizing<[u8; 32]>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl AsRef<[u8; 32]> for MemoryLockGuard {
fn as_ref(&self) -> &[u8; 32] {
&self.0
}
}
impl Drop for MemoryLockGuard {
fn drop(&mut self) {
crate::windows::unlock_memory(self.0.as_ptr(), 32);
}
}
// ---------------------------------------------------------------------------
// Datei-Handle mit Streaming & Chunk-Pufferung
// ---------------------------------------------------------------------------
@@ -103,7 +139,7 @@ pub struct SanctumFile {
file_size: u64,
cursor: u64,
db: Database,
dek: Arc<Zeroizing<[u8; 32]>>,
dek: Arc<MemoryLockGuard>,
meta: SanctumMetaData,
// (chunk_index, decrypted_payload, is_dirty)
cached_chunk: Option<(u32, Vec<u8>, bool)>,
@@ -126,7 +162,7 @@ impl SanctumFile {
pub fn new(
node: NodeRecord,
db: Database,
dek: Arc<Zeroizing<[u8; 32]>>,
dek: Arc<MemoryLockGuard>,
format_version: u32,
last_activity: Arc<AtomicU64>,
append: bool,
@@ -445,9 +481,9 @@ impl DavFile for SanctumFile {
#[derive(Clone)]
pub struct SanctumFs {
db: Database,
dek: Arc<Zeroizing<[u8; 32]>>,
dek: Arc<MemoryLockGuard>,
#[allow(dead_code)]
carrier_dek: Option<Arc<Zeroizing<[u8; 32]>>>,
carrier_dek: Option<Arc<MemoryLockGuard>>,
carrier_node_id: Option<i64>,
carrier_fs: Option<CarrierFs>,
format_version: u32,
@@ -493,10 +529,10 @@ impl SanctumFs {
.duration_since(UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
let dek_arc = Arc::new(dek);
let carrier_dek_arc = carrier_dek.map(Arc::new);
let dek_guard = Arc::new(MemoryLockGuard::new(dek));
let carrier_dek_guard = carrier_dek.map(|k| Arc::new(MemoryLockGuard::new(k)));
let db = db.with_session(vault_id, (*dek_arc).clone());
let db = db.with_session(vault_id, (*dek_guard.key()).clone());
// Im Decoy-Vault (Slot 0): Stelle sicher, dass carrier_node_id stets bekannt ist,
// um die Trägerdatei vor versehentlichem Löschen oder Überschreiben zu schützen.
@@ -509,12 +545,12 @@ impl SanctumFs {
});
let carrier_fs = if vault_id == 1 {
if let (Some(ref c_dek), Some(c_nid)) = (&carrier_dek_arc, carrier_node_id) {
if let (Some(ref c_dek), Some(c_nid)) = (&carrier_dek_guard, carrier_node_id) {
match CarrierFs::load(
db.clone(),
c_nid,
c_dek.clone(),
dek_arc.clone(),
Arc::new((*c_dek.key()).clone()),
Arc::new((*dek_guard.key()).clone()),
format_version,
anti_leak,
) {
@@ -531,16 +567,10 @@ impl SanctumFs {
None
};
// Forensischer RAM-Paging-Schutz via VirtualLock (verhindert Auslagerung in pagefile.sys)
crate::windows::lock_memory(dek_arc.as_ptr(), 32);
if let Some(ref c_dek) = carrier_dek_arc {
crate::windows::lock_memory(c_dek.as_ptr(), 32);
}
Self {
db,
dek: dek_arc,
carrier_dek: carrier_dek_arc,
dek: dek_guard,
carrier_dek: carrier_dek_guard,
carrier_node_id,
carrier_fs,
format_version,
@@ -550,6 +580,10 @@ impl SanctumFs {
}
}
pub fn dek_strong_count(&self) -> usize {
Arc::strong_count(&self.dek)
}
pub fn vault_id(&self) -> u32 {
self.vault_id
}
@@ -636,15 +670,6 @@ pub fn validate_path_safety(path: &str) -> Result<(), FsError> {
Ok(())
}
impl Drop for SanctumFs {
fn drop(&mut self) {
crate::windows::unlock_memory(self.dek.as_ptr(), 32);
if let Some(ref c_dek) = self.carrier_dek {
crate::windows::unlock_memory(c_dek.as_ptr(), 32);
}
}
}
impl DavFileSystem for SanctumFs {
fn open<'a>(
&'a self,
tests/mount_security_test.rs
+65
View File
@@ -154,3 +154,68 @@ fn test_mount_security_multi_auth_and_no_token_in_url() {
"Saubere URI darf kein Token enthalten"
);
}
#[tokio::test]
async fn test_vfs_memory_lock_retention_on_clone_v03() {
use dav_server::davpath::DavPath;
use dav_server::fs::{DavFileSystem, ReadDirMeta};
use futures_util::StreamExt;
use sanctum::vfs::SanctumFs;
let temp_dir = std::env::temp_dir();
let container_path: PathBuf =
temp_dir.join(format!("test_v03_lock_{}.sanctum", std::process::id()));
if container_path.exists() {
let _ = std::fs::remove_file(&container_path);
}
let salt = generate_salt();
let kdf_params = KdfParams {
memory_cost: MIN_MEMORY_COST_KIB,
time_cost: MIN_TIME_COST,
parallelism: 1,
};
let kek = derive_kek("TestPassV03!", &salt, &kdf_params).unwrap();
let dek = generate_dek();
let (wrapped_dek, nonce, tag) = wrap_dek(&kek, &dek).unwrap();
let db = Database::open(&container_path).unwrap();
db.init_schema(&salt, &kdf_params, &wrapped_dek, &nonce, &tag)
.unwrap();
// 1. Initialisiere SanctumFs
let fs = SanctumFs::new(db.clone(), dek, sanctum::crypto::FORMAT_VERSION);
assert_eq!(
fs.dek_strong_count(),
1,
"Anfangs muss genau 1 Referenz auf den verriegelten DEK existieren"
);
// 2. Klone SanctumFs (wie bei jeder HTTP/WebDAV-Anfrage im Server)
let fs_clone = fs.clone();
assert_eq!(
fs.dek_strong_count(),
2,
"Nach dem Klonen müssen 2 Referenzen existieren"
);
// 3. Droppe den Klon
drop(fs_clone);
// 4. V-03: Der Refcount muss nun wieder 1 sein. Der Speicherbereich darf NICHT
// vorzeitig über Drop eines Klons entriegelt worden sein!
assert_eq!(
fs.dek_strong_count(),
1,
"Nach Drop des Klons muss genau 1 Referenz erhalten bleiben"
);
// Verifiziere funktionale Nutzbarkeit nach Drop des Klons
let root_path = DavPath::new("/").unwrap();
let mut entries = fs.read_dir(&root_path, ReadDirMeta::None).await.unwrap();
assert!(entries.next().await.is_none());
drop(fs);
let _ = std::fs::remove_file(&container_path);
}