Skip to content

armgit / dbx

Public Imported from GitHub
0

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。

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.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<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.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<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();