fix(secrets): unlock Secret Service items on retry

Closes #11052
This commit is contained in:
t8y2 committed 2026-10-04 16:33:11 +00:00
1 parent 320e37aa42
commit 75c9122799
11 files changed
+220 -23

No files matched your search

+107 -6
View File
@@ -345,6 +345,31 @@ where
worker.join().map_err(|_| "KEYRING_ACCESS_FAILED: secret service worker failed".to_string())?
}
#[cfg(any(test, all(feature = "os-keyring", target_os = "linux")))]
fn read_secret_service_item<I, U, R, E>(mut is_locked: I, mut unlock: U, mut read: R) -> Result<Vec<u8>, String>
where
I: FnMut() -> Result<bool, E>,
U: FnMut() -> Result<(), E>,
R: FnMut() -> Result<Vec<u8>, E>,
E: std::fmt::Display,
{
let locked =
is_locked().map_err(|error| format!("KEYRING_ACCESS_FAILED: secret lock status check failed: {error}"))?;
if locked {
// Unlock drives the provider's prompt flow (KWallet, GNOME Keyring,
// and other Secret Service implementations). Never treat a denied or
// failed prompt as a missing item: doing so could provision a
// replacement key and strand existing ciphertext.
unlock().map_err(|error| format!("KEYRING_ACCESS_FAILED: secret unlock failed: {error}"))?;
let still_locked = is_locked()
.map_err(|error| format!("KEYRING_ACCESS_FAILED: secret lock status check failed after unlock: {error}"))?;
if still_locked {
return Err("KEYRING_ACCESS_FAILED: secret remained locked after unlock".to_string());
}
}
read().map_err(|error| format!("KEYRING_ACCESS_FAILED: secret read failed: {error}"))
}
#[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, Error as SecretServiceError};
@@ -372,8 +397,7 @@ fn secret_service_keyring_codec(allow_create: bool) -> Result<Option<SecretCodec
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 secret = read_secret_service_item(|| item.is_locked(), || item.unlock(), || item.get_secret())?;
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));
@@ -411,8 +435,7 @@ fn secret_service_keyring_codec(allow_create: bool) -> Result<Option<SecretCodec
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 secret = read_secret_service_item(|| item.is_locked(), || item.unlock(), || item.get_secret())?;
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())?;
@@ -599,8 +622,8 @@ mod tests {
}
use super::{
managed_key_path, read_key_file_with_retry, run_secret_service_operation, SecretCodec, SecretKeyPolicy,
SecretKeySource,
managed_key_path, read_key_file_with_retry, read_secret_service_item, run_secret_service_operation,
SecretCodec, SecretKeyPolicy, SecretKeySource,
};
use base64::Engine as _;
use std::sync::{Mutex, OnceLock};
@@ -699,6 +722,84 @@ mod tests {
assert!(!path.exists());
}
#[test]
fn locked_secret_service_item_is_unlocked_before_read() {
use std::cell::{Cell, RefCell};
let locked = Cell::new(true);
let calls = RefCell::new(Vec::new());
let secret = read_secret_service_item(
|| {
calls.borrow_mut().push("is_locked");
Ok::<_, &'static str>(locked.get())
},
|| {
calls.borrow_mut().push("unlock");
locked.set(false);
Ok::<_, &'static str>(())
},
|| {
calls.borrow_mut().push("read");
Ok::<_, &'static str>(b"secret".to_vec())
},
)
.unwrap();
assert_eq!(secret, b"secret");
assert_eq!(*calls.borrow(), ["is_locked", "unlock", "is_locked", "read"]);
}
#[test]
fn unlocked_secret_service_item_is_read_without_an_unlock_prompt() {
let unlock_called = std::cell::Cell::new(false);
let secret = read_secret_service_item(
|| Ok::<_, &'static str>(false),
|| {
unlock_called.set(true);
Ok::<_, &'static str>(())
},
|| Ok::<_, &'static str>(b"secret".to_vec()),
)
.unwrap();
assert_eq!(secret, b"secret");
assert!(!unlock_called.get());
}
#[test]
fn secret_service_unlock_rejection_or_provider_failure_is_not_treated_as_missing() {
for detail in ["prompt dismissed by user", "provider returned an error"] {
let read_called = std::cell::Cell::new(false);
let result = read_secret_service_item(
|| Ok::<_, &'static str>(true),
|| Err(detail),
|| {
read_called.set(true);
Ok::<_, &'static str>(Vec::new())
},
);
assert_eq!(result.unwrap_err(), format!("KEYRING_ACCESS_FAILED: secret unlock failed: {detail}"));
assert!(!read_called.get());
}
}
#[test]
fn secret_service_item_still_locked_after_unlock_is_an_access_error() {
let read_called = std::cell::Cell::new(false);
let result = read_secret_service_item(
|| Ok::<_, &'static str>(true),
|| Ok::<_, &'static str>(()),
|| {
read_called.set(true);
Ok::<_, &'static str>(Vec::new())
},
);
assert_eq!(result.unwrap_err(), "KEYRING_ACCESS_FAILED: secret remained locked after unlock");
assert!(!read_called.get());
}
#[cfg(all(feature = "os-keyring", target_os = "linux"))]
#[test]
fn linux_keyring_missing_bus_is_safe_for_sync_and_async_callers() {
+56 -2
View File
@@ -1348,7 +1348,15 @@ impl Storage {
}
fn resolve_secret_key(&self, allow_create: bool) -> Result<SecretKeyResolution, String> {
if !allow_create {
self.resolve_secret_key_with_error_cache(allow_create, true)
}
fn resolve_secret_key_with_error_cache(
&self,
allow_create: bool,
use_cached_error: bool,
) -> Result<SecretKeyResolution, String> {
if !allow_create && use_cached_error {
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() {
@@ -1557,6 +1565,20 @@ impl Storage {
}
pub async fn inspect_data_migration(&self) -> Result<MigrationPreflight, String> {
self.inspect_data_migration_with_error_cache(true).await
}
/// Repeat the read-only migration probe after an explicit user action.
/// Only this call bypasses a cached provider failure; its success or error
/// replaces that cache before ordinary startup/background reads resume.
pub async fn retry_data_migration_inspection(&self) -> Result<MigrationPreflight, String> {
self.inspect_data_migration_with_error_cache(false).await
}
async fn inspect_data_migration_with_error_cache(
&self,
use_cached_key_error: bool,
) -> Result<MigrationPreflight, String> {
let files = self.legacy_json_files().await?;
let mut stored = self.load_migration_state().await?;
let failure = self.migration_failure.lock().unwrap_or_else(|p| p.into_inner()).clone();
@@ -1664,7 +1686,7 @@ impl Storage {
// This probe is deliberately read-only. It must not create a keyring
// 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);
let key_probe = self.resolve_secret_key_with_error_cache(false, use_cached_key_error);
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.
@@ -9430,6 +9452,38 @@ mod tests {
assert!(storage.secret_codec(false).is_ok());
}
#[tokio::test]
async fn explicit_status_retry_bypasses_cached_error_and_keeps_the_success() {
let dir = tempfile::tempdir().unwrap();
let storage = storage_with_managed_key(dir.path()).await;
let cached_error = "KEYRING_ACCESS_FAILED: cached locked keyring";
storage.cache_secret_key_error(cached_error, storage.key_file_digests());
let cached = storage.inspect_data_migration().await.unwrap();
assert_eq!(cached.error_code.as_deref(), Some("KEYRING_ACCESS_FAILED"));
assert_eq!(storage.resolve_secret_key(false).err().unwrap(), cached_error);
let retried = storage.retry_data_migration_inspection().await.unwrap();
assert!(retried.key_provider_available);
assert_eq!(retried.key_status, super::MigrationKeyStatus::Ready);
assert_eq!(retried.key_source, "managed_data_dir");
assert!(storage.resolve_secret_key(false).is_ok());
}
#[tokio::test]
async fn failed_status_retry_replaces_the_cached_provider_error() {
let dir = tempfile::tempdir().unwrap();
let storage = storage_with_managed_key(dir.path()).await;
std::fs::write(managed_key_path(dir.path()), "\n").unwrap();
let cached_error = "KEYRING_ACCESS_FAILED: cached locked keyring";
storage.cache_secret_key_error(cached_error, storage.key_file_digests());
assert_eq!(storage.resolve_secret_key(false).err().unwrap(), cached_error);
let retried = storage.retry_data_migration_inspection().await.unwrap();
assert_eq!(retried.error_code.as_deref(), Some("SECRET_KEY_INVALID"));
assert_eq!(storage.resolve_secret_key(false).err().unwrap(), "SECRET_KEY_INVALID");
}
#[tokio::test]
async fn start_data_migration_invalidates_cached_secret_key_error() {
// Migration must re-probe the live provider instead of trusting a