1 parent
320e37aa42
commit
75c9122799
11 files changed
+220
-23
No files matched your search
@@ -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() {
|
||||
|
||||
@@ -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
|
||||
|
||||
Reference in new issue
Block a user