From 77d3c4c49f636f3c68d1d334bed741c7fe549337 Mon Sep 17 00:00:00 2001 From: Bilal Elmoussaoui Date: Fri, 20 Nov 2026 11:31:55 +0100 Subject: [PATCH 1/6] coverage: Exclude the login helper and keep the LCOV data The login helper is a binary spawned from the PAM module, tarpaulin can't execute it. The combined LCOV file is kept around, it has the per-line records the JSON report lacks. The HTML report stays at coverage/html, where grcov nests it and the CI parses its coverage.json summary. --- coverage.sh | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/coverage.sh b/coverage.sh index 04aa588f..f1d0dace 100755 --- a/coverage.sh +++ b/coverage.sh @@ -63,7 +63,8 @@ grcov coverage-raw/combined.info \ --ignore "**/target/*" \ --ignore "**/error.rs" \ --ignore "**/main.rs" \ - --ignore "**/capability.rs" + --ignore "**/capability.rs" \ + --ignore "**/login.rs" # Generate HTML report with grcov grcov coverage-raw/combined.info \ @@ -84,20 +85,24 @@ grcov coverage-raw/combined.info \ --ignore "**/target/*" \ --ignore "**/error.rs" \ --ignore "**/main.rs" \ - --ignore "**/capability.rs" + --ignore "**/capability.rs" \ + --ignore "**/login.rs" # Extract and display coverage percentage -if [ -f coverage/html/coverage.json ]; then - COVERAGE=$(jq -r '.message' coverage/html/coverage.json | sed 's/%//') +if [ -f coverage/coverage.json ]; then + COVERAGE=$(jq -r '.coveragePercent' coverage/coverage.json) + COVERED=$(jq -r '.linesCovered' coverage/coverage.json) + TOTAL=$(jq -r '.linesTotal' coverage/coverage.json) echo "" - echo "✅ Combined coverage: ${COVERAGE}%" + echo "✅ Combined coverage: ${COVERAGE}% (${COVERED}/${TOTAL} lines)" echo "📁 HTML report available at: coverage/html/index.html" echo "📁 JSON report available at: coverage/coverage.json" else echo "⚠️ Warning: coverage.json not found" fi -# Clean up raw files +# Keep the combined LCOV file for line-level analysis +mv coverage-raw/combined.info coverage/combined.info rm -rf coverage-raw echo "" From 1dbe0a51ce276d2dc57c4b7519d7c2c24ea07881 Mon Sep 17 00:00:00 2001 From: Bilal Elmoussaoui Date: Fri, 20 Nov 2026 11:41:18 +0100 Subject: [PATCH 2/6] server: Test the CLI and plasma prompter dismissed paths The terminal prompter used by CLI sessions and the dismiss cleanup of the plasma prompter callback had no coverage. --- server/src/prompt/tests.rs | 193 +++++++++++++++++++++++++++++++++++++ 1 file changed, 193 insertions(+) diff --git a/server/src/prompt/tests.rs b/server/src/prompt/tests.rs index 4e8ab206..24af6cbd 100644 --- a/server/src/prompt/tests.rs +++ b/server/src/prompt/tests.rs @@ -99,3 +99,196 @@ async fn dismiss_prompt_cleanup() -> Result<(), Box> { Ok(()) } + +/// Mock of the terminal prompter the CLI registers +#[derive(Clone, Default)] +struct MockCliPrompter { + password: Arc>>, + accept: Arc>, +} + +#[zbus::interface(name = "org.freedesktop.secrets.CliPrompter")] +impl MockCliPrompter { + async fn prompt( + &self, + _label: &str, + _description: &str, + ) -> zbus::fdo::Result<(zbus::wire::OwnedFd, bool)> { + if !*self.accept.lock().await { + let (read_end, _) = std::os::unix::net::UnixStream::pair() + .map_err(|e| zbus::fdo::Error::Failed(e.to_string()))?; + return Ok(( + zbus::wire::OwnedFd::from(std::os::fd::OwnedFd::from(read_end)), + false, + )); + } + + let password = self + .password + .lock() + .await + .clone() + .unwrap_or_else(|| oo7::Secret::from("")); + let (read_end, mut write_end) = std::os::unix::net::UnixStream::pair() + .map_err(|e| zbus::fdo::Error::Failed(e.to_string()))?; + write_end + .write_all(password.as_bytes()) + .map_err(|e| zbus::fdo::Error::Failed(e.to_string()))?; + drop(write_end); + Ok(( + zbus::wire::OwnedFd::from(std::os::fd::OwnedFd::from(read_end)), + true, + )) + } +} + +use std::{io::Write as _, sync::Arc}; + +#[tokio::test] +async fn unlock_with_cli_prompter() -> Result<(), Box> { + let setup = TestServiceSetup::plain_session(true).await?; + setup + .server + .set_prompter_type(crate::service::PrompterType::Cli) + .await; + + let mock = MockCliPrompter::default(); + *mock.password.lock().await = setup.keyring_secret.clone(); + *mock.accept.lock().await = true; + setup + .client_conn + .object_server() + .at("/org/freedesktop/secrets/CliPrompter", mock) + .await?; + + setup.lock_collection(&setup.collections[0]).await?; + assert!(setup.collections[0].is_locked().await?); + + let unlocked = setup + .service_api + .unlock(&[setup.collections[0].inner().path()], None) + .await?; + assert_eq!(unlocked.len(), 1); + assert!(!setup.collections[0].is_locked().await?); + + Ok(()) +} + +#[tokio::test] +async fn unlock_with_cli_prompter_dismissed() -> Result<(), Box> { + let setup = TestServiceSetup::plain_session(true).await?; + setup + .server + .set_prompter_type(crate::service::PrompterType::Cli) + .await; + + let mock = MockCliPrompter::default(); + *mock.accept.lock().await = false; + setup + .client_conn + .object_server() + .at("/org/freedesktop/secrets/CliPrompter", mock) + .await?; + + setup.lock_collection(&setup.collections[0]).await?; + + let result = setup + .service_api + .unlock(&[setup.collections[0].inner().path()], None) + .await; + assert!(result.is_err(), "A dismissed prompt should fail the unlock"); + assert!( + setup.collections[0].is_locked().await?, + "Collection should remain locked" + ); + + Ok(()) +} + +#[cfg(any(feature = "plasma_native_crypto", feature = "plasma_openssl_crypto"))] +#[tokio::test] +async fn dismiss_prompt_cleanup_plasma() -> Result<(), Box> { + let setup = TestServiceSetup::plain_session(true).await?; + setup + .server + .set_prompter_type(crate::service::PrompterType::Plasma) + .await; + + setup.lock_collection(&setup.collections[0]).await?; + + let (_unlocked, prompt_path) = setup + .server + .unlock(vec![setup.collections[0].inner().path().to_owned().into()]) + .await?; + assert!(!prompt_path.is_empty(), "Should have a prompt path"); + + // Dismissing the prompt tells the plasma prompter to close its + // dialog and drops the prompt + let prompt = oo7::dbus::api::Prompt::new(&setup.client_conn, prompt_path.clone()) + .await? + .expect("prompt should be accessible"); + prompt.dismiss().await?; + + tokio::time::sleep(tokio::time::Duration::from_millis(50)).await; + assert!( + setup.server.prompt(&prompt_path).await.is_none(), + "Prompt should be removed from service after dismissal" + ); + + Ok(()) +} + +#[cfg(any(feature = "plasma_native_crypto", feature = "plasma_openssl_crypto"))] +#[tokio::test] +async fn plasma_prompter_callback_dismissed() -> Result<(), Box> { + use crate::plasma::prompter::PlasmaPrompterCallback; + + let setup = TestServiceSetup::plain_session(true).await?; + + setup.lock_collection(&setup.collections[0]).await?; + + let (_unlocked, prompt_path) = setup + .server + .unlock(vec![setup.collections[0].inner().path().to_owned().into()]) + .await?; + assert!(!prompt_path.is_empty(), "Should have a prompt path"); + assert!(setup.server.prompt(&prompt_path).await.is_some()); + + // Serve a callback like the plasma prompter would see one + let callback = PlasmaPrompterCallback::new(setup.server.clone(), prompt_path.clone()).await; + let callback_path: zbus::wire::OwnedObjectPath = callback.path().to_owned().into(); + setup + .server + .object_server() + .at(&callback_path, callback) + .await?; + + // The prompter dismissing its dialog drops the prompt and the callback + setup + .client_conn + .call_method( + None::<()>, + &callback_path, + Some("org.kde.secretprompter.request"), + "Dismissed", + &(), + ) + .await?; + + tokio::time::sleep(tokio::time::Duration::from_millis(50)).await; + assert!( + setup.server.prompt(&prompt_path).await.is_none(), + "Prompt should be removed from service" + ); + assert!( + setup + .server + .object_server() + .interface::<_, PlasmaPrompterCallback>(&callback_path) + .await + .is_err(), + "Callback should be removed from the object server" + ); + + Ok(()) +} From 0de9df7b178cb1199255af9bc8488840cc9d6831 Mon Sep 17 00:00:00 2001 From: Bilal Elmoussaoui Date: Fri, 20 Nov 2026 12:17:24 +0100 Subject: [PATCH 3/6] server: Retry the CLI prompter on a wrong secret A wrong password left the prompt completed without a signal, hanging the client until its timeout. Prompt again up to the maximum unlock attempts, then emit the dismissed completion. --- server/src/prompt/mod.rs | 85 ++++++++++++++++++++------------- server/src/prompt/tests.rs | 97 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 148 insertions(+), 34 deletions(-) diff --git a/server/src/prompt/mod.rs b/server/src/prompt/mod.rs index 11c85d8d..394cc915 100644 --- a/server/src/prompt/mod.rs +++ b/server/src/prompt/mod.rs @@ -450,44 +450,61 @@ impl Prompt { .expect("Wrong format in translatable string"), }; - match proxy.prompt(&self.label, &description).await { - Ok((fd, true)) => { - let std_stream = std::os::unix::net::UnixStream::from( - fd.as_fd().try_clone_to_owned().expect("Failed to clone fd"), - ); - std_stream.set_nonblocking(true).map_err(|e| { - custom_service_error(&format!("Failed to set non-blocking: {e}")) - })?; - let mut stream = tokio::net::UnixStream::from_std(std_stream) - .expect("Failed to create Tokio UnixStream"); - let mut buffer = zeroize::Zeroizing::new(Vec::new()); - stream.read_to_end(&mut buffer).await.map_err(|e| { - custom_service_error(&format!("Failed to read secret from CLI prompter: {e}")) - })?; - let secret = if buffer.is_empty() { - None - } else { - Some(Secret::from(buffer.as_slice())) - }; - - match self.role { - PromptRole::Unlock => { - self.on_unlock_collection(secret).await?; - } - PromptRole::CreateCollection => { - self.on_create_collection(secret).await?; + let mut attempts = 0; + loop { + let (fd, accepted) = match proxy.prompt(&self.label, &description).await { + Ok(result) => result, + Err(e) => return Err(custom_service_error(&format!("CLI prompter failed: {e}"))), + }; + if !accepted { + tracing::info!("CLI prompter dismissed by user."); + return Err(custom_service_error("Prompt dismissed by user.")); + } + + let std_stream = std::os::unix::net::UnixStream::from( + fd.as_fd().try_clone_to_owned().expect("Failed to clone fd"), + ); + std_stream + .set_nonblocking(true) + .map_err(|e| custom_service_error(&format!("Failed to set non-blocking: {e}")))?; + let mut stream = tokio::net::UnixStream::from_std(std_stream) + .expect("Failed to create Tokio UnixStream"); + let mut buffer = zeroize::Zeroizing::new(Vec::new()); + stream.read_to_end(&mut buffer).await.map_err(|e| { + custom_service_error(&format!("Failed to read secret from CLI prompter: {e}")) + })?; + let secret = if buffer.is_empty() { + None + } else { + Some(Secret::from(buffer.as_slice())) + }; + + match self.role { + PromptRole::Unlock => { + if self.on_unlock_collection(secret).await? { + return Ok(()); } - PromptRole::ChangePassword => { - self.on_change_password(secret).await?; + + attempts += 1; + if attempts >= MAX_UNLOCK_ATTEMPTS { + tracing::warn!( + "Maximum unlock attempts ({MAX_UNLOCK_ATTEMPTS}) reached, \ + dismissing prompt." + ); + self.emit_dismissed().await; + return Ok(()); } + // Prompt again, the secret was incorrect + } + PromptRole::CreateCollection => { + self.on_create_collection(secret).await?; + return Ok(()); + } + PromptRole::ChangePassword => { + self.on_change_password(secret).await?; + return Ok(()); } - Ok(()) - } - Ok((_, false)) => { - tracing::info!("CLI prompter dismissed by user."); - Err(custom_service_error("Prompt dismissed by user.")) } - Err(e) => Err(custom_service_error(&format!("CLI prompter failed: {e}"))), } } } diff --git a/server/src/prompt/tests.rs b/server/src/prompt/tests.rs index 24af6cbd..9bc1c80b 100644 --- a/server/src/prompt/tests.rs +++ b/server/src/prompt/tests.rs @@ -105,6 +105,8 @@ async fn dismiss_prompt_cleanup() -> Result<(), Box> { struct MockCliPrompter { password: Arc>>, accept: Arc>, + /// Passwords handed out one per prompt, for retry testing + password_queue: Arc>>, } #[zbus::interface(name = "org.freedesktop.secrets.CliPrompter")] @@ -129,6 +131,15 @@ impl MockCliPrompter { .await .clone() .unwrap_or_else(|| oo7::Secret::from("")); + let queued = { + let mut queue = self.password_queue.lock().await; + if queue.is_empty() { + None + } else { + Some(queue.remove(0)) + } + }; + let password = queued.unwrap_or(password); let (read_end, mut write_end) = std::os::unix::net::UnixStream::pair() .map_err(|e| zbus::fdo::Error::Failed(e.to_string()))?; write_end @@ -292,3 +303,89 @@ async fn plasma_prompter_callback_dismissed() -> Result<(), Box Result<(), Box> { + let setup = TestServiceSetup::plain_session(true).await?; + setup + .server + .set_prompter_type(crate::service::PrompterType::Cli) + .await; + + let mock = MockCliPrompter::default(); + *mock.accept.lock().await = true; + *mock.password_queue.lock().await = vec![ + oo7::Secret::from("wrong-password"), + setup.keyring_secret.clone().unwrap(), + ]; + setup + .client_conn + .object_server() + .at("/org/freedesktop/secrets/CliPrompter", mock) + .await?; + + // An item makes the keyring validate the secret + setup + .create_item( + "Test Item", + &[("app", "cli-prompter")], + "item-secret", + false, + ) + .await?; + setup.lock_collection(&setup.collections[0]).await?; + + let unlocked = setup + .service_api + .unlock(&[setup.collections[0].inner().path()], None) + .await?; + assert_eq!(unlocked.len(), 1, "Should unlock after the retry"); + assert!(!setup.collections[0].is_locked().await?); + + Ok(()) +} + +#[tokio::test] +async fn unlock_with_cli_prompter_max_attempts() -> Result<(), Box> { + let setup = TestServiceSetup::plain_session(true).await?; + setup + .server + .set_prompter_type(crate::service::PrompterType::Cli) + .await; + + let mock = MockCliPrompter::default(); + *mock.accept.lock().await = true; + *mock.password_queue.lock().await = + vec![oo7::Secret::from("wrong-password"); crate::prompt::MAX_UNLOCK_ATTEMPTS as usize]; + setup + .client_conn + .object_server() + .at("/org/freedesktop/secrets/CliPrompter", mock) + .await?; + + // An item makes the keyring validate the secret + setup + .create_item( + "Test Item", + &[("app", "cli-prompter")], + "item-secret", + false, + ) + .await?; + setup.lock_collection(&setup.collections[0]).await?; + + let result = setup + .service_api + .unlock(&[setup.collections[0].inner().path()], None) + .await; + assert!( + matches!(result, Err(oo7::dbus::Error::Dismissed)), + "Expected Dismissed after max attempts, got: {result:?}" + ); + assert!( + setup.collections[0].is_locked().await?, + "Collection should remain locked" + ); + + Ok(()) +} From b00d6f468f3511a988c8470c977b2eada841d1d1 Mon Sep 17 00:00:00 2001 From: Bilal Elmoussaoui Date: Fri, 20 Nov 2026 12:47:09 +0100 Subject: [PATCH 4/6] server: Test the PAM secret buffering and socket validation A secret arriving before the service is initialized is buffered and replayed once the keyrings are discovered, and garbage on the PAM socket fails the connection without taking the listener down. --- server/src/pam_listener/tests.rs | 134 +++++++++++++++++++++++++++---- server/src/tests.rs | 32 ++++++-- 2 files changed, 143 insertions(+), 23 deletions(-) diff --git a/server/src/pam_listener/tests.rs b/server/src/pam_listener/tests.rs index 10c684c9..8febdad2 100644 --- a/server/src/pam_listener/tests.rs +++ b/server/src/pam_listener/tests.rs @@ -3,14 +3,17 @@ use zgvariant::serialized::Context; use super::*; -async fn spawn_pam_listener(server: &crate::Service) -> std::path::PathBuf { +/// Spawn the listener, returning its socket path and a clone sharing the +/// buffered secrets, for [`PamListener::replay_buffered_secrets`]. +async fn spawn_pam_listener(server: &crate::Service) -> (std::path::PathBuf, PamListener) { let pam_listener = PamListener::new(server.clone()); let socket_path = pam_listener.socket_path.clone(); + let spawned = pam_listener.clone(); tokio::spawn(async move { - let _ = pam_listener.start().await; + let _ = spawned.start().await; }); tokio::time::sleep(tokio::time::Duration::from_millis(10)).await; - socket_path + (socket_path, pam_listener) } fn create_pam_message( @@ -40,6 +43,18 @@ async fn send_pam_message( socket_path: &std::path::Path, message_bytes: &[u8], ) -> Result<(), Box> { + let response = send_pam_bytes(socket_path, message_bytes).await?; + if !response.success { + return Err(format!("PAM operation failed: {}", response.error_message).into()); + } + Ok(()) +} + +/// Send raw bytes on the PAM socket and read back the response, if any. +async fn send_pam_bytes( + socket_path: &std::path::Path, + message_bytes: &[u8], +) -> Result> { use tokio::io::{AsyncReadExt, AsyncWriteExt}; let mut stream = tokio::net::UnixStream::connect(socket_path).await?; @@ -54,14 +69,7 @@ async fn send_pam_message( let mut response_bytes = vec![0u8; response_length]; stream.read_exact(&mut response_bytes).await?; - let response = PamResponse::from_bytes(&response_bytes)?; - - // Check if response indicates success or error - if !response.success { - return Err(format!("PAM operation failed: {}", response.error_message).into()); - } - - Ok(()) + Ok(PamResponse::from_bytes(&response_bytes)?) } #[tokio::test] @@ -94,7 +102,7 @@ async fn pam_migrates_v0_keyrings() -> Result<(), Box> { "V0 keyring should be pending migration" ); - let socket_path = spawn_pam_listener(&setup.server).await; + let (socket_path, _) = spawn_pam_listener(&setup.server).await; let message = create_pam_message(PamOperation::Unlock, "testuser", &[], v0_secret.as_bytes()); send_pam_message(&socket_path, &message).await?; @@ -179,7 +187,7 @@ async fn pam_migration_then_write_to_default_alias() -> Result<(), Box Result<(), Box Result<(), Box> { "Work collection should be locked" ); - let socket_path = spawn_pam_listener(&setup.server).await; + let (socket_path, _) = spawn_pam_listener(&setup.server).await; let new_secret = Secret::from("new-password"); let message = create_pam_message( @@ -420,7 +428,7 @@ async fn pam_wrong_secret_keeps_pending_migration_locked() -> Result<(), Box Result<(), Box 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 secret = Secret::from("pam-password"); + let keyring = UnlockedKeyring::open_at(temp_dir.path(), "login", Some(secret.clone())).await?; + keyring + .create_item( + "Login Item", + &[("app", "pam-replay")], + Secret::text("item-secret"), + false, + ) + .await?; + keyring.write().await?; + + // The service is served on the bus but not initialized yet + let (server, server_conn, _client_conn, _parts_temp) = + crate::tests::TestServiceSetup::uninitialized_service( + temp_dir.path().to_path_buf(), + Some(temp_dir.path().join("pam.sock")), + ) + .await?; + + // The PAM secret arrives before the keyrings are discovered + let (socket_path, listener) = spawn_pam_listener(&server).await; + let message = create_pam_message(PamOperation::Unlock, "testuser", &[], secret.as_bytes()); + send_pam_message(&socket_path, &message).await?; + + // Initialize like Service::run does, then replay the buffered secret + let discovered = server.discover_keyrings(None).await?; + server + .initialize(server_conn, discovered, None, false) + .await?; + + let login = server + .collection_by_label("Login") + .await + .expect("Login collection should exist"); + assert!(login.is_locked().await, "No secret known at this point"); + + listener.replay_buffered_secrets().await; + + let login = server + .collection_by_label("Login") + .await + .expect("Login collection should exist"); + assert!( + !login.is_locked().await, + "The buffered secret should replay" + ); + + Ok(()) +} + +// Garbage on the PAM socket fails the connection cleanly +#[tokio::test] +async fn pam_malformed_message() -> Result<(), Box> { + let temp_dir = tempfile::tempdir()?; + + let setup = crate::tests::TestServiceSetup::with_disk_keyrings( + temp_dir.path().to_path_buf(), + Some(temp_dir.path().join("pam.sock")), + None, + ) + .await?; + + let (socket_path, _) = spawn_pam_listener(&setup.server).await; + + // A valid length prefix around bytes that don't parse as a message + let payload = b"definitely not a pam message"; + let mut message = (payload.len() as u32).to_le_bytes().to_vec(); + message.extend_from_slice(payload); + + let result = send_pam_bytes(&socket_path, &message).await; + assert!( + result.is_err(), + "A malformed message should fail the connection" + ); + + // The listener keeps serving valid messages afterwards + let secret = Secret::from("good-password"); + let message = create_pam_message(PamOperation::Unlock, "testuser", &[], secret.as_bytes()); + send_pam_message(&socket_path, &message).await?; + + Ok(()) +} diff --git a/server/src/tests.rs b/server/src/tests.rs index 30f95f85..f52bc9e8 100644 --- a/server/src/tests.rs +++ b/server/src/tests.rs @@ -242,17 +242,24 @@ impl TestServiceSetup { }) } - /// Create a test setup that discovers keyrings from disk - /// This is useful for PAM tests that need to create keyrings on disk first - pub(crate) async fn with_disk_keyrings( + /// A service served on a p2p connection, but not yet initialized. The + /// caller drives discovery and [`crate::Service::initialize`], like + /// [`crate::Service::run`] does. + pub(crate) async fn uninitialized_service( data_dir: std::path::PathBuf, pam_socket: Option, - secret: Option, - ) -> Result> { + ) -> Result< + ( + crate::Service, + zbus::Connection, + zbus::Connection, + tempfile::TempDir, + ), + Box, + > { use zbus::proxy::Defaults; let (server_conn, client_conn) = create_p2p_connection().await?; - let temp_dir = tempfile::TempDir::new()?; let service = crate::Service::new(data_dir, pam_socket, true); @@ -273,6 +280,19 @@ impl TestServiceSetup { ) .await?; + Ok((service, server_conn, client_conn, temp_dir)) + } + + /// Create a test setup that discovers keyrings from disk + /// This is useful for PAM tests that need to create keyrings on disk first + pub(crate) async fn with_disk_keyrings( + data_dir: std::path::PathBuf, + pam_socket: Option, + secret: Option, + ) -> Result> { + let (service, server_conn, client_conn, temp_dir) = + Self::uninitialized_service(data_dir, pam_socket).await?; + let discovered = service.discover_keyrings(secret.clone()).await?; service .initialize(server_conn, discovered, secret.clone(), false) From 5720623c0b7158f95015e42eacd8903b5094b176 Mon Sep 17 00:00:00 2001 From: Bilal Elmoussaoui Date: Fri, 20 Nov 2026 13:06:12 +0100 Subject: [PATCH 5/6] server: Refuse deleting the placeholder of a pending migration Deleting it prompted for the secret, completed the migration and threw the result away, destroying the legacy keyring's data. Unlock the collection first to migrate it, then delete it if that is really wanted. --- server/src/collection/mod.rs | 8 ++++++++ server/src/collection/tests/deletion.rs | 22 +++++++++++++++++++++- server/src/service/locking.rs | 6 ++++++ 3 files changed, 35 insertions(+), 1 deletion(-) diff --git a/server/src/collection/mod.rs b/server/src/collection/mod.rs index 42611641..73c17677 100644 --- a/server/src/collection/mod.rs +++ b/server/src/collection/mod.rs @@ -52,6 +52,14 @@ impl Collection { } else { "unknown".to_string() }; + // Deleting the placeholder of a pending migration would migrate + // the legacy keyring and throw the result away + if self.service.has_pending_migration(self.name()).await { + return Err(ServiceError::IsLocked(format!( + "Collection `{}` holds a keyring awaiting migration, unlock it first.", + self.path + ))); + } // Check if collection is locked if self.is_locked().await { // Create a prompt to unlock and delete the collection diff --git a/server/src/collection/tests/deletion.rs b/server/src/collection/tests/deletion.rs index c4c2d508..f8a591a3 100644 --- a/server/src/collection/tests/deletion.rs +++ b/server/src/collection/tests/deletion.rs @@ -134,11 +134,31 @@ async fn delete_locked_pending_migration() -> Result<(), Box bool { + self.pending_migrations.lock().await.contains_key(name) + } + pub(crate) async fn perform_unlock(&self, objects: &[OwnedObjectPath], secret: Option) { for object in objects { let collection = { From 300dfeced513a769d62b338c31a4ce3de30fc934 Mon Sep 17 00:00:00 2001 From: Bilal Elmoussaoui Date: Fri, 20 Nov 2026 13:29:27 +0100 Subject: [PATCH 6/6] server: Refuse deleting an item of a pending migration placeholder Like the collection deletion, it would migrate the legacy keyring and throw the item away. Storing items keeps migrating transparently, only destructive operations now require unlocking first. --- server/src/collection/tests/items.rs | 22 ++++++++++++++++++++-- server/src/item/mod.rs | 10 ++++++++++ 2 files changed, 30 insertions(+), 2 deletions(-) diff --git a/server/src/collection/tests/items.rs b/server/src/collection/tests/items.rs index ff642383..e1f520a2 100644 --- a/server/src/collection/tests/items.rs +++ b/server/src/collection/tests/items.rs @@ -576,13 +576,31 @@ async fn delete_item_pending_migration() -> Result<(), Box