diff --git a/crates/dbx-core/src/persistence/secret_codec.rs b/crates/dbx-core/src/persistence/secret_codec.rs index b86e9e87c5..ffb4595d3a 100644 --- a/crates/dbx-core/src/persistence/secret_codec.rs +++ b/crates/dbx-core/src/persistence/secret_codec.rs @@ -473,6 +473,21 @@ pub fn managed_key_path(data_dir: &std::path::Path) -> std::path::PathBuf { data_dir.join(".dbx").join("secret.key") } +/// Every file that can supply key material on its own, in resolution order. +/// Callers that cache a resolved codec can digest these paths to notice a key +/// file that was added, replaced, or removed afterwards. +pub fn key_file_candidates(data_dir: &std::path::Path) -> Vec { + let mut paths = Vec::new(); + if let Some(path) = std::env::var_os("DBX_SECRET_KEY_FILE") { + paths.push(std::path::PathBuf::from(path)); + } + if let Some(path) = default_key_path() { + paths.push(path); + } + paths.push(managed_key_path(data_dir)); + paths +} + fn read_key_file_with_retry(path: &std::path::Path, reject_symlink: bool) -> Result { let mut last_error = "KEY_FILE_UNAVAILABLE".to_string(); for attempt in 0..20 { diff --git a/crates/dbx-core/src/persistence/storage.rs b/crates/dbx-core/src/persistence/storage.rs index 1f6be0a24a..3ff544bac4 100644 --- a/crates/dbx-core/src/persistence/storage.rs +++ b/crates/dbx-core/src/persistence/storage.rs @@ -5,7 +5,7 @@ pub use dbx_drivers::runtime_config::{ use std::collections::{HashMap, HashSet}; use std::path::{Path, PathBuf}; -use std::sync::OnceLock; +use std::sync::{Arc, Mutex, OnceLock}; use std::time::{SystemTime, UNIX_EPOCH}; use log::warn; @@ -34,7 +34,9 @@ use crate::history::{ HistorySearchRequest, HistorySearchResult, MAX_HISTORY, }; use crate::models::connection::{ConnectionConfig, DatabaseConnectionInfo, DatabaseType, TransportLayerConfig}; -use crate::persistence::secret_codec::{SecretCodec, SecretKeyPolicy, SecretKeyResolution, SecretKeySource}; +use crate::persistence::secret_codec::{ + key_file_candidates, SecretCodec, SecretKeyPolicy, SecretKeyResolution, SecretKeySource, +}; use crate::prompt_template::PromptTemplate; use crate::saved_sql::{SavedSqlFile, SavedSqlFolder, SavedSqlLibrary}; @@ -193,6 +195,16 @@ pub struct Storage { /// Standalone CLI/MCP processes may use an existing key but must never /// provision one as a side effect of a write. secret_key_creation_allowed: bool, + /// Key material resolved for business reads and writes. Every resolution + /// round-trips to the OS credential store, so hydrating N stored secrets + /// used to mean N credential-store accesses on the startup path. + secret_codec_cache: Arc>>, +} + +/// Key material plus the digest of every key file it was resolved from. +struct CachedSecretCodec { + codec: SecretCodec, + key_files: Vec<(PathBuf, Option<[u8; 32]>)>, } pub const SECRET_STORE_MIGRATION_ID: &str = "secret-store-v1"; @@ -1188,8 +1200,13 @@ impl Storage { let path = db_path.to_path_buf(); let db_path = db_path.to_string_lossy().to_string(); let db = connect_path_create_if_missing(&db_path).await?; - let storage = - Self { db, path, secret_key_policy: SecretKeyPolicy::PlatformDefault, secret_key_creation_allowed: true }; + let storage = Self { + db, + path, + secret_key_policy: SecretKeyPolicy::PlatformDefault, + secret_key_creation_allowed: true, + secret_codec_cache: Arc::new(Mutex::new(None)), + }; // Best-effort: switching journal mode is itself a lock-sensitive // operation, so a transient failure here (e.g. another process // racing to open the same brand-new database file) must never stop @@ -1229,8 +1246,61 @@ impl Storage { SecretCodec::resolve(self.secret_key_policy, self.data_dir(), allow_create) } + /// Resolution cost is dominated by the platform credential store, so the + /// codec is cached for the process. Key files are re-digested on every use, + /// and migration invalidates the cache, so no caller serves material that + /// the provider no longer agrees with. Callers that must observe a key + /// change immediately (status probes, migration) use `resolve_secret_key`. fn secret_codec(&self, allow_create: bool) -> Result { - self.resolve_secret_key(allow_create).map(|resolved| resolved.codec) + if let Some(cached) = self.cached_secret_codec() { + return Ok(cached); + } + let key_files = self.key_file_digests(); + let codec = self.resolve_secret_key(allow_create).map(|resolved| resolved.codec)?; + // Pair the codec with the pre-resolve digests, and only when the key + // files are unchanged across the resolve. A pair taken after resolving + // could combine a stale codec with fresh digests, which the use-time + // digest check would then never reject. + if self.key_file_digests() == key_files { + self.cache_secret_codec(codec, key_files); + } + Ok(codec) + } + + fn cached_secret_codec(&self) -> Option { + let mut cache = self.secret_codec_cache.lock().unwrap_or_else(|poisoned| poisoned.into_inner()); + let cached = cache.as_ref()?; + let codec = cached.codec; + let resolved_key_files = cached.key_files.clone(); + if resolved_key_files != self.key_file_digests() { + // A key file was added, replaced, or removed after resolution. + *cache = None; + return None; + } + Some(codec) + } + + fn cache_secret_codec(&self, codec: SecretCodec, key_files: Vec<(PathBuf, Option<[u8; 32]>)>) { + let entry = CachedSecretCodec { codec, key_files }; + *self.secret_codec_cache.lock().unwrap_or_else(|poisoned| poisoned.into_inner()) = Some(entry); + } + + fn invalidate_secret_codec(&self) { + *self.secret_codec_cache.lock().unwrap_or_else(|poisoned| poisoned.into_inner()) = None; + } + + /// Digest of every file that can supply key material on its own. Comparing + /// these on use costs a few small reads instead of a credential-store + /// round trip, and still catches a key file replaced outside DBX. + fn key_file_digests(&self) -> Vec<(PathBuf, Option<[u8; 32]>)> { + use sha2::Digest; + key_file_candidates(self.data_dir()) + .into_iter() + .map(|path| { + let digest = std::fs::read(&path).ok().map(|contents| sha2::Sha256::digest(contents).into()); + (path, digest) + }) + .collect() } async fn secret_codec_for_write(&self, needs_key: bool) -> Result { @@ -1592,6 +1662,9 @@ impl Storage { pub async fn start_data_migration(&self) -> Result { let lock = DATA_MIGRATION_LOCK.get_or_init(|| tokio::sync::Mutex::new(())).lock().await; + // Migration may create or replace key material, so the codec resolved + // for earlier reads must not be reused here. + self.invalidate_secret_codec(); let preflight = self.inspect_data_migration().await?; if preflight.is_ready() { return Ok(MigrationReport { @@ -8326,7 +8399,7 @@ mod tests { use crate::models::connection::{ ConnectionConfig, DatabaseConnectionInfo, DatabaseType, HttpTunnelConfig, SshTunnelConfig, TransportLayerConfig, }; - use crate::persistence::secret_codec::{managed_key_path, SecretKeyPolicy}; + use crate::persistence::secret_codec::{managed_key_path, SecretCodec, SecretKeyPolicy}; use crate::saved_sql::{SavedSqlFile, SavedSqlFolder, SavedSqlLibrary}; use rusqlite::{Connection, TransactionBehavior}; use std::collections::BTreeMap; @@ -8554,6 +8627,44 @@ mod tests { assert_eq!(reopened.get_secret("legacy", "password").await.unwrap().as_deref(), Some("secret")); } + /// Reads through the same codec path business reads use, so a cached codec + /// has to produce the right plaintext for the assertion to hold. + fn open_with_resolved_codec(storage: &Storage, envelope: &str) -> Result { + storage.secret_codec(false)?.decrypt("connection", "password", envelope) + } + + #[tokio::test] + async fn resolved_secret_codec_is_cached_until_a_key_file_changes() { + // Hydrating stored secrets used to re-resolve key material per secret, + // which on the desktop means one OS credential-store round trip per + // secret on the startup path. + let dir = tempfile::tempdir().unwrap(); + let storage = Storage::open_unmigrated(&dir.path().join("dbx.db")) + .await + .unwrap() + .with_secret_key_policy(SecretKeyPolicy::ManagedDataDir); + let key_path = managed_key_path(dir.path()); + std::fs::create_dir_all(key_path.parent().unwrap()).unwrap(); + std::fs::write(&key_path, "ab".repeat(32)).unwrap(); + let file_codec = storage.secret_codec(false).unwrap(); + let envelope = file_codec.encrypt("connection", "password", "secret").unwrap(); + + storage.cache_secret_codec(SecretCodec::new([7u8; 32]), storage.key_file_digests()); + // Business reads answer from the cached codec instead of re-reading the + // key file, so an envelope sealed with the file key stays shut. + assert_eq!(open_with_resolved_codec(&storage, &envelope), Err("secret decryption failed".to_string())); + + // Replacing the key file drops the cached codec, so the next read uses + // the material the provider now reports. + std::fs::write(&key_path, "cd".repeat(32)).unwrap(); + assert!(storage.cached_secret_codec().is_none()); + assert_eq!(open_with_resolved_codec(&storage, &envelope), Err("secret decryption failed".to_string())); + + // Restoring the original material restores the working codec. + std::fs::write(&key_path, "ab".repeat(32)).unwrap(); + assert_eq!(open_with_resolved_codec(&storage, &envelope).as_deref(), Ok("secret")); + } + #[tokio::test] async fn secret_migration_rejects_wrong_or_invalid_managed_keys_without_replacing_them() { let directory = tempfile::tempdir().unwrap();