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 "" 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 Result<(), Box 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/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 4e8ab206..9bc1c80b 100644 --- a/server/src/prompt/tests.rs +++ b/server/src/prompt/tests.rs @@ -99,3 +99,293 @@ 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>, + /// Passwords handed out one per prompt, for retry testing + password_queue: 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 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 + .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(()) +} + +#[tokio::test] +async fn unlock_with_cli_prompter_retry() -> 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(()) +} diff --git a/server/src/service/locking.rs b/server/src/service/locking.rs index b555bc60..fcf13ea1 100644 --- a/server/src/service/locking.rs +++ b/server/src/service/locking.rs @@ -155,6 +155,12 @@ impl Service { } } + /// Whether a legacy keyring awaits migration under this collection's + /// name. + pub(crate) async fn has_pending_migration(&self, name: &str) -> 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 = { 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)