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): repair Linux Secret Service key lookup
t8y29d9eb0afb732
diff --git a/crates/dbx-core/src/persistence/secret_codec.rs b/crates/dbx-core/src/persistence/secret_codec.rsindex ffb4595d3a..8fb9a02135 100644--- a/crates/dbx-core/src/persistence/secret_codec.rs+++ b/crates/dbx-core/src/persistence/secret_codec.rs@@ -308,7 +308,10 @@ fn platform_keyring_codec(allow_create: bool) -> Result<Option<SecretCodec>, Strlet entry = keyring::Entry::new(KEYRING_SERVICE, KEYRING_USER).map_err(|error| format!("keyring entry unavailable: {error}"))?;match entry.get_password() {- Ok(value) => return Ok(SecretCodec::from_key_material(value.trim()).ok()),+ Ok(value) => {+ let codec = SecretCodec::from_key_material(value.trim()).map_err(|_| "SECRET_KEY_INVALID".to_string())?;+ return Ok(Some(codec));+ }Err(keyring::Error::NoEntry) => {}// Distinguish a present-but-unreadable keychain item (ACL denial,// locked keychain) from a missing one: callers surface this class in@@ -344,7 +347,7 @@ where#[cfg(all(feature = "os-keyring", target_os = "linux"))]fn secret_service_keyring_codec(allow_create: bool) -> Result<Option<SecretCodec>, String> {- use secret_service::{blocking::SecretService, EncryptionType};+ use secret_service::{blocking::SecretService, EncryptionType, Error as SecretServiceError};use std::collections::HashMap;// A missing session bus (headless server/container) means the provider is@@ -352,34 +355,68 @@ fn secret_service_keyring_codec(allow_create: bool) -> Result<Option<SecretCodec// managed .dbx/secret.key file exactly as before.let service = match SecretService::connect(EncryptionType::Dh) {Ok(service) => service,- Err(_) => return Ok(None),- };- let collection = match service.get_default_collection() {- Ok(collection) => collection,- Err(_) => return Ok(None),+ Err(error) if secret_service_provider_is_missing(&error.to_string()) => return Ok(None),+ Err(error) => return Err(format!("KEYRING_ACCESS_FAILED: secret service connection failed: {error}")),};+let mut attributes = HashMap::new();attributes.insert("target", KEYRING_TARGET);attributes.insert("service", KEYRING_SERVICE);attributes.insert("username", KEYRING_USER);- let mut found = collection+ // SearchItems on the service is the Secret Service API's interoperable+ // lookup: it searches every collection. This also lets us recover an+ // existing DBX key when the default alias points at a stale collection.+ let search = service.search_items(attributes).map_err(|error| format!("KEYRING_ACCESS_FAILED: secret search failed: {error}"))?;- if found.is_empty() {- let mut legacy = HashMap::new();- legacy.insert("service", KEYRING_SERVICE);- legacy.insert("username", KEYRING_USER);- found = collection- .search_items(legacy)- .map_err(|error| format!("KEYRING_ACCESS_FAILED: secret search failed: {error}"))?;++ let item = search.unlocked.into_iter().next().or_else(|| search.locked.into_iter().next());+ if let Some(item) = item {+ let secret =+ item.get_secret().map_err(|error| format!("KEYRING_ACCESS_FAILED: secret read failed: {error}"))?;+ let material = String::from_utf8(secret).map_err(|_| "SECRET_KEY_INVALID".to_string())?;+ let codec = SecretCodec::from_key_material(material.trim()).map_err(|_| "SECRET_KEY_INVALID".to_string())?;+ return Ok(Some(codec));+ }++ // Older DBX/keyring entries may omit `target`. Preserve that compatibility+ // search, but only against a live default collection. Secret Service+ // implementations can return a stale object path for the `default` alias;+ // calling SearchItems on that path produces UnknownMethod even though the+ // provider itself is healthy. Confirming it appears in Collections keeps+ // that specific missing-collection case on the documented file fallback+ // path without swallowing access or API errors.+ let collection = match service.get_default_collection() {+ Ok(collection) => collection,+ Err(SecretServiceError::NoResult | SecretServiceError::Unavailable) => return Ok(None),+ Err(error) => return Err(format!("KEYRING_ACCESS_FAILED: default collection lookup failed: {error}")),+ };+ let default_path = collection.collection_path.as_str().to_string();+ let collections = service+ .get_all_collections()+ .map_err(|error| format!("KEYRING_ACCESS_FAILED: collection enumeration failed: {error}"))?;+ if !collection_path_is_registered(+ &default_path,+ collections.iter().map(|candidate| candidate.collection_path.as_str()),+ ) {+ return Ok(None);}++ let mut legacy = HashMap::new();+ legacy.insert("service", KEYRING_SERVICE);+ legacy.insert("username", KEYRING_USER);+ let found = collection+ .search_items(legacy)+ .map_err(|error| format!("KEYRING_ACCESS_FAILED: secret search failed: {error}"))?;let item = found.into_iter().next();match item {Some(item) => {let secret =item.get_secret().map_err(|error| format!("KEYRING_ACCESS_FAILED: secret read failed: {error}"))?;let material = String::from_utf8(secret).map_err(|_| "SECRET_KEY_INVALID".to_string())?;- Ok(SecretCodec::from_key_material(material.trim()).ok())+ let codec =+ SecretCodec::from_key_material(material.trim()).map_err(|_| "SECRET_KEY_INVALID".to_string())?;+ Ok(Some(codec))}None if allow_create => {let mut key = [0u8; 32];@@ -398,6 +435,17 @@ fn secret_service_keyring_codec(allow_create: bool) -> Result<Option<SecretCodec}}+#[cfg(all(feature = "os-keyring", target_os = "linux"))]+fn secret_service_provider_is_missing(error: &str) -> bool {+ error.contains("org.freedesktop.DBus.Error.ServiceUnknown")+ || error.contains("org.freedesktop.DBus.Error.NameHasNoOwner")+ || error.contains("no secret service provider or dbus session found")+}++fn collection_path_is_registered<'a>(path: &str, collection_paths: impl IntoIterator<Item = &'a str>) -> bool {+ collection_paths.into_iter().any(|candidate| candidate == path)+}+#[cfg(not(feature = "os-keyring"))]fn platform_keyring_codec(_allow_create: bool) -> Result<Option<SecretCodec>, String> {// Cross/server builds compile without the OS keyring backend; the managed@@ -561,6 +609,14 @@ mod tests {LOCK.get_or_init(|| Mutex::new(()))}+ fn restore_env(name: &str, value: Option<std::ffi::OsString>) {+ if let Some(value) = value {+ std::env::set_var(name, value);+ } else {+ std::env::remove_var(name);+ }+ }+fn assert_secret_service_runtime_isolated() {let directory = tempfile::tempdir().unwrap();let path = directory.path().join("secret.key");@@ -609,6 +665,18 @@ mod tests {assert!(!path.exists());}+ #[test]+ fn denied_or_corrupt_platform_key_never_creates_a_fallback() {+ for provider_error in ["KEYRING_ACCESS_FAILED: permission denied", "SECRET_KEY_INVALID"] {+ let directory = tempfile::tempdir().unwrap();+ let path = directory.path().join("secret.key");+ let expected = provider_error.to_string();+ let result = SecretCodec::resolve_platform_default(Some(path.clone()), true, move |_| Err(expected));+ assert!(matches!(result, Err(error) if error == provider_error));+ assert!(!path.exists());+ }+ }+#[tokio::test]async fn secret_service_worker_panics_do_not_create_a_fallback() {let directory = tempfile::tempdir().unwrap();@@ -829,6 +897,9 @@ mod tests {fn unavailable_platform_creation_uses_a_stable_fallback_key() {let directory = tempfile::tempdir().unwrap();let path = directory.path().join("secret.key");+ // The Linux provider reports both an absent session service and a+ // missing default collection as `Ok(None)`. Both cases are safe to+ // provision through the existing persistent compatibility path.let created = SecretCodec::resolve_platform_default(Some(path.clone()), true, |allow_create| {assert!(allow_create);Ok(None)@@ -845,6 +916,30 @@ mod tests {assert_eq!(std::fs::read(path).unwrap(), original);}+ #[test]+ fn stale_default_collection_is_classified_by_registered_paths() {+ let default_path = "/org/freedesktop/secrets/collection/login";+ assert!(!super::collection_path_is_registered(default_path, ["/org/freedesktop/secrets/collection/other",]));+ assert!(super::collection_path_is_registered(default_path, [default_path]));+ }++ #[cfg(all(feature = "os-keyring", target_os = "linux"))]+ #[test]+ fn only_absent_secret_service_names_use_provider_fallback() {+ assert!(super::secret_service_provider_is_missing(+ "zbus error: org.freedesktop.DBus.Error.ServiceUnknown: no owner"+ ));+ assert!(super::secret_service_provider_is_missing(+ "zbus error: org.freedesktop.DBus.Error.NameHasNoOwner: no owner"+ ));+ assert!(!super::secret_service_provider_is_missing(+ "zbus error: org.freedesktop.DBus.Error.AccessDenied: permission denied"+ ));+ assert!(!super::secret_service_provider_is_missing(+ "zbus error: org.freedesktop.DBus.Error.UnknownMethod: object does not exist"+ ));+ }+#[test]fn unavailable_platform_provider_does_not_replace_a_corrupt_fallback_key() {let directory = tempfile::tempdir().unwrap();