git.delta.rocks / remowt / refs/commits / 2499daa8100a

--- /dev/null
+++ b/cmds/remowt-agent/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "remowt-agent"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1.0.86"
+clap = { version = "4.5.13", features = ["derive"] }
+pam-client = "0.5.0"
+polkit-shared = { version = "0.1.0", path = "../../crates/polkit-shared" }
+rand = "0.8.5"
+serde = { version = "1.0.204", features = ["derive"] }
+tokio = { version = "1.39.2", features = ["rt-multi-thread", "fs", "macros"] }
+tracing = "0.1.40"
+tracing-subscriber = "0.3.18"
+ui-prompt = { version = "0.1.0", path = "../../crates/ui-prompt" }
+uuid = { version = "1.10.0", features = ["v4"] }
+zbus = { version = "4.4.0", features = ["tokio"] }
+zbus_polkit = { version = "4.0.0", features = ["tokio"] }

--- /dev/null
+++ b/cmds/remowt-agent/src/main.rs
@@ -0,0 +1,197 @@
+use std::collections::HashMap;
+use std::io::{stdout, Write};
+use std::marker::PhantomData;
+use std::sync::{Mutex, RwLock};
+use std::{future, process};
+
+use clap::Parser;
+use polkit_shared::{BackendRequest, Identity};
+use tokio::runtime::Handle;
+use tokio::task::{AbortHandle, JoinHandle, LocalSet};
+use tracing::trace;
+use ui_prompt::dbus::DbusPrompterInterface;
+use ui_prompt::rofi::RofiPrompter;
+use ui_prompt::Prompter;
+use zbus::zvariant::{OwnedValue, Str};
+use zbus::ObjectServer;
+use zbus::{interface, proxy, Connection};
+use zbus_polkit::policykit1::Subject;
+
+struct TemporaryPrompterInterface<P: Prompter + Send + Sync + 'static> {
+    connection: Connection,
+    path: String,
+    _marker: PhantomData<P>,
+}
+impl<P: Prompter + Send + Sync + 'static> TemporaryPrompterInterface<P> {
+    async fn new(connection: Connection, prompter: P) -> Self {
+        let path = format!(
+            "/remowt/prompters/{}",
+            uuid::Uuid::new_v4().to_string().replace("-", "_")
+        );
+        let _ = connection
+            .object_server()
+            .at(path.clone(), DbusPrompterInterface(prompter))
+            .await;
+        Self {
+            connection,
+            path,
+            _marker: PhantomData,
+        }
+    }
+}
+impl<P: Prompter + Send + Sync + 'static> Drop for TemporaryPrompterInterface<P> {
+    fn drop(&mut self) {
+        // FIXME: block_in_place prevents to moving to current_thread runtime
+        // There should be a blocking way to remove ObjectServer listener.
+        // As far as I can see, it is only async because of async RwLock, shouldn't it be
+        // just a sync lock?
+        tokio::task::block_in_place(move || {
+            Handle::current().block_on(async {
+                let _ = self
+                    .connection
+                    .object_server()
+                    .remove::<DbusPrompterInterface<P>, String>(self.path.clone())
+                    .await;
+            });
+        });
+    }
+}
+
+struct Agent {
+    helper: PolkitHelperProxy<'static>,
+    tasks: Mutex<HashMap<String, AbortHandle>>,
+    connection: Connection,
+}
+impl Agent {
+    async fn new(connection: Connection) -> anyhow::Result<Self> {
+        Ok(Self {
+            helper: PolkitHelperProxy::new(&connection).await?,
+            tasks: Mutex::new(HashMap::new()),
+            connection,
+        })
+    }
+}
+
+#[interface(name = "org.freedesktop.PolicyKit1.AuthenticationAgent")]
+impl Agent {
+    /// BeginAuthentication method
+    #[allow(clippy::too_many_arguments)]
+    async fn begin_authentication(
+        &mut self,
+        action_id: String,
+        message: String,
+        icon_name: String,
+        details: HashMap<String, String>,
+        cookie: String,
+        identities: Vec<Identity>,
+    ) -> zbus::fdo::Result<()> {
+        trace!("begin auth");
+        let task = {
+            let connection = self.connection.clone();
+            let helper = self.helper.clone();
+            let cookie = cookie.clone();
+            tokio::task::spawn(async move {
+                trace!("conversation task");
+                let prompter = TemporaryPrompterInterface::new(connection, RofiPrompter).await;
+                helper
+                    .init_conversation(
+                        BackendRequest {
+                            cookie: cookie.to_owned(),
+                            environment: HashMap::new(),
+                            prompter_path: prompter.path.clone(),
+                            // TODO: Let user choose
+                            identity: identities.get(0).expect("first always exists").clone(),
+                        }, // cookie.to_owned(), HashMap::new(), prompter.path.clone()
+                    )
+                    .await?;
+                println!("ASKED");
+                dbg!(action_id, message, icon_name, details, cookie, identities);
+
+                Ok(())
+            })
+        };
+
+        self.tasks
+            .lock()
+            .unwrap()
+            .insert(cookie.clone(), task.abort_handle());
+        let result = task.await.expect("join error");
+        // The only way to no reach this line, is to either panic in previous line, or if authorization cancelled,
+        // while cancellation will remove task by itself.
+        // TODO: But still it would be better to have abort guard, which will remove it from HashMap
+        self.tasks.lock().unwrap().remove(&cookie);
+
+        result
+    }
+
+    /// CancelAuthentication method
+    async fn cancel_authentication(&self, cookie: &str) -> zbus::fdo::Result<()> {
+        trace!("cancel auth");
+        if let Some(abort) = self.tasks.lock().unwrap().remove(cookie) {
+            abort.abort();
+        }
+        // debug!("Authentication cancled ! {cookie}");
+        Ok(())
+    }
+}
+
+const OBJ_PATH: &str = "/0lach/polkitAgent";
+
+#[proxy(
+    interface = "lach.PolkitHelper",
+    default_service = "lach.polkit.helper1",
+    default_path = "/lach/PolkitHelper"
+)]
+trait PolkitHelper {
+    fn init_conversation(&self, request: BackendRequest) -> zbus::Result<()>;
+}
+
+#[derive(Parser)]
+enum Opts {
+    Agent,
+    AskPass { description: String },
+}
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    tracing_subscriber::fmt::init();
+    let opts = Opts::parse();
+
+    match opts {
+        Opts::Agent => {
+            trace!("started");
+            let conn = Connection::system().await?;
+
+            let proxy = zbus_polkit::policykit1::AuthorityProxy::new(&conn).await?;
+            conn.object_server()
+                .at(OBJ_PATH, Agent::new(conn.clone()).await?)
+                .await?;
+
+            let session_id = std::env::var("XDG_SESSION_ID")?;
+            let mut details = HashMap::new();
+            let val: OwnedValue = {
+                let wrapped: Str<'_> = session_id.into();
+                wrapped.into()
+            };
+            details.insert("session-id".to_string(), val);
+            proxy
+                .register_authentication_agent(
+                    &Subject {
+                        subject_kind: "unix-session".to_string(),
+                        subject_details: details,
+                    },
+                    "C",
+                    OBJ_PATH,
+                )
+                .await?;
+        }
+        Opts::AskPass { description } => {
+            let password = RofiPrompter
+                .prompt_text(false, &description, "SSH password request", &[])
+                .await?;
+            stdout().lock().write_all(password.as_bytes())?;
+        }
+    }
+
+    future::pending().await
+}

--- /dev/null
+++ b/cmds/remowt-ssh/Cargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "remowt-ssh"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

--- /dev/null
+++ b/cmds/remowt-ssh/src/main.rs
@@ -0,0 +1,3 @@
+fn main() {
+    println!("Hello, world!");
+}