25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
fix(core): cache resolved secret codec per storage instance
zipg8e0b2ff49676
diff --git a/crates/dbx-core/src/persistence/secret_codec.rs b/crates/dbx-core/src/persistence/secret_codec.rsindex 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<std::path::PathBuf> {+ 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<SecretCodec, String> {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.rsindex 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<Mutex<Option<CachedSecretCodec>>>,+}++/// 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<SecretCodec, String> {- 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<SecretCodec> {+ 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<SecretCodec, String> {@@ -1592,6 +1662,9 @@ impl Storage {pub async fn start_data_migration(&self) -> Result<MigrationReport, String> {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<String, String> {+ 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();