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(security): avoid repeated kde secret store probes
二丫讲梵cc87ab0cd128
diff --git a/crates/dbx-core/src/persistence/storage.rs b/crates/dbx-core/src/persistence/storage.rsindex 2765bfa2f1..1fefb5445d 100644--- a/crates/dbx-core/src/persistence/storage.rs+++ b/crates/dbx-core/src/persistence/storage.rs@@ -207,6 +207,9 @@ pub struct Storage {/// 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>>>,+ /// A failed platform lookup is cached for the startup boundary as well.+ /// Without this, each consumer can prompt a locked Secret Service again.+ secret_key_error_cache: Arc<Mutex<Option<CachedSecretKeyError>>>,migration_failure: Arc<Mutex<Option<MigrationFailure>>>,}@@ -216,6 +219,11 @@ struct CachedSecretCodec {key_files: Vec<(PathBuf, Option<[u8; 32]>)>,}+struct CachedSecretKeyError {+ error: String,+ key_files: Vec<(PathBuf, Option<[u8; 32]>)>,+}+#[derive(Clone)]struct MigrationFailure {code: String,@@ -1301,6 +1309,7 @@ impl Storage {secret_key_policy: SecretKeyPolicy::PlatformDefault,secret_key_creation_allowed: true,secret_codec_cache: Arc::new(Mutex::new(None)),+ secret_key_error_cache: Arc::new(Mutex::new(None)),migration_failure: Arc::new(Mutex::new(None)),};// Best-effort: switching journal mode is itself a lock-sensitive@@ -1339,7 +1348,27 @@ impl Storage {}fn resolve_secret_key(&self, allow_create: bool) -> Result<SecretKeyResolution, String> {- SecretCodec::resolve(self.secret_key_policy, self.data_dir(), allow_create)+ if !allow_create {+ let key_files = self.key_file_digests();+ let mut cache = self.secret_key_error_cache.lock().unwrap_or_else(|poisoned| poisoned.into_inner());+ if let Some(cached) = cache.as_ref() {+ if cached.key_files == key_files {+ return Err(cached.error.clone());+ }+ *cache = None;+ }+ }+ let resolved = SecretCodec::resolve(self.secret_key_policy, self.data_dir(), allow_create)?;+ // A fresh successful resolve supersedes any cached failure recorded+ // while the platform store was locked or unavailable, so read-only+ // callers stop serving the stale error once the provider recovers.+ *self.secret_key_error_cache.lock().unwrap_or_else(|poisoned| poisoned.into_inner()) = None;+ Ok(resolved)+ }++ fn cache_secret_key_error(&self, error: &str, key_files: Vec<(PathBuf, Option<[u8; 32]>)>) {+ *self.secret_key_error_cache.lock().unwrap_or_else(|poisoned| poisoned.into_inner()) =+ Some(CachedSecretKeyError { error: error.to_string(), key_files });}/// Resolution cost is dominated by the platform credential store, so the@@ -1389,6 +1418,7 @@ impl Storage {fn invalidate_secret_codec(&self) {*self.secret_codec_cache.lock().unwrap_or_else(|poisoned| poisoned.into_inner()) = None;+ *self.secret_key_error_cache.lock().unwrap_or_else(|poisoned| poisoned.into_inner()) = None;}/// Digest of every file that can supply key material on its own. Comparing@@ -1635,6 +1665,11 @@ impl Storage {// entry, key file, or change permissions while displaying status.let key_files_before = self.key_file_digests();let key_probe = self.resolve_secret_key(false);+ if let Err(error) = key_probe.as_ref() {+ // Keep one startup probe from being repeated by each subsequent+ // storage read while the desktop keyring is locked or unavailable.+ self.cache_secret_key_error(error, key_files_before.clone());+ }let mut key_provider_available = key_probe.is_ok();let database_plaintext_count = (plaintext + ai + tunnels).max(0) as usize;let has_legacy_data =@@ -9341,6 +9376,68 @@ mod tests {assert_eq!(open_with_resolved_codec(&storage, &envelope).as_deref(), Ok("secret"));}+ /// Seeds the read-only error cache the way the startup status probe does+ /// after a failed platform lookup. The sentinel string cannot be produced+ /// by a real resolve, so observing it proves the cached error was served+ /// without consulting the provider again.+ fn cache_locked_keyring_error(storage: &Storage) {+ let digests = storage.key_file_digests();+ storage.cache_secret_key_error("CACHED_KEYRING_LOCKED", digests);+ }++ async fn storage_with_managed_key(directory: &std::path::Path) -> Storage {+ let key_path = managed_key_path(directory);+ std::fs::create_dir_all(key_path.parent().unwrap()).unwrap();+ std::fs::write(&key_path, "ab".repeat(32)).unwrap();+ Storage::open_unmigrated(&directory.join("dbx.db"))+ .await+ .unwrap()+ .with_secret_key_policy(SecretKeyPolicy::ManagedDataDir)+ }++ #[tokio::test]+ async fn cached_secret_key_error_is_served_to_read_only_resolves() {+ // One failed startup probe must not be repeated by every subsequent+ // read-only consumer while the desktop keyring stays locked.+ let dir = tempfile::tempdir().unwrap();+ let storage = storage_with_managed_key(dir.path()).await;+ cache_locked_keyring_error(&storage);+ assert_eq!(storage.resolve_secret_key(false).err().unwrap(), "CACHED_KEYRING_LOCKED");+ assert_eq!(storage.secret_codec(false).err().unwrap(), "CACHED_KEYRING_LOCKED");++ // A key file change invalidates the cached error, so the next+ // read-only resolve consults the provider again.+ std::fs::write(managed_key_path(dir.path()), "cd".repeat(32)).unwrap();+ assert!(storage.secret_codec(false).is_ok());+ }++ #[tokio::test]+ async fn successful_resolve_clears_cached_secret_key_error() {+ // Once any resolve succeeds against a recovered provider, the stale+ // cached failure must be retired instead of outliving the recovery.+ let dir = tempfile::tempdir().unwrap();+ let storage = storage_with_managed_key(dir.path()).await;+ cache_locked_keyring_error(&storage);+ assert_eq!(storage.resolve_secret_key(false).err().unwrap(), "CACHED_KEYRING_LOCKED");+ // A create-allowed resolve bypasses the read-only guard; its success+ // drops the cached error for later read-only callers.+ assert!(storage.resolve_secret_key(true).is_ok());+ assert!(storage.resolve_secret_key(false).is_ok());+ assert!(storage.secret_codec(false).is_ok());+ }++ #[tokio::test]+ async fn start_data_migration_invalidates_cached_secret_key_error() {+ // Migration must re-probe the live provider instead of trusting a+ // stale failure cached at startup.+ let dir = tempfile::tempdir().unwrap();+ let storage = storage_with_managed_key(dir.path()).await;+ cache_locked_keyring_error(&storage);+ assert_eq!(storage.resolve_secret_key(false).err().unwrap(), "CACHED_KEYRING_LOCKED");+ storage.start_data_migration().await.unwrap();+ assert!(storage.secret_codec(false).is_ok());+ }+#[tokio::test]async fn secret_migration_rejects_wrong_or_invalid_managed_keys_without_replacing_them() {let directory = tempfile::tempdir().unwrap();