use core::fmt;
use serde::{Deserialize, Serialize};
use shep_core::config::AppConfig;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub struct Credentials {
pub uid: u32,
pub gid: Option<u32>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum SpawnIdentity {
Unresolved,
Resolved(Option<Credentials>),
}
#[cfg_attr(windows, allow(dead_code))]
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum PrivilegeError {
UnknownUser(String),
UnknownGroup(String),
Lookup(String),
NotPermitted {
user: Option<String>,
group: Option<String>,
},
}
impl fmt::Display for PrivilegeError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::UnknownUser(name) => write!(f, "unknown user {name:?}"),
Self::UnknownGroup(name) => write!(f, "unknown group {name:?}"),
Self::Lookup(msg) => write!(f, "passwd/group lookup failed: {msg}"),
Self::NotPermitted { user, group } => write!(
f,
"cannot run as user={user:?} group={group:?}: not running as root"
),
}
}
}
impl core::error::Error for PrivilegeError {}
#[cfg(unix)]
pub(crate) fn resolve(app: &AppConfig) -> Result<Option<Credentials>, PrivilegeError> {
if app.user.is_none() && app.group.is_none() {
return Ok(None);
}
let own_uid = nix::unistd::geteuid().as_raw();
let own_gid = nix::unistd::getegid().as_raw();
let uid = match &app.user {
Some(name) => resolve_user(name)?,
None => own_uid,
};
let gid = match &app.group {
Some(name) => Some(resolve_group(name)?),
None => None,
};
let changing_identity = uid != own_uid || gid.is_some_and(|g| g != own_gid);
if changing_identity && !nix::unistd::geteuid().is_root() {
return Err(PrivilegeError::NotPermitted {
user: app.user.clone(),
group: app.group.clone(),
});
}
Ok(Some(Credentials { uid, gid }))
}
#[cfg(not(unix))]
pub(crate) fn resolve(app: &AppConfig) -> Result<Option<Credentials>, PrivilegeError> {
match (&app.user, &app.group) {
(None, None) => Ok(None),
_ => Err(PrivilegeError::Lookup(
"uid/gid privilege drop is unix-only".to_string(),
)),
}
}
#[cfg(unix)]
fn resolve_user(name: &str) -> Result<u32, PrivilegeError> {
match nix::unistd::User::from_name(name) {
Ok(Some(user)) => Ok(user.uid.as_raw()),
Ok(None) => Err(PrivilegeError::UnknownUser(name.to_string())),
Err(errno) => Err(PrivilegeError::Lookup(errno.to_string())),
}
}
#[cfg(unix)]
fn resolve_group(name: &str) -> Result<u32, PrivilegeError> {
match nix::unistd::Group::from_name(name) {
Ok(Some(group)) => Ok(group.gid.as_raw()),
Ok(None) => Err(PrivilegeError::UnknownGroup(name.to_string())),
Err(errno) => Err(PrivilegeError::Lookup(errno.to_string())),
}
}
#[cfg(all(test, unix))]
mod tests {
use super::*;
fn own_user_name() -> String {
nix::unistd::User::from_uid(nix::unistd::geteuid())
.unwrap()
.expect("this process has a passwd entry")
.name
}
#[test]
fn no_user_or_group_means_no_credentials() {
assert_eq!(resolve(&AppConfig::minimal("web", "./srv")).unwrap(), None);
}
#[test]
fn a_real_user_name_resolves_to_its_uid() {
let mut app = AppConfig::minimal("web", "./srv");
app.user = Some(own_user_name());
let creds = resolve(&app).unwrap().expect("a user was requested");
assert_eq!(creds.uid, nix::unistd::geteuid().as_raw());
assert_eq!(creds.gid, None);
}
#[test]
fn an_unknown_user_is_a_typed_error_naming_the_user() {
let mut app = AppConfig::minimal("web", "./srv");
app.user = Some("definitely-not-a-real-shep-user".to_string());
assert_eq!(
resolve(&app).unwrap_err(),
PrivilegeError::UnknownUser("definitely-not-a-real-shep-user".to_string())
);
}
#[test]
fn asking_for_another_user_without_root_is_refused_in_plain_english() {
if nix::unistd::geteuid().is_root() {
return; }
let mut app = AppConfig::minimal("web", "./srv");
app.user = Some("root".to_string());
let err = resolve(&app).unwrap_err();
assert!(matches!(err, PrivilegeError::NotPermitted { .. }));
assert!(
err.to_string().contains("not running as root"),
"the message must say what to do: {err}"
);
}
}