server: kde plasma prompter support

hsitter · hsitter · commit 19fe595908c9 · 2026-01-07T15:56:38.000+01:00
slated to be introduced as part of Plasma 6.6
diff --git a/server/src/main.rs b/server/src/main.rs
@@ -4,6 +4,7 @@ mod error;
 mod gnome;
 mod item;
 mod pam_listener;
+mod plasma;
 mod prompt;
 mod service;
 mod session;
diff --git a/server/src/plasma/mod.rs b/server/src/plasma/mod.rs
@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2025 Harald Sitter <sitter@kde.org>
+
+pub mod prompter;
diff --git a/server/src/plasma/prompter.rs b/server/src/plasma/prompter.rs
@@ -0,0 +1,173 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2025 Harald Sitter <sitter@kde.org>
+
+use ashpd::{ActivationToken, WindowIdentifierType};
+use oo7::dbus::ServiceError;
+
+use serde::Serialize;
+use zbus::{
+    object_server::SignalEmitter,
+    zvariant::{self, ObjectPath, Optional, OwnedFd, OwnedObjectPath, Type},
+};
+
+use crate::{
+    prompt::{Prompt, PromptRole},
+    service::Service,
+};
+use tokio::io::AsyncReadExt;
+
+use std::os::fd::AsFd;
+
+#[repr(i32)]
+#[derive(Debug, Type, Serialize)]
+pub enum CallbackAction {
+    Dismiss = 0,
+    Keep = 1,
+}
+
+#[zbus::proxy(
+    default_service = "org.kde.secretprompter",
+    interface = "org.kde.secretprompter",
+    default_path = "/SecretPrompter",
+    gen_blocking = false
+)]
+pub trait PlasmaPrompter {
+    fn unlock_collection_prompt(
+        &self,
+        request: &ObjectPath<'_>,
+        window_id: Optional<WindowIdentifierType>,
+        activation_token: ActivationToken,
+        collection_name: &str,
+    ) -> Result<(), ServiceError>;
+    fn create_collection_prompt(
+        &self,
+        request: &ObjectPath<'_>,
+        window_id: Optional<WindowIdentifierType>,
+        activation_token: ActivationToken,
+        collection_name: &str,
+    ) -> Result<(), ServiceError>;
+}
+
+#[derive(Debug, Clone)]
+pub struct PlasmaPrompterCallback {
+    service: Service,
+    prompt_path: OwnedObjectPath,
+    path: OwnedObjectPath,
+}
+
+#[zbus::interface(name = "org.kde.secretprompter.request")]
+impl PlasmaPrompterCallback {
+    pub async fn accepted(&self, result_fd: OwnedFd) -> Result<CallbackAction, ServiceError> {
+        let prompt_path = &self.prompt_path;
+        let Some(prompt) = self.service.prompt(prompt_path).await else {
+            return Err(ServiceError::NoSuchObject(format!(
+                "Prompt '{prompt_path}' does not exist."
+            )));
+        };
+
+        tracing::debug!("User accepted the prompt.");
+
+        let secret = {
+            let borrowed_fd = result_fd.as_fd();
+            let std_stream = std::os::unix::net::UnixStream::from(
+                borrowed_fd
+                    .try_clone_to_owned()
+                    .expect("Failed to clone fd"),
+            );
+            let mut stream = tokio::net::UnixStream::from_std(std_stream).unwrap();
+            let mut buffer = String::new();
+            stream
+                .read_to_string(&mut buffer)
+                .await
+                .expect("error reading secret");
+            buffer
+        };
+
+        self.on_reply(&prompt, &secret).await
+    }
+
+    pub async fn rejected(&self) -> Result<CallbackAction, ServiceError> {
+        tracing::debug!("User rejected the prompt.");
+        self.prompter_dismissed(self.prompt_path.clone()).await?;
+        Ok(CallbackAction::Dismiss) // simply dismiss without further action
+    }
+
+    pub async fn dismissed(&self) -> Result<(), ServiceError> {
+        // This is only does check if the prompt is tracked on Service
+        let path = &self.prompt_path;
+        if let Some(_prompt) = self.service.prompt(path).await {
+            self.service
+                .object_server()
+                .remove::<Prompt, _>(path)
+                .await?;
+            self.service.remove_prompt(path).await;
+        }
+        self.service
+            .object_server()
+            .remove::<Self, _>(&self.path)
+            .await?;
+
+        Ok(())
+    }
+
+    #[zbus(signal)]
+    pub async fn retry(signal_emitter: &SignalEmitter<'_>, reason: &str) -> zbus::Result<()>;
+
+    #[zbus(signal)]
+    pub async fn dismiss(signal_emitter: &SignalEmitter<'_>) -> zbus::Result<()>;
+}
+
+impl PlasmaPrompterCallback {
+    pub async fn new(
+        service: Service,
+        prompt_path: OwnedObjectPath,
+    ) -> Result<Self, oo7::crypto::Error> {
+        let index = service.prompt_index().await;
+        Ok(Self {
+            path: OwnedObjectPath::try_from(format!("/org/plasma/keyring/Prompt/p{index}"))
+                .unwrap(),
+            service,
+            prompt_path,
+        })
+    }
+
+    pub fn path(&self) -> &ObjectPath<'_> {
+        &self.path
+    }
+
+    async fn on_reply(&self, prompt: &Prompt, reply: &str) -> Result<CallbackAction, ServiceError> {
+        let secret = oo7::Secret::from(reply);
+
+        // Handle each role differently based on what validation/preparation is needed
+        match prompt.role() {
+            PromptRole::Unlock => {
+                if prompt.on_unlock_collection(secret).await? {
+                    Ok(CallbackAction::Dismiss)
+                } else {
+                    let emitter = SignalEmitter::from_parts(
+                        self.service.connection().clone(),
+                        self.path().clone(),
+                    );
+                    PlasmaPrompterCallback::retry(&emitter, "The unlock password was incorrect")
+                        .await?;
+
+                    Ok(CallbackAction::Keep) // we retry
+                }
+            }
+            PromptRole::CreateCollection => {
+                prompt.on_create_collection(secret).await?;
+                Ok(CallbackAction::Dismiss)
+            }
+        }
+    }
+
+    async fn prompter_dismissed(&self, prompt_path: OwnedObjectPath) -> Result<(), ServiceError> {
+        let signal_emitter = self.service.signal_emitter(prompt_path)?;
+        let result = zvariant::Value::new::<Vec<OwnedObjectPath>>(vec![])
+            .try_into_owned()
+            .unwrap();
+
+        tokio::spawn(async move { Prompt::completed(&signal_emitter, true, result).await });
+        Ok(())
+    }
+}
diff --git a/server/src/prompt/mod.rs b/server/src/prompt/mod.rs
@@ -1,7 +1,7 @@
 // org.freedesktop.Secret.Prompt
+use std::{env, future::Future, pin::Pin, str::FromStr, sync::Arc};
 
-use std::{future::Future, pin::Pin, str::FromStr, sync::Arc};
-
+use ashpd::{ActivationToken, WindowIdentifier};
 use oo7::{Secret, dbus::ServiceError};
 use tokio::sync::{Mutex, OnceCell};
 use zbus::{
@@ -13,6 +13,7 @@ use zbus::{
 use crate::{
     error::custom_service_error,
     gnome::prompter::{PrompterCallback, PrompterProxy},
+    plasma::prompter::{PlasmaPrompterCallback, PlasmaPrompterProxy},
     service::Service,
 };
 
@@ -63,6 +64,8 @@ pub struct Prompt {
     collection: Option<crate::collection::Collection>,
     /// GNOME Specific
     callback: Arc<OnceCell<PrompterCallback>>,
+    /// KDE Plasma Specific
+    callback_plasma: Arc<OnceCell<PlasmaPrompterCallback>>,
     /// The action to execute when the prompt completes
     action: Arc<Mutex<Option<PromptAction>>>,
 }
@@ -83,6 +86,67 @@ impl std::fmt::Debug for Prompt {
 #[interface(name = "org.freedesktop.Secret.Prompt")]
 impl Prompt {
     pub async fn prompt(&self, window_id: Optional<&str>) -> Result<(), ServiceError> {
+        let is_plasma = env::var("XDG_CURRENT_DESKTOP")
+            .map(|v| v.to_lowercase() == "kde")
+            .unwrap_or(false);
+
+        if is_plasma {
+            if self.callback_plasma.get().is_some() {
+                return Err(custom_service_error(
+                    "A prompt callback is ongoing already.",
+                ));
+            };
+
+            let callback = PlasmaPrompterCallback::new(self.service.clone(), self.path.clone())
+                .await
+                .map_err(|err| {
+                    custom_service_error(&format!("Failed to create PrompterCallback {err}."))
+                })?;
+
+            let path = OwnedObjectPath::from(callback.path().clone());
+
+            self.callback_plasma
+                .set(callback.clone())
+                .expect("A prompt callback is only set once");
+
+            self.service.object_server().at(&path, callback).await?;
+            tracing::debug!("Prompt `{}` created.", self.path);
+
+            let prompter = PlasmaPrompterProxy::new(self.service.connection()).await?;
+            let window_id =
+                (*window_id).and_then(|w| ashpd::WindowIdentifierType::from_str(w).ok());
+
+            let collection_name = self.label.clone();
+            match self.role() {
+                PromptRole::Unlock => {
+                    tokio::spawn(async move {
+                        prompter
+                            .unlock_collection_prompt(
+                                &path,
+                                window_id,
+                                ActivationToken::from(""),
+                                collection_name.as_str(),
+                            )
+                            .await
+                    });
+                }
+                PromptRole::CreateCollection => {
+                    tokio::spawn(async move {
+                        prompter
+                            .create_collection_prompt(
+                                &path,
+                                window_id,
+                                ActivationToken::from(""),
+                                collection_name.as_str(),
+                            )
+                            .await
+                    });
+                }
+            }
+
+            return Ok(());
+        }
+
         if self.callback.get().is_some() {
             return Err(custom_service_error(
                 "A prompt callback is ongoing already.",
@@ -108,7 +172,7 @@ impl Prompt {
         self.service.object_server().at(&path, callback).await?;
         tracing::debug!("Prompt `{}` created.", self.path);
 
-        // Starts GNOME System Prompting.
+        // Starts System Prompting.
         // Spawned separately to avoid blocking the early return of the current
         // execution.
         let prompter = PrompterProxy::new(self.service.connection()).await?;
@@ -118,6 +182,14 @@ impl Prompt {
     }
 
     pub async fn dismiss(&self) -> Result<(), ServiceError> {
+        if let Some(callback_plasma) = self.callback_plasma.get() {
+            let emitter = SignalEmitter::from_parts(
+                self.service.connection().clone(),
+                callback_plasma.path().clone(),
+            );
+            PlasmaPrompterCallback::dismiss(&emitter).await?;
+        }
+
         if let Some(_callback) = self.callback.get() {
             // TODO: figure out if we should destroy the un-export the callback
             // here?
@@ -156,6 +228,7 @@ impl Prompt {
             label,
             collection,
             callback: Default::default(),
+            callback_plasma: Default::default(),
             action: Arc::new(Mutex::new(None)),
         }
     }
