//! Per-user, unprivileged storage and initiating-user resolution. //! //! Personal package preferences and proactive-alert state are user data, not //! system policy. They must be writable by a normal desktop account without //! touching `/etc` or `/var/lib`, while system-wide defaults stay root-owned and //! are only changed through an authenticated typed action. //! //! Three problems are solved here: //! //! 1. **Where** personal state lives: `/.config/phoebus/` and //! `/.local/state/phoebus/`, each created 0700 and written 0600 //! atomically. `PHOEBUS_PERSONAL_DIR` overrides the base for tests. //! 2. **Whose** state it is: when `sys` runs under `sudo`/`pkexec`, the //! effective uid is root but the preferences belong to the invoking user. //! [`initiating_uid`] resolves `PHOEBUS_UID` → `SUDO_UID` → `PKEXEC_UID` → //! the real/effective uid, and [`UserStorage::for_uid`] resolves that user's //! home from `/etc/passwd` rather than trusting `$HOME` (which `sudo` sets to //! root's). //! 3. **Ownership**: when the write runs elevated (effective root on behalf of a //! non-root initiating user), the created directories and file are chowned //! to the *initiating* user's uid/gid so the setting stays readable and //! replaceable by that user. A non-root process that is not the initiating //! user refuses to write. Paths are created component by component, reject //! symlinks, and must stay within the resolved home, so a planted symlink //! cannot redirect the write. use std::io::Write; use std::path::{Component, Path, PathBuf}; use crate::error::{ExecError, Result}; /// The uid that initiated the command, honouring the elevation wrappers so the /// CLI and GUI resolve the same user's storage. pub fn initiating_uid() -> u32 { for var in ["PHOEBUS_UID", "SUDO_UID", "PKEXEC_UID"] { if let Ok(value) = std::env::var(var) { if let Ok(uid) = value.trim().parse::() { return uid; } } } effective_uid() } pub fn effective_uid() -> u32 { // Read the effective uid from /proc without unsafe or a subprocess. The // second field of `Uid:` is the effective uid. if let Ok(status) = std::fs::read_to_string("/proc/self/status") { for line in status.lines() { if let Some(rest) = line.strip_prefix("Uid:") { if let Some(effective) = rest.split_whitespace().nth(1) { if let Ok(uid) = effective.parse::() { return uid; } } } } } std::process::Command::new("id") .arg("-u") .output() .ok() .and_then(|o| String::from_utf8_lossy(&o.stdout).trim().parse().ok()) .unwrap_or(1) } /// Look up a user's home directory from the passwd database. `$HOME` is not /// trusted because `sudo`/`pkexec` rewrite it. pub fn home_for_uid(uid: u32) -> Option { passwd_entry(uid).map(|(_, home)| home) } /// The user's primary group id, from the passwd database. pub fn primary_gid_for_uid(uid: u32) -> Option { let text = std::fs::read_to_string("/etc/passwd").ok()?; for line in text.lines() { let fields: Vec<&str> = line.split(':').collect(); if fields.len() >= 6 { if let Ok(line_uid) = fields[2].parse::() { if line_uid == uid { return fields[3].parse::().ok(); } } } } None } fn passwd_entry(uid: u32) -> Option<(u32, PathBuf)> { let text = std::fs::read_to_string("/etc/passwd").ok()?; for line in text.lines() { let fields: Vec<&str> = line.split(':').collect(); if fields.len() >= 6 { if let Ok(line_uid) = fields[2].parse::() { if line_uid == uid && !fields[5].trim().is_empty() { return Some((line_uid, PathBuf::from(fields[5].trim()))); } } } } None } /// The identity that should own a user's personal files, plus the effective uid /// of the writing process. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct Ownership { /// The initiating user that should own the files. pub uid: u32, /// The initiating user's primary gid (best effort; falls back to the uid). pub gid: u32, /// The effective uid of this process. pub euid: u32, } impl Ownership { pub fn for_uid(uid: u32) -> Self { Self { uid, gid: primary_gid_for_uid(uid).unwrap_or(uid), euid: effective_uid(), } } /// A non-root process that is not the initiating user must not write user /// data on their behalf. pub fn may_write(self) -> bool { self.euid == self.uid || self.euid == 0 } /// Whether the created paths must be chowned to the initiating user. Only /// root can do this. pub fn needs_fix(self) -> bool { self.euid == 0 && self.uid != 0 } } /// Chowns a freshly created path to the initiating user. Abstracted so the /// ownership logic can be tested without requiring root. pub trait OwnerFixer { fn fix(&self, path: &Path, uid: u32, gid: u32) -> std::io::Result<()>; } /// The production fixer: `chown(2)` via the standard library. pub struct RealOwnerFixer; impl OwnerFixer for RealOwnerFixer { fn fix(&self, path: &Path, uid: u32, gid: u32) -> std::io::Result<()> { std::os::unix::fs::chown(path, Some(uid), Some(gid)) } } /// A resolved, user-owned storage location. #[derive(Debug, Clone)] pub struct UserStorage { uid: u32, base: PathBuf, } impl UserStorage { /// Storage for a specific uid. `PHOEBUS_PERSONAL_DIR` overrides everything /// (used by tests and by a caller that already resolved the user's home). pub fn for_uid(uid: u32) -> Self { if let Ok(dir) = std::env::var("PHOEBUS_PERSONAL_DIR") { return Self { uid, base: PathBuf::from(dir), }; } let home = home_for_uid(uid).or_else(|| std::env::var_os("HOME").map(PathBuf::from)); let base = home.unwrap_or_else(|| PathBuf::from(format!("/tmp/phoebus-user-{uid}"))); Self { uid, base } } /// Storage for the user who invoked the command (through sudo/pkexec). pub fn for_initiating_user() -> Self { Self::for_uid(initiating_uid()) } /// An explicit base directory, for tests and callers that already resolved /// the user's home. pub fn with_base(uid: u32, base: impl Into) -> Self { Self { uid, base: base.into(), } } pub fn uid(&self) -> u32 { self.uid } pub fn base(&self) -> &Path { &self.base } /// The 0700 config directory for this user. pub fn config_dir(&self) -> PathBuf { self.base.join(".config/phoebus") } /// The 0700 state directory for this user. pub fn state_dir(&self) -> PathBuf { self.base.join(".local/state/phoebus") } pub fn config_file(&self, name: &str) -> PathBuf { self.config_dir().join(name) } pub fn state_file(&self, name: &str) -> PathBuf { self.state_dir().join(name) } /// Atomically write a 0600 file inside the given (0700) directory, owned by /// the initiating user. pub fn write_private(&self, dir: &Path, file: &Path, bytes: &[u8]) -> Result<()> { let ownership = Ownership::for_uid(self.uid); self.write_private_as(dir, file, bytes, ownership, &RealOwnerFixer) } /// Explicit-ownership variant, used by tests to exercise the elevated path /// and the ownership fixer without requiring root. pub(crate) fn write_private_as( &self, dir: &Path, file: &Path, bytes: &[u8], ownership: Ownership, fixer: &dyn OwnerFixer, ) -> Result<()> { if !ownership.may_write() { return Err(ExecError::operation( "personal", "write", format!( "refusing to write uid {} personal data as effective uid {}", ownership.uid, ownership.euid ), )); } // The file must live directly inside the target directory and both must // be within the resolved base, so a caller cannot redirect the write. if file.parent() != Some(dir) { return Err(ExecError::operation( "personal", "write", "the destination file is not inside the target directory", )); } if !self.is_within_base(dir) || !self.is_within_base(file) { return Err(ExecError::operation( "personal", "write", "refusing to write outside the user's own storage", )); } self.create_dir_chain(dir, ownership, fixer)?; // After creating the chain, verify the canonical directory has not // escaped the base through a symlink. let base = std::fs::canonicalize(&self.base).map_err(|e| ExecError::io(self.base.clone(), e))?; let dir_canon = std::fs::canonicalize(dir).map_err(|e| ExecError::io(dir.to_path_buf(), e))?; if !dir_canon.starts_with(&base) { return Err(ExecError::operation( "personal", "write", "the destination directory resolves outside the user's storage (symlink?)", )); } let tmp = dir.join(format!(".{}.tmp", tmp_token())); { let mut opts = std::fs::OpenOptions::new(); opts.write(true).create_new(true); #[cfg(unix)] { use std::os::unix::fs::OpenOptionsExt; opts.mode(0o600); } let mut fh = opts.open(&tmp).map_err(|e| ExecError::io(tmp.clone(), e))?; fh.write_all(bytes) .and_then(|_| fh.flush()) .and_then(|_| fh.sync_all()) .map_err(|e| ExecError::io(tmp.clone(), e))?; } if ownership.needs_fix() { fixer .fix(&tmp, ownership.uid, ownership.gid) .map_err(|e| ExecError::io(tmp.clone(), e))?; } std::fs::rename(&tmp, file).map_err(|e| { let _ = std::fs::remove_file(&tmp); ExecError::io(file.to_path_buf(), e) })?; if ownership.needs_fix() { // rename preserves ownership; this also repairs a pre-existing file // that was created root-owned by an older, buggy writer. fixer .fix(file, ownership.uid, ownership.gid) .map_err(|e| ExecError::io(file.to_path_buf(), e))?; } if let Ok(dir) = std::fs::File::open(dir) { let _ = dir.sync_all(); } Ok(()) } /// Lexical containment check: `path` must be `base` or below it. fn is_within_base(&self, path: &Path) -> bool { path.starts_with(&self.base) } /// Create `dir` component by component beneath `base`, rejecting symlinks /// and non-directories, setting 0700, and chowning to the initiating user /// when this process is elevated. fn create_dir_chain( &self, dir: &Path, ownership: Ownership, fixer: &dyn OwnerFixer, ) -> Result<()> { let meta = std::fs::symlink_metadata(&self.base) .map_err(|e| ExecError::io(self.base.clone(), e))?; if meta.file_type().is_symlink() || !meta.is_dir() { return Err(ExecError::operation( "personal", "write", "the user's home is not a real directory", )); } let rel = dir.strip_prefix(&self.base).map_err(|_| { ExecError::operation( "personal", "write", "the destination is not within the user's home", ) })?; let mut cur = self.base.clone(); for component in rel.components() { let Component::Normal(name) = component else { return Err(ExecError::operation( "personal", "write", "the destination contains an unsafe path component", )); }; cur = cur.join(name); match std::fs::symlink_metadata(&cur) { Ok(meta) if meta.file_type().is_symlink() => { return Err(ExecError::operation( "personal", "write", "refusing to follow a symlink while creating user storage", )); } Ok(meta) if meta.is_dir() => { if ownership.needs_fix() { // Repair (or confirm) ownership of an existing dir. let _ = fixer.fix(&cur, ownership.uid, ownership.gid); } } Ok(_) => { return Err(ExecError::operation( "personal", "write", "a path component of the user storage is not a directory", )); } Err(e) if e.kind() == std::io::ErrorKind::NotFound => { std::fs::create_dir(&cur).map_err(|e| ExecError::io(cur.clone(), e))?; #[cfg(unix)] { use std::os::unix::fs::PermissionsExt; std::fs::set_permissions(&cur, std::fs::Permissions::from_mode(0o700)) .map_err(|e| ExecError::io(cur.clone(), e))?; } if ownership.needs_fix() { fixer .fix(&cur, ownership.uid, ownership.gid) .map_err(|e| ExecError::io(cur.clone(), e))?; } } Err(e) => return Err(ExecError::io(cur.clone(), e)), } } Ok(()) } } fn tmp_token() -> String { use std::time::{SystemTime, UNIX_EPOCH}; let nanos = SystemTime::now() .duration_since(UNIX_EPOCH) .map(|d| d.as_nanos()) .unwrap_or(0); format!("{nanos}-{}", std::process::id()) } #[cfg(test)] mod tests { use super::*; use std::cell::RefCell; /// Records ownership changes instead of performing them (the test process is /// not root, so a real chown would fail). #[derive(Default)] struct RecordingFixer { calls: RefCell>, } impl OwnerFixer for RecordingFixer { fn fix(&self, path: &Path, uid: u32, gid: u32) -> std::io::Result<()> { self.calls.borrow_mut().push((path.to_path_buf(), uid, gid)); Ok(()) } } #[test] fn write_private_is_0600_inside_0700() { use std::os::unix::fs::PermissionsExt; let dir = tempfile::tempdir().unwrap(); let storage = UserStorage::with_base(effective_uid(), dir.path()); let cfg = storage.config_dir(); let file = storage.config_file("x.toml"); storage.write_private(&cfg, &file, b"a = 1").unwrap(); assert_eq!( std::fs::metadata(&file).unwrap().permissions().mode() & 0o777, 0o600 ); assert_eq!( std::fs::metadata(&cfg).unwrap().permissions().mode() & 0o777, 0o700 ); assert_eq!(std::fs::read(&file).unwrap(), b"a = 1"); } #[test] fn elevated_write_is_chowned_to_the_initiating_user() { let dir = tempfile::tempdir().unwrap(); // Simulate `sudo sys`: effective root writing on behalf of a non-root // initiating user. let owner_uid = effective_uid() + 1; let storage = UserStorage::with_base(owner_uid, dir.path()); let cfg = storage.config_dir(); let file = storage.config_file("prefs.toml"); let fixer = RecordingFixer::default(); storage .write_private_as( &cfg, &file, b"a = 1", Ownership { uid: owner_uid, gid: owner_uid, euid: 0, }, &fixer, ) .unwrap(); // The created config directory and the file were both handed to the // initiating user, and only under that user's home. let calls = fixer.calls.borrow(); assert!( calls.iter().any(|(p, _, _)| p == &file), "the file must be chowned: {calls:?}" ); assert!( calls.iter().any(|(p, _, _)| p == &cfg), "the config directory must be chowned: {calls:?}" ); assert!( calls.iter().all(|(p, uid, gid)| p.starts_with(dir.path()) && *uid == owner_uid && *gid == owner_uid), "only paths under the home may be chowned, to the initiating user: {calls:?}" ); // The file is readable afterwards. (A real cross-uid chown requires // root, so the recording fixer verifies intent rather than effect.) assert_eq!(std::fs::read(&file).unwrap(), b"a = 1"); } #[test] fn a_written_personal_file_is_replaceable_by_its_owner() { let dir = tempfile::tempdir().unwrap(); let storage = UserStorage::with_base(effective_uid(), dir.path()); let cfg = storage.config_dir(); let file = storage.config_file("x.toml"); storage.write_private(&cfg, &file, b"a = 1").unwrap(); assert_eq!(std::fs::read(&file).unwrap(), b"a = 1"); // The owner can replace it again (atomic overwrite). storage.write_private(&cfg, &file, b"a = 2").unwrap(); assert_eq!(std::fs::read(&file).unwrap(), b"a = 2"); } #[test] fn a_non_root_process_cannot_write_for_another_user() { let dir = tempfile::tempdir().unwrap(); let storage = UserStorage::with_base(effective_uid(), dir.path()); let cfg = storage.config_dir(); let file = storage.config_file("x.toml"); let err = storage .write_private_as( &cfg, &file, b"a = 1", Ownership { uid: effective_uid() + 1, gid: effective_uid() + 1, euid: effective_uid(), }, &RecordingFixer::default(), ) .unwrap_err(); assert!(err.to_string().contains("refusing to write"), "{err}"); assert!(!file.exists()); } #[test] fn a_symlinked_component_is_refused() { let dir = tempfile::tempdir().unwrap(); let storage = UserStorage::with_base(effective_uid(), dir.path()); // Plant a symlink where the config directory should be. let outside = tempfile::tempdir().unwrap(); std::os::unix::fs::symlink(outside.path(), dir.path().join(".config")).unwrap(); let cfg = storage.config_dir(); let file = storage.config_file("x.toml"); let err = storage.write_private(&cfg, &file, b"a = 1").unwrap_err(); assert!(err.to_string().contains("symlink"), "{err}"); assert!(!outside.path().join("phoebus/x.toml").exists()); } #[test] fn initiator_env_resolution_order() { let storage = UserStorage::for_uid(4242); assert_eq!(storage.uid(), 4242); } }