diff --git a/client/src/file/unlocked_keyring.rs b/client/src/file/unlocked_keyring.rs index 95d992fd..1050b9fe 100644 --- a/client/src/file/unlocked_keyring.rs +++ b/client/src/file/unlocked_keyring.rs @@ -509,6 +509,8 @@ impl UnlockedKeyring { Err(e) => { #[cfg(feature = "tracing")] tracing::error!("Failed to write keyring after item creation"); + let mut keyring = self.keyring.write().await; + keyring.items.pop(); Err(e) } Ok(_) => { diff --git a/client/tests/file_unlocked_keyring/errors.rs b/client/tests/file_unlocked_keyring/errors.rs index c0c8ec39..6dadda41 100644 --- a/client/tests/file_unlocked_keyring/errors.rs +++ b/client/tests/file_unlocked_keyring/errors.rs @@ -71,6 +71,54 @@ async fn delete_broken_items() -> Result<(), Error> { Ok(()) } +#[tokio::test] +async fn create_item_write_failure_leaves_item_in_memory() -> Result<(), Error> { + let temp_dir = tempdir()?; + let keyring_path = temp_dir.path().join("write_fail.keyring"); + + let keyring = UnlockedKeyring::load(&keyring_path, Some(Secret::blob("test"))).await?; + keyring + .create_item("Initial", &[("app", "test")], "secret", false) + .await?; + assert_eq!(keyring.n_items().await, 1); + + // Make the parent directory unwritable so the temp-file creation fails + let dir = temp_dir.path(); + let mut perms = std::fs::metadata(dir)?.permissions(); + perms.set_readonly(true); + std::fs::set_permissions(dir, perms)?; + + // create_item should fail on write + let result = keyring + .create_item("Ghost", &[("app", "ghost")], "ghost-secret", false) + .await; + assert!(result.is_err(), "create_item should fail when write fails"); + + // The failed item must not remain in memory + let items = keyring.items().await?; + assert_eq!( + items.len(), + 1, + "Failed create_item should not leave a ghost item in memory" + ); + + // Restore permissions for cleanup + let mut perms = std::fs::metadata(dir)?.permissions(); + #[allow(clippy::permissions_set_readonly_false)] + perms.set_readonly(false); + std::fs::set_permissions(dir, perms)?; + + // Reload from disk + let reloaded = UnlockedKeyring::load(&keyring_path, Some(Secret::blob("test"))).await?; + assert_eq!( + reloaded.n_items().await, + 1, + "On-disk keyring should only have the initial item" + ); + + Ok(()) +} + #[tokio::test] async fn partially_corrupted_keyring_error() -> Result<(), Error> { let temp_dir = tempdir().unwrap(); diff --git a/client/tests/file_unlocked_keyring/lifecycle.rs b/client/tests/file_unlocked_keyring/lifecycle.rs index a3c12e6e..74f49a3c 100644 --- a/client/tests/file_unlocked_keyring/lifecycle.rs +++ b/client/tests/file_unlocked_keyring/lifecycle.rs @@ -1,13 +1,12 @@ -use oo7::{Key, Secret, file::*}; -use tempfile::tempdir; +use std::path::PathBuf; #[cfg(feature = "async-std")] use async_std::fs; +use oo7::{Key, Secret, file::*}; +use tempfile::tempdir; #[cfg(feature = "tokio")] use tokio::fs; -use std::path::PathBuf; - use super::strong_key; #[tokio::test] diff --git a/server/src/collection/tests/items.rs b/server/src/collection/tests/items.rs index b5a767b4..919d1d0f 100644 --- a/server/src/collection/tests/items.rs +++ b/server/src/collection/tests/items.rs @@ -213,6 +213,63 @@ async fn create_item_with_replace_matches_attributes() -> Result<(), Box Result<(), Box> { + let setup = TestServiceSetup::plain_session(true).await?; + let attrs = &[("application", "dup-app"), ("username", "same-user")]; + + // Create 3 items with identical attributes (replace=false) + let item1 = setup + .create_item("Dup 1", attrs, "password-1", false) + .await?; + let item2 = setup + .create_item("Dup 2", attrs, "password-2", false) + .await?; + let item3 = setup + .create_item("Dup 3", attrs, "password-3", false) + .await?; + + assert_eq!(setup.collections[0].items().await?.len(), 3); + + let first_path = item1.inner().path().to_owned(); + + // Replace with a 4th + let replacement = setup + .create_item("Replacement", attrs, "password-final", true) + .await?; + + let items = setup.collections[0].items().await?; + assert_eq!( + items.len(), + 1, + "Should have exactly one item after replace dedup" + ); + + // The kept item should be at the first match's path + assert_eq!( + replacement.inner().path().as_str(), + first_path.as_str(), + "Replacement should reuse the first duplicate's D-Bus path" + ); + + // The removed items' D-Bus objects should be gone + assert!( + item2.secret(&setup.session).await.is_err(), + "Removed dup should not be accessible" + ); + assert!( + item3.secret(&setup.session).await.is_err(), + "Removed dup should not be accessible" + ); + + // Verify the secret is correct + let secret = replacement.secret(&setup.session).await?; + assert_eq!(secret.value(), b"password-final"); + + Ok(()) +} + #[tokio::test] async fn create_item_invalid_session() -> Result<(), Box> { let setup = TestServiceSetup::plain_session(true).await?; diff --git a/server/src/tests.rs b/server/src/tests.rs index fd751bb6..e0f83fd1 100644 --- a/server/src/tests.rs +++ b/server/src/tests.rs @@ -46,9 +46,7 @@ struct MockPrompters { } impl MockPrompters { - async fn register( - conn: &zbus::Connection, - ) -> Result> { + async fn register(conn: &zbus::Connection) -> Result> { #[cfg(any(feature = "gnome_native_crypto", feature = "gnome_openssl_crypto"))] let gnome = { let prompter = MockPrompterServiceGNOME::new();