`47f3231`

derive sender from peer credentials

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 2 months ago

SHA: 47f323179285e041c2c9de441e7b257f37796037
Parents: 9e7714d
Tree: f23282f

3 changed files

Status	File	+	-
M	`Cargo.lock`	1	0
M	`garwarp/Cargo.toml`	1	0
M	`garwarp/src/daemon.rs`	107	24

Cargo.lockmodified


 version = "0.1.0"
 dependencies = [
  "garwarp-ipc",
+ "libc",
  "zbus",
 ]
 

garwarp/Cargo.tomlmodified

`@@ -6,3 +6,4 @@` edition = "2024"
6	[dependencies]	6	[dependencies]
7	garwarp-ipc = { path = "../garwarp-ipc" }	7	garwarp-ipc = { path = "../garwarp-ipc" }
8	zbus = "5.14.0"	8	zbus = "5.14.0"
		9	+libc = "0.2"

garwarp/src/daemon.rsmodified

+         }
          Some(ControlRequest::BeginRequest {
              id,
--            sender,
++            sender: _sender,
              app_id,
              parent_window,
          }) => {
++            let sender = match trusted_sender(reader.get_ref()) {
++                Ok(sender) => sender,
++                Err(error) => {
++                    let mapping = map_portal_error(&PortalError::InternalFailure);
++                    logging::warn(&format!("peer_identity_error={error}"));
++                    return write_response(
++                        reader.into_inner(),
++                        ControlResponse::Error {
++                            code: mapping.code as u32,
++                            reason: mapping.reason.to_string(),
++                        },
++                    );
++                }
++            };
++
              let validation = validate_request_identity(&id, &sender, app_id.as_deref());
              if let Err(error) = validation {
                  let mapping = map_portal_error(&error);
+         }
          Some(ControlRequest::TransitionRequest {
              id,
--            sender,
++            sender: _sender,
              app_id,
              target,
          }) => {
++            let sender = match trusted_sender(reader.get_ref()) {
++                Ok(sender) => sender,
++                Err(error) => {
++                    let mapping = map_portal_error(&PortalError::InternalFailure);
++                    logging::warn(&format!("peer_identity_error={error}"));
++                    return write_response(
++                        reader.into_inner(),
++                        ControlResponse::Error {
++                            code: mapping.code as u32,
++                            reason: mapping.reason.to_string(),
++                        },
++                    );
++                }
++            };
++
              let validation = validate_request_identity(&id, &sender, app_id.as_deref());
              if let Err(error) = validation {
                  let mapping = map_portal_error(&error);
      Ok(Some(quarantined))
+ }
++fn trusted_sender(stream: &UnixStream) -> io::Result<String> {
++    #[cfg(target_os = "linux")]
++    {
++        use std::mem;
++        use std::os::fd::AsRawFd;
++
++        let fd = stream.as_raw_fd();
++        let mut cred = libc::ucred {
++            pid: 0,
++            uid: 0,
++            gid: 0,
++        };
++        let mut len = mem::size_of::<libc::ucred>() as libc::socklen_t;
++        let rc = unsafe {
++            libc::getsockopt(
++                fd,
++                libc::SOL_SOCKET,
++                libc::SO_PEERCRED,
++                (&mut cred as *mut libc::ucred).cast::<libc::c_void>(),
++                &mut len,
++            )
++        };
++        if rc == -1 {
++            return Err(io::Error::last_os_error());
++        }
++        if len as usize != mem::size_of::<libc::ucred>() {
++            return Err(io::Error::other("invalid peer credential size"));
++        }
++        return Ok(canonical_sender_for_uid(cred.uid));
++    }
++
++    #[cfg(not(target_os = "linux"))]
++    {
++        let _ = stream;
++        Err(io::Error::new(
++            io::ErrorKind::Unsupported,
++            "peer credentials are unsupported on this platform",
++        ))
++    }
++}
++
++fn canonical_sender_for_uid(uid: u32) -> String {
++    format!(":uid.{uid}")
++}
++
  fn persist_registry_state(path: &std::path::Path, registry: &RequestRegistry) {
      if let Err(error) = request_store::persist_registry(path, registry) {
          logging::warn(&format!("request_store_write_failed error={error}"));
  #[cfg(test)]
  mod tests {
      use super::{
--        DaemonState, MAX_CONTROL_LINE_BYTES, handle_connection, load_registry_with_fallback,
++        DaemonState, MAX_CONTROL_LINE_BYTES, canonical_sender_for_uid, handle_connection,
--        load_registry_with_recovery,
++        load_registry_with_fallback, load_registry_with_recovery,
      };
      use garwarp_ipc::{ControlResponse, HealthStatus};
      use std::fs;
          std::env::temp_dir().join(format!("garwarp-daemon-recovery-{nanos}.state"))
+     }
++    fn local_sender() -> String {
++        canonical_sender_for_uid(unsafe { libc::geteuid() })
++    }
++
      #[test]
      fn status_request_returns_status_response() {
          let (mut client, server) = UnixStream::pair().expect("pair should be created");
              .requests
              .begin_at(
                  "req-1",
--                RequestOwner::new(":1.2", None),
++                RequestOwner::new(local_sender(), None),
                  None,
                  Instant::now(),
+             )
              .requests
              .transition(
                  "req-1",
--                &RequestOwner::new(":1.2", None),
++                &RequestOwner::new(local_sender(), None),
                  RequestState::AwaitingUser,
+             )
              .expect("request should transition");
              .requests
              .begin_at(
                  "req-1",
--                RequestOwner::new(":1.2", None),
++                RequestOwner::new(local_sender(), None),
                  Some(ParentWindowContext::X11 { window_id: 42 }),
                  Instant::now(),
+             )
              .requests
              .transition(
                  "req-1",
--                &RequestOwner::new(":1.2", None),
++                &RequestOwner::new(local_sender(), None),
                  RequestState::AwaitingUser,
+             )
              .expect("request should transition");
              .requests
              .begin_at(
                  "req-1",
--                RequestOwner::new(":1.2", None),
++                RequestOwner::new(":uid.4242", None),
                  Some(ParentWindowContext::X11 { window_id: 42 }),
                  Instant::now(),
+             )
+     }
      #[test]
--    fn invalid_sender_maps_to_invalid_request() {
++    fn payload_sender_is_ignored_for_begin() {
          let (mut client, server) = UnixStream::pair().expect("pair should be created");
          client
--            .write_all(b"transition id=req-1 sender=org.test.App state=cancelled\n")
++            .write_all(b"begin id=req-1 sender=org.test.App parent=x11:0x2a\n")
--            .expect("transition request should be written");
++            .expect("begin request should be written");
          let mut state = DaemonState {
              health: HealthStatus::Healthy,
              requests: RequestRegistry::new(Duration::from_secs(5)),
              running: true,
          };
--        handle_connection(server, &mut state).expect("transition should be handled");
++        handle_connection(server, &mut state).expect("begin should be handled");
          let mut response_line = String::new();
          let mut reader = BufReader::new(client);
          let response = ControlResponse::parse_line(&response_line).expect("response should parse");
          assert_eq!(
              response,
--            ControlResponse::Error {
++            ControlResponse::AckRequest {
--                code: 2,
++                id: "req-1".to_string(),
--                reason: "invalid_request".to_string(),
++                state: "pending".to_string(),
+             }
          );
++        assert_eq!(
++            state.requests.owner("req-1").map(|owner| owner.sender),
++            Some(local_sender())
++        );
+     }
      #[test]
              .requests
              .begin_at(
                  "req-1",
--                RequestOwner::new(":1.2", None),
++                RequestOwner::new(":uid.4242", None),
                  Some(ParentWindowContext::X11 { window_id: 42 }),
                  Instant::now(),
+             )
              .requests
              .begin_at(
                  "req-1",
--                RequestOwner::new(":1.2", None),
++                RequestOwner::new(local_sender(), None),
                  None,
                  Instant::now(),
+             )
              .requests
              .transition(
                  "req-1",
--                &RequestOwner::new(":1.2", None),
++                &RequestOwner::new(local_sender(), None),
                  RequestState::Cancelled,
+             )
              .expect("first cancel should transition");
              .requests
              .begin_at(
                  "req-1",
--                RequestOwner::new(":1.2", None),
++                RequestOwner::new(local_sender(), None),
                  None,
                  Instant::now(),
+             )
              .requests
              .transition(
                  "req-1",
--                &RequestOwner::new(":1.2", None),
++                &RequestOwner::new(local_sender(), None),
                  RequestState::AwaitingUser,
+             )
              .expect("first awaiting_user should transition");
              .requests
              .begin_at(
                  "req-1",
--                RequestOwner::new(":1.2", Some("org.test.App".to_string())),
++                RequestOwner::new(local_sender(), Some("org.test.App".to_string())),
                  Some(ParentWindowContext::X11 { window_id: 42 }),
                  Instant::now(),
+             )
              .requests
              .transition(
                  "req-1",
--                &RequestOwner::new(":1.2", Some("org.test.App".to_string())),
++                &RequestOwner::new(local_sender(), Some("org.test.App".to_string())),
                  RequestState::AwaitingUser,
+             )
              .expect("request should transition");
              ControlResponse::RequestSnapshot {
                  id: "req-1".to_string(),
                  state: "awaiting_user".to_string(),
--                sender: ":1.2".to_string(),
++                sender: local_sender(),
                  app_id: Some("org.test.App".to_string()),
                  parent_window: Some("x11:0x2a".to_string()),
+             }

`@@ -303,6 +303,7 @@` name = "garwarp"
303	version = "0.1.0"	303	version = "0.1.0"
304	dependencies = [	304	dependencies = [
305	"garwarp-ipc",	305	"garwarp-ipc",
		306	+ "libc",
306	"zbus",	307	"zbus",
307	]	308	]
308		309