From ecfa455701975f284bbef352ce99fc91427c37d7 Mon Sep 17 00:00:00 2001 From: Bilal Elmoussaoui Date: Wed, 18 Nov 2026 20:46:19 +0100 Subject: [PATCH 1/4] server: Notify clients when a pending migration completes Migrated items were dispatched without change signals, so clients kept showing the empty placeholder collection until restarted. https://github.com/linux-credentials/oo7/issues/688 --- server/src/collection/mod.rs | 62 ++++++++++---- server/src/error.rs | 11 +++ server/src/service/locking.rs | 19 ++--- server/src/service/tests/discovery.rs | 113 ++++++++++++++++++++++++++ 4 files changed, 180 insertions(+), 25 deletions(-) diff --git a/server/src/collection/mod.rs b/server/src/collection/mod.rs index 80900ba2..bad65b9e 100644 --- a/server/src/collection/mod.rs +++ b/server/src/collection/mod.rs @@ -676,25 +676,57 @@ impl Collection { keyring_items.len(), self.path ); - let mut items = self.items.lock().await; - let object_server = self.service.object_server(); - let mut n_items = 1; + drop(keyring_guard); - for keyring_item in keyring_items { - let item_path = OwnedObjectPath::try_from(format!("{}/{n_items}", self.path)).unwrap(); - let item = item::Item::new( - keyring_item, - self.service.clone(), - self.path.clone(), - item_path.clone(), - ); - n_items += 1; + let mut dispatched_items = Vec::new(); + { + let mut items = self.items.lock().await; + let object_server = self.service.object_server(); + let mut n_items = 1; + + for keyring_item in keyring_items { + let item_path = + OwnedObjectPath::try_from(format!("{}/{n_items}", self.path)).unwrap(); + let item = item::Item::new( + keyring_item, + self.service.clone(), + self.path.clone(), + item_path.clone(), + ); + n_items += 1; + + items.push(item.clone()); + dispatched_items.push(item.clone()); + object_server.at(item_path, item).await?; + } + + *self.item_index.write().await = n_items; + } - items.push(item.clone()); - object_server.at(item_path, item).await?; + // Notify clients about the newly dispatched items. + let signal_emitter = self.service.signal_emitter(&self.path)?; + for item in &dispatched_items { + Self::item_created(&signal_emitter, item.path()).await?; } + self.items_changed(&signal_emitter).await?; - *self.item_index.write().await = n_items; + Ok(()) + } + + /// Replace the keyring with a just-migrated one, dispatch its items + /// and emit the corresponding change signals. + pub async fn apply_migrated_keyring(&self, keyring: Keyring) -> Result<(), Error> { + *self.keyring.write().await = Some(keyring); + + self.dispatch_items().await?; + + // The keyring swap bypasses set_locked, so emit Locked here. + let signal_emitter = self.service.signal_emitter(&self.path)?; + self.locked_changed(&signal_emitter).await?; + + let service_path = oo7::dbus::api::Service::PATH.as_ref().unwrap(); + let signal_emitter = self.service.signal_emitter(service_path)?; + Service::collection_changed(&signal_emitter, &self.path).await?; Ok(()) } diff --git a/server/src/error.rs b/server/src/error.rs index f85a3b10..9161cf17 100644 --- a/server/src/error.rs +++ b/server/src/error.rs @@ -27,6 +27,17 @@ impl From for Error { } } +impl From for Error { + fn from(err: ServiceError) -> Self { + match err { + ServiceError::ZBus(err) => Self::Zbus(err), + err => Self::Zbus(zbus::Error::FDO(Box::new(zbus::fdo::Error::Failed( + err.to_string(), + )))), + } + } +} + impl From for Error { fn from(err: oo7::file::Error) -> Self { Self::File(err) diff --git a/server/src/service/locking.rs b/server/src/service/locking.rs index 858e2800..9a8dd8d2 100644 --- a/server/src/service/locking.rs +++ b/server/src/service/locking.rs @@ -145,13 +145,11 @@ impl Service { migration_name ); - // Replace the keyring in the collection - let mut keyring_guard = collection.keyring.write().await; - *keyring_guard = Some(Keyring::Unlocked(unlocked_keyring)); - drop(keyring_guard); - - // Dispatch items from the migrated keyring - if let Err(e) = collection.dispatch_items().await { + // Replace the placeholder and notify clients + if let Err(e) = collection + .apply_migrated_keyring(Keyring::Unlocked(unlocked_keyring)) + .await + { tracing::error!("Failed to dispatch items after migration: {}", e); } @@ -230,9 +228,10 @@ impl Service { }; if let Some(collection) = placeholder { - *collection.keyring.write().await = Some(Keyring::Unlocked(unlocked)); - - if let Err(e) = collection.dispatch_items().await { + if let Err(e) = collection + .apply_migrated_keyring(Keyring::Unlocked(unlocked)) + .await + { tracing::error!( "Failed to dispatch items for migrated keyring '{name}': {e}", ); diff --git a/server/src/service/tests/discovery.rs b/server/src/service/tests/discovery.rs index 7aa68e68..4cd394a3 100644 --- a/server/src/service/tests/discovery.rs +++ b/server/src/service/tests/discovery.rs @@ -216,6 +216,119 @@ async fn unlock_pending_v0_migration_impl( Ok(()) } +// https://github.com/linux-credentials/oo7/issues/688 +// Unlocking a pending migration must notify clients, else they keep +// showing the empty placeholder collection until restarted. +#[cfg(any(feature = "gnome_native_crypto", feature = "gnome_openssl_crypto"))] +#[tokio::test] +async fn unlock_pending_v0_migration_emits_change_signals() -> Result<(), Box> +{ + use std::collections::HashMap; + + use tokio_stream::StreamExt; + use zbus::{ + MatchRule, MessageStream, + message::Type as MessageType, + wire::{OwnedObjectPath, OwnedVariant, Variant}, + }; + + use crate::tests::assert_next_signal; + + let temp_dir = tempfile::tempdir()?; + let keyrings_dir = temp_dir.path().join("keyrings"); + tokio::fs::create_dir_all(keyrings_dir.join("v1")).await?; + + // Copy the v0 keyring fixture (contains a single item labeled "foo") + let v0_secret = Secret::from("test"); + let fixture_path = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .parent() + .unwrap() + .join("client/fixtures/legacy.keyring"); + tokio::fs::copy(&fixture_path, keyrings_dir.join("legacy.keyring")).await?; + + // Create test service that discovers keyrings WITHOUT the password + let setup = + TestServiceSetup::with_disk_keyrings(temp_dir.path().to_path_buf(), None, None).await?; + + // Find the placeholder collection + let collections = setup.service_api.collections().await?; + let mut legacy_index = None; + for (index, collection) in collections.iter().enumerate() { + if collection.label().await? == "Legacy" { + legacy_index = Some(index); + break; + } + } + let legacy_collection = + &collections[legacy_index.expect("Should have Legacy placeholder collection")]; + + // The placeholder starts out locked and empty + assert!(legacy_collection.is_locked().await?); + assert_eq!( + legacy_collection.items().await?.len(), + 0, + "Placeholder should not expose any items" + ); + + // Subscribe to the collection signals before triggering the migration + let item_created_stream = legacy_collection.receive_item_created().await?; + tokio::pin!(item_created_stream); + + let properties_rule = MatchRule::builder() + .msg_type(MessageType::Signal) + .interface("org.freedesktop.DBus.Properties") + .member("PropertiesChanged") + .path(legacy_collection.inner().path().to_owned()) + .build()?; + let mut properties_stream = + MessageStream::for_match_rule(properties_rule, &setup.client_conn, None).await?; + + // Unlock via D-Bus API with the correct password (triggers migration) + setup.set_password_queue(vec![v0_secret]).await; + let unlocked = setup + .service_api + .unlock(&[legacy_collection.inner().path()], None) + .await?; + assert_eq!(unlocked.len(), 1, "Should have unlocked the collection"); + + // The migrated item is announced via ItemCreated + let item = assert_next_signal(&mut item_created_stream).await; + assert_eq!( + item.inner().path().as_str(), + format!("{}/1", legacy_collection.inner().path().as_str()), + "ItemCreated should announce the migrated item" + ); + assert_eq!(item.label().await?, "foo"); + + // The Items and Locked properties are signaled as changed + let mut items_signaled = false; + let mut locked_signaled = false; + for _ in 0..2 { + let message = assert_next_signal(&mut properties_stream).await?; + let (_, changed, _invalidated): (String, HashMap, Vec) = + message.body().deserialize()?; + + if let Some(value) = changed.get("Items") { + let items = Vec::::try_from(Variant::from(value.clone()))?; + assert_eq!( + items.len(), + 1, + "Items property should contain the migrated item" + ); + assert_eq!(items[0].as_str(), item.inner().path().as_str()); + items_signaled = true; + } + if let Some(value) = changed.get("Locked") { + assert!(!bool::try_from(Variant::from(value.clone()))?); + locked_signaled = true; + } + } + assert!(items_signaled, "Items property change should be signaled"); + assert!(locked_signaled, "Locked property change should be signaled"); + + Ok(()) +} + #[tokio::test] async fn discover_v0_keyrings() -> Result<(), Box> { let temp_dir = tempfile::tempdir()?; From 10e3724cd9598591b9c9a27406a62ce17626cfc6 Mon Sep 17 00:00:00 2001 From: Bilal Elmoussaoui Date: Wed, 18 Nov 2026 21:02:20 +0100 Subject: [PATCH 2/4] server: Validate unlock secrets against pending migrations The empty placeholder accepts any secret, so any password silently unlocked it and hid the pending migration. Validate against the legacy keyring instead. https://github.com/linux-credentials/oo7/issues/688 --- client/src/file/mod.rs | 27 +++++ server/src/migration.rs | 27 +++++ server/src/prompt/mod.rs | 19 ++- server/src/service/tests/discovery.rs | 166 +++++++++++++++++++++++++- 4 files changed, 237 insertions(+), 2 deletions(-) diff --git a/client/src/file/mod.rs b/client/src/file/mod.rs index 3da3e939..23113051 100644 --- a/client/src/file/mod.rs +++ b/client/src/file/mod.rs @@ -74,6 +74,33 @@ pub use locked_keyring::LockedKeyring; pub use unlocked_item::UnlockedItem; pub use unlocked_keyring::{ItemDefinition, UnlockedKeyring}; +/// Check whether a secret can decrypt the legacy (gnome-keyring +/// format) keyring at `path`, without migrating it. +/// +/// Returns `Ok(false)` if the secret cannot decrypt the keyring. +#[cfg_attr( + feature = "tracing", + tracing::instrument(skip(secret), fields(path = ?path.as_ref())) +)] +pub async fn validate_legacy_secret( + path: impl AsRef, + secret: &Secret, +) -> Result { + let path = path.as_ref(); + #[cfg(feature = "tokio")] + let content = tokio::fs::read(path).await?; + #[cfg(feature = "async-std")] + let content = async_fs::read(path).await?; + + let legacy = api::LegacyKeyring::try_from(content.as_slice())?; + match legacy.decrypt_items(secret) { + Ok(_) => Ok(true), + // A wrong secret yields a checksum mismatch. + Err(Error::ChecksumMismatch) => Ok(false), + Err(err) => Err(err), + } +} + use crate::{AsAttributes, GENERIC_SCHEMA, Key, Secret, XDG_SCHEMA_ATTRIBUTE}; #[derive(Debug)] diff --git a/server/src/migration.rs b/server/src/migration.rs index 30c72931..b1ffcae6 100644 --- a/server/src/migration.rs +++ b/server/src/migration.rs @@ -34,6 +34,33 @@ pub enum PendingMigration { } impl PendingMigration { + /// Check whether the secret can decrypt the legacy keyring, as the + /// placeholder keyring of a pending migration accepts any secret. + pub async fn validate_secret(&self, secret: &Secret) -> Result { + match self { + Self::V0 { path, .. } => Ok(oo7::file::validate_legacy_secret(path, secret).await?), + #[cfg(feature = "kwallet_migration")] + Self::KWallet { path, .. } => { + let path = path.clone(); + let password = secret.to_vec(); + match tokio::task::spawn_blocking(move || { + kwallet_parser::KWalletFile::open(&path, &password) + }) + .await + { + Ok(Ok(_)) => Ok(true), + Ok(Err(err)) => { + tracing::debug!("Failed to validate KWallet keyring secret: {err}"); + Ok(false) + } + Err(err) => Err(Error::IO(std::io::Error::other(format!( + "Task join error: {err}" + )))), + } + } + } + } + /// Attempt to migrate this keyring with the provided secret pub async fn migrate( &self, diff --git a/server/src/prompt/mod.rs b/server/src/prompt/mod.rs index 492fa5af..17d30b34 100644 --- a/server/src/prompt/mod.rs +++ b/server/src/prompt/mod.rs @@ -228,7 +228,24 @@ impl Prompt { let collection = self.collection().expect("Unlock requires a collection"); let label = self.label(); - let is_valid = if let Some(ref secret) = secret { + // The placeholder of a pending migration accepts any secret; + // validate against the legacy keyring instead. + let pending_migration = { + let pending = self.service.pending_migrations.lock().await; + pending.get(collection.name()).cloned() + }; + + let is_valid = if let Some(migration) = pending_migration { + match secret.as_ref() { + Some(secret) => migration.validate_secret(secret).await.map_err(|err| { + custom_service_error(&format!( + "Failed to validate secret for {label} keyring: {err}." + )) + })?, + // A pending migration always requires a secret. + None => false, + } + } else if let Some(ref secret) = secret { // Validate the secret using the already-open keyring let keyring_guard = collection.keyring.read().await; let valid = keyring_guard diff --git a/server/src/service/tests/discovery.rs b/server/src/service/tests/discovery.rs index 4cd394a3..3c6c11ce 100644 --- a/server/src/service/tests/discovery.rs +++ b/server/src/service/tests/discovery.rs @@ -1,7 +1,7 @@ use oo7::{Secret, file::UnlockedKeyring}; use super::super::*; -use crate::tests::TestServiceSetup; +use crate::{prompt::MAX_UNLOCK_ATTEMPTS, tests::TestServiceSetup}; #[tokio::test] async fn discover_v1_keyrings() -> Result<(), Box> { @@ -329,6 +329,170 @@ async fn unlock_pending_v0_migration_emits_change_signals() -> Result<(), Box Result<(), Box> { + unlock_pending_v0_migration_wrong_password_retry_impl(PrompterType::GNOME).await +} + +#[cfg(any(feature = "plasma_native_crypto", feature = "plasma_openssl_crypto"))] +#[tokio::test] +async fn unlock_pending_v0_migration_wrong_password_retry_plasma() +-> Result<(), Box> { + unlock_pending_v0_migration_wrong_password_retry_impl(PrompterType::Plasma).await +} + +async fn unlock_pending_v0_migration_wrong_password_retry_impl( + prompter_type: PrompterType, +) -> Result<(), Box> { + let temp_dir = tempfile::tempdir()?; + let keyrings_dir = temp_dir.path().join("keyrings"); + tokio::fs::create_dir_all(keyrings_dir.join("v1")).await?; + + let v0_secret = Secret::from("test"); + let fixture_path = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .parent() + .unwrap() + .join("client/fixtures/legacy.keyring"); + tokio::fs::copy(&fixture_path, keyrings_dir.join("legacy.keyring")).await?; + + let setup = + TestServiceSetup::with_disk_keyrings(temp_dir.path().to_path_buf(), None, None).await?; + setup.server.set_prompter_type(prompter_type).await; + + assert_eq!( + setup.server.pending_migrations.lock().await.len(), + 1, + "V0 keyring should be pending migration" + ); + + // Find the placeholder collection + let collections = setup.service_api.collections().await?; + let mut legacy_index = None; + for (index, collection) in collections.iter().enumerate() { + if collection.label().await? == "Legacy" { + legacy_index = Some(index); + break; + } + } + let legacy_collection = + &collections[legacy_index.expect("Should have Legacy placeholder collection")]; + + assert!( + legacy_collection.is_locked().await?, + "Placeholder should be locked" + ); + + // Wrong passwords first, then the correct one + setup + .set_password_queue(vec![ + Secret::from("wrong-password"), + Secret::from("another-wrong-password"), + v0_secret, + ]) + .await; + + let unlocked = setup + .service_api + .unlock(&[legacy_collection.inner().path()], None) + .await?; + assert_eq!(unlocked.len(), 1, "Should have unlocked the collection"); + + assert!( + !legacy_collection.is_locked().await?, + "Collection should be unlocked after retry with correct password" + ); + assert_eq!( + legacy_collection.items().await?.len(), + 1, + "Migrated item should be dispatched" + ); + assert_eq!( + setup.server.pending_migrations.lock().await.len(), + 0, + "Migration should have completed" + ); + + Ok(()) +} + +// https://github.com/linux-credentials/oo7/issues/688 +// After exhausted unlock attempts, the placeholder must stay locked and +// the migration pending, so it can be retried later. +#[cfg(any(feature = "gnome_native_crypto", feature = "gnome_openssl_crypto"))] +#[tokio::test] +async fn unlock_pending_v0_migration_wrong_password_dismissed_gnome() +-> Result<(), Box> { + unlock_pending_v0_migration_wrong_password_dismissed_impl(PrompterType::GNOME).await +} + +#[cfg(any(feature = "plasma_native_crypto", feature = "plasma_openssl_crypto"))] +#[tokio::test] +async fn unlock_pending_v0_migration_wrong_password_dismissed_plasma() +-> Result<(), Box> { + unlock_pending_v0_migration_wrong_password_dismissed_impl(PrompterType::Plasma).await +} + +async fn unlock_pending_v0_migration_wrong_password_dismissed_impl( + prompter_type: PrompterType, +) -> Result<(), Box> { + let temp_dir = tempfile::tempdir()?; + let keyrings_dir = temp_dir.path().join("keyrings"); + tokio::fs::create_dir_all(keyrings_dir.join("v1")).await?; + + let fixture_path = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .parent() + .unwrap() + .join("client/fixtures/legacy.keyring"); + tokio::fs::copy(&fixture_path, keyrings_dir.join("legacy.keyring")).await?; + + let setup = + TestServiceSetup::with_disk_keyrings(temp_dir.path().to_path_buf(), None, None).await?; + setup.server.set_prompter_type(prompter_type).await; + + // Find the placeholder collection + let collections = setup.service_api.collections().await?; + let mut legacy_index = None; + for (index, collection) in collections.iter().enumerate() { + if collection.label().await? == "Legacy" { + legacy_index = Some(index); + break; + } + } + let legacy_collection = + &collections[legacy_index.expect("Should have Legacy placeholder collection")]; + + setup + .set_password_queue(vec![ + Secret::from("wrong-password"); + MAX_UNLOCK_ATTEMPTS as usize + 1 + ]) + .await; + + let collection_path = legacy_collection.inner().path().to_owned(); + let result = setup.service_api.unlock(&[collection_path], None).await; + + assert!( + matches!(result, Err(oo7::dbus::Error::Dismissed)), + "Expected Dismissed error after max failed attempts, got: {result:?}" + ); + assert!( + legacy_collection.is_locked().await?, + "Placeholder should remain locked after failed unlock attempts" + ); + assert_eq!( + setup.server.pending_migrations.lock().await.len(), + 1, + "Migration should still be pending, so it can be retried later" + ); + + Ok(()) +} + #[tokio::test] async fn discover_v0_keyrings() -> Result<(), Box> { let temp_dir = tempfile::tempdir()?; From 51d652fd972702a4ce34e745b9167caf03133269 Mon Sep 17 00:00:00 2001 From: Bilal Elmoussaoui Date: Wed, 18 Nov 2026 21:04:01 +0100 Subject: [PATCH 3/4] server: Keep placeholder locked when migration fails on unlock Otherwise the empty placeholder gets unlocked and the pending migration can no longer be prompted. https://github.com/linux-credentials/oo7/issues/688 --- server/src/service/locking.rs | 3 +- server/src/service/tests/discovery.rs | 74 +++++++++++++++++++++------ 2 files changed, 61 insertions(+), 16 deletions(-) diff --git a/server/src/service/locking.rs b/server/src/service/locking.rs index 9a8dd8d2..aea8eaba 100644 --- a/server/src/service/locking.rs +++ b/server/src/service/locking.rs @@ -162,7 +162,8 @@ impl Service { migration_name, e ); - let _ = collection.set_locked(false, secret.clone()).await; + // Keep the placeholder locked so the migration + // can be retried. } } } else { diff --git a/server/src/service/tests/discovery.rs b/server/src/service/tests/discovery.rs index 3c6c11ce..2d6a3f77 100644 --- a/server/src/service/tests/discovery.rs +++ b/server/src/service/tests/discovery.rs @@ -1,7 +1,13 @@ +use std::collections::HashMap; + use oo7::{Secret, file::UnlockedKeyring}; +use zbus::wire::{OwnedObjectPath, OwnedVariant, Variant}; use super::super::*; -use crate::{prompt::MAX_UNLOCK_ATTEMPTS, tests::TestServiceSetup}; +use crate::{ + prompt::MAX_UNLOCK_ATTEMPTS, + tests::{TestServiceSetup, assert_next_signal}, +}; #[tokio::test] async fn discover_v1_keyrings() -> Result<(), Box> { @@ -223,17 +229,6 @@ async fn unlock_pending_v0_migration_impl( #[tokio::test] async fn unlock_pending_v0_migration_emits_change_signals() -> Result<(), Box> { - use std::collections::HashMap; - - use tokio_stream::StreamExt; - use zbus::{ - MatchRule, MessageStream, - message::Type as MessageType, - wire::{OwnedObjectPath, OwnedVariant, Variant}, - }; - - use crate::tests::assert_next_signal; - let temp_dir = tempfile::tempdir()?; let keyrings_dir = temp_dir.path().join("keyrings"); tokio::fs::create_dir_all(keyrings_dir.join("v1")).await?; @@ -274,14 +269,14 @@ async fn unlock_pending_v0_migration_emits_change_signals() -> Result<(), Box Result<(), Box> { + let temp_dir = tempfile::tempdir()?; + let keyrings_dir = temp_dir.path().join("keyrings"); + tokio::fs::create_dir_all(keyrings_dir.join("v1")).await?; + + let fixture_path = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .parent() + .unwrap() + .join("client/fixtures/legacy.keyring"); + tokio::fs::copy(&fixture_path, keyrings_dir.join("legacy.keyring")).await?; + + let setup = + TestServiceSetup::with_disk_keyrings(temp_dir.path().to_path_buf(), None, None).await?; + + // Find the placeholder collection on the server side + let legacy_collection = { + let collections = setup.server.collections.lock().await; + collections + .values() + .find(|c| c.name() == "legacy") + .expect("Should have Legacy placeholder collection") + .clone() + }; + + // Call perform_unlock directly with a wrong secret, bypassing the + // prompt validation + let path = OwnedObjectPath::from(legacy_collection.path().to_owned()); + setup + .server + .perform_unlock(&[path], Some(Secret::from("wrong-password"))) + .await; + + assert!( + legacy_collection.is_locked().await, + "Placeholder should remain locked after a failed migration" + ); + assert_eq!( + setup.server.pending_migrations.lock().await.len(), + 1, + "Migration should still be pending" + ); + + Ok(()) +} + #[tokio::test] async fn discover_v0_keyrings() -> Result<(), Box> { let temp_dir = tempfile::tempdir()?; From fb0053180d3f46dfaa3c01d3d10ae68cea8221d3 Mon Sep 17 00:00:00 2001 From: Bilal Elmoussaoui Date: Thu, 19 Nov 2026 09:35:05 +0100 Subject: [PATCH 4/4] Expose LegacyKeyring under the unstable feature Replace the validate_legacy_secret free function with a validate_secret method on the legacy keyring type, alongside decrypt_items and is_encrypted, so oo7-cli can interact with legacy keyrings too. --- .../src/file/api/legacy_keyring/encrypted.rs | 18 ++++- client/src/file/api/legacy_keyring/mod.rs | 65 +++++++++++++++++++ client/src/file/api/mod.rs | 2 +- client/src/file/mod.rs | 27 -------- server/Cargo.toml | 2 +- server/src/migration.rs | 6 +- 6 files changed, 89 insertions(+), 31 deletions(-) diff --git a/client/src/file/api/legacy_keyring/encrypted.rs b/client/src/file/api/legacy_keyring/encrypted.rs index 7d273689..539f597d 100644 --- a/client/src/file/api/legacy_keyring/encrypted.rs +++ b/client/src/file/api/legacy_keyring/encrypted.rs @@ -28,6 +28,22 @@ pub struct Keyring { impl Keyring { pub fn decrypt_items(self, secret: &Secret) -> Result, Error> { + let content = self.decrypt_content(secret)?; + self.read_items(&content) + } + + /// Check whether the secret can decrypt this keyring. + #[cfg(any(feature = "unstable", test))] + pub fn validate_secret(&self, secret: &Secret) -> Result { + match self.decrypt_content(secret) { + Ok(_) => Ok(true), + Err(Error::ChecksumMismatch) => Ok(false), + Err(err) => Err(err), + } + } + + /// Decrypt the keyring content, verifying its checksum. + fn decrypt_content(&self, secret: &Secret) -> Result, Error> { let (key, iv) = crypto::legacy_derive_key_and_iv( &**secret, &self.salt, @@ -38,7 +54,7 @@ impl Keyring { if !crypto::verify_checksum_md5(digest, content) { return Err(Error::ChecksumMismatch); } - self.read_items(content) + Ok(content.to_vec()) } fn read_attributes<'a>( diff --git a/client/src/file/api/legacy_keyring/mod.rs b/client/src/file/api/legacy_keyring/mod.rs index e55ff20f..80a1ee52 100644 --- a/client/src/file/api/legacy_keyring/mod.rs +++ b/client/src/file/api/legacy_keyring/mod.rs @@ -38,6 +38,12 @@ pub enum Keyring { } impl Keyring { + /// Whether this keyring is stored in the encrypted binary format. + #[cfg(any(feature = "unstable", test))] + pub fn is_encrypted(&self) -> bool { + matches!(self, Self::Encrypted(_)) + } + /// Retrieve the keyring items. /// /// The secret is ignored for plain keyrings. @@ -47,6 +53,17 @@ impl Keyring { Self::Plain(keyring) => Ok(keyring.into_items()), } } + + /// Check whether the secret can decrypt this keyring. + /// + /// Plain keyrings are not encrypted and accept any secret. + #[cfg(any(feature = "unstable", test))] + pub fn validate_secret(&self, secret: &Secret) -> Result { + match self { + Self::Encrypted(keyring) => keyring.validate_secret(secret), + Self::Plain(_) => Ok(true), + } + } } impl TryFrom<&[u8]> for Keyring { @@ -62,3 +79,51 @@ impl TryFrom<&[u8]> for Keyring { } } } + +#[cfg(test)] +mod tests { + use super::*; + + fn fixture(name: &str) -> Vec { + let path = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("fixtures") + .join(name); + std::fs::read(path).unwrap() + } + + #[test] + fn encrypted_keyring() { + let keyring = Keyring::try_from(fixture("legacy.keyring").as_slice()).unwrap(); + assert!(keyring.is_encrypted()); + + assert!( + keyring + .validate_secret(&Secret::from("test")) + .expect("validation should not fail") + ); + assert!( + !keyring + .validate_secret(&Secret::from("wrong-password")) + .expect("validation should not fail") + ); + + let items = keyring + .decrypt_items(&Secret::from("test")) + .expect("decryption should not fail"); + assert_eq!(items.len(), 1); + assert_eq!(items[0].label(), "foo"); + } + + #[test] + fn plain_keyring() { + let keyring = Keyring::try_from(fixture("plain.keyring").as_slice()).unwrap(); + assert!(!keyring.is_encrypted()); + + // Plain keyrings accept any secret + assert!( + keyring + .validate_secret(&Secret::from("anything")) + .expect("validation should not fail") + ); + } +} diff --git a/client/src/file/api/mod.rs b/client/src/file/api/mod.rs index ed721d66..67577797 100644 --- a/client/src/file/api/mod.rs +++ b/client/src/file/api/mod.rs @@ -41,7 +41,7 @@ mod encrypted_item; mod legacy_keyring; pub(super) use encrypted_item::EncryptedItem; -pub(super) use legacy_keyring::{Keyring as LegacyKeyring, MAJOR_VERSION as LEGACY_MAJOR_VERSION}; +pub use legacy_keyring::{Keyring as LegacyKeyring, MAJOR_VERSION as LEGACY_MAJOR_VERSION}; use zeroize::{Zeroize, ZeroizeOnDrop}; use crate::{ diff --git a/client/src/file/mod.rs b/client/src/file/mod.rs index 23113051..3da3e939 100644 --- a/client/src/file/mod.rs +++ b/client/src/file/mod.rs @@ -74,33 +74,6 @@ pub use locked_keyring::LockedKeyring; pub use unlocked_item::UnlockedItem; pub use unlocked_keyring::{ItemDefinition, UnlockedKeyring}; -/// Check whether a secret can decrypt the legacy (gnome-keyring -/// format) keyring at `path`, without migrating it. -/// -/// Returns `Ok(false)` if the secret cannot decrypt the keyring. -#[cfg_attr( - feature = "tracing", - tracing::instrument(skip(secret), fields(path = ?path.as_ref())) -)] -pub async fn validate_legacy_secret( - path: impl AsRef, - secret: &Secret, -) -> Result { - let path = path.as_ref(); - #[cfg(feature = "tokio")] - let content = tokio::fs::read(path).await?; - #[cfg(feature = "async-std")] - let content = async_fs::read(path).await?; - - let legacy = api::LegacyKeyring::try_from(content.as_slice())?; - match legacy.decrypt_items(secret) { - Ok(_) => Ok(true), - // A wrong secret yields a checksum mismatch. - Err(Error::ChecksumMismatch) => Ok(false), - Err(err) => Err(err), - } -} - use crate::{AsAttributes, GENERIC_SCHEMA, Key, Secret, XDG_SCHEMA_ATTRIBUTE}; #[derive(Debug)] diff --git a/server/Cargo.toml b/server/Cargo.toml index 56bca1bf..00b586fc 100644 --- a/server/Cargo.toml +++ b/server/Cargo.toml @@ -33,7 +33,7 @@ kwallet-parser = { version = "0.8.0-alpha", path = "../kwallet/parser", optional libc.workspace = true num.workspace = true num-bigint-dig.workspace = true -oo7 = { workspace = true, features = ["tokio"] } +oo7 = { workspace = true, features = ["tokio", "unstable"] } openssl = { workspace = true, optional = true } rpassword.workspace = true rustix = { version = "1.1", default-features = false, features = ["process", "std", "thread", "mm", "fs", "net", "event"] } diff --git a/server/src/migration.rs b/server/src/migration.rs index b1ffcae6..a23de266 100644 --- a/server/src/migration.rs +++ b/server/src/migration.rs @@ -38,7 +38,11 @@ impl PendingMigration { /// placeholder keyring of a pending migration accepts any secret. pub async fn validate_secret(&self, secret: &Secret) -> Result { match self { - Self::V0 { path, .. } => Ok(oo7::file::validate_legacy_secret(path, secret).await?), + Self::V0 { path, .. } => { + let content = tokio::fs::read(path).await?; + let keyring = oo7::file::api::LegacyKeyring::try_from(content.as_slice())?; + Ok(keyring.validate_secret(secret)?) + } #[cfg(feature = "kwallet_migration")] Self::KWallet { path, .. } => { let path = path.clone();