use anyhow::{Result, anyhow};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct DropTarget {
pub uid: libc::uid_t,
pub gid: libc::gid_t,
}
#[cfg(target_os = "macos")]
const NOBODY: DropTarget = DropTarget {
uid: 0xFFFF_FFFE,
gid: 0xFFFF_FFFE,
};
#[cfg(not(target_os = "macos"))]
const NOBODY: DropTarget = DropTarget {
uid: 65534,
gid: 65534,
};
pub fn resolve_drop_target() -> Option<DropTarget> {
if unsafe { libc::geteuid() } != 0 {
return None;
}
Some(target_from_env(
std::env::var("SUDO_UID").ok().as_deref(),
std::env::var("SUDO_GID").ok().as_deref(),
))
}
pub fn invoking_uid() -> Option<libc::uid_t> {
if unsafe { libc::geteuid() } != 0 {
return None;
}
parse_sudo_target(
std::env::var("SUDO_UID").ok().as_deref(),
std::env::var("SUDO_GID").ok().as_deref(),
)
.map(|target| target.uid)
}
fn parse_sudo_target(sudo_uid: Option<&str>, sudo_gid: Option<&str>) -> Option<DropTarget> {
let parse = |value: Option<&str>| {
value
.and_then(|text| text.parse::<u32>().ok())
.filter(|&id| id != 0)
};
Some(DropTarget {
uid: parse(sudo_uid)?,
gid: parse(sudo_gid)?,
})
}
fn target_from_env(sudo_uid: Option<&str>, sudo_gid: Option<&str>) -> DropTarget {
parse_sudo_target(sudo_uid, sudo_gid).unwrap_or(NOBODY)
}
pub fn chown_to_target(file: &std::fs::File, target: DropTarget) -> std::io::Result<()> {
use std::os::fd::AsRawFd;
let rc = unsafe { libc::fchown(file.as_raw_fd(), target.uid, target.gid) };
if rc == 0 {
Ok(())
} else {
Err(std::io::Error::last_os_error())
}
}
pub(crate) fn drop_to(target: DropTarget) -> Result<()> {
if target.uid == 0 || target.gid == 0 {
return Err(anyhow!("refusing to 'drop' to uid 0 / gid 0"));
}
let gids = [target.gid];
if unsafe { libc::setgroups(1, gids.as_ptr()) } != 0 {
return Err(anyhow!(
"setgroups failed: {}",
std::io::Error::last_os_error()
));
}
#[cfg(not(target_os = "macos"))]
{
if unsafe { libc::setresgid(target.gid, target.gid, target.gid) } != 0 {
return Err(anyhow!(
"setresgid({}) failed: {}",
target.gid,
std::io::Error::last_os_error()
));
}
if unsafe { libc::setresuid(target.uid, target.uid, target.uid) } != 0 {
return Err(anyhow!(
"setresuid({}) failed: {}",
target.uid,
std::io::Error::last_os_error()
));
}
let (mut ruid, mut euid, mut suid) = (0, 0, 0);
let (mut rgid, mut egid, mut sgid) = (0, 0, 0);
unsafe {
libc::getresuid(&mut ruid, &mut euid, &mut suid);
libc::getresgid(&mut rgid, &mut egid, &mut sgid);
}
if [ruid, euid, suid] != [target.uid; 3] || [rgid, egid, sgid] != [target.gid; 3] {
return Err(anyhow!(
"uid/gid drop verification failed (uids {ruid}/{euid}/{suid}, gids {rgid}/{egid}/{sgid})"
));
}
}
#[cfg(target_os = "macos")]
{
if unsafe { libc::setgid(target.gid) } != 0 {
return Err(anyhow!(
"setgid({}) failed: {}",
target.gid,
std::io::Error::last_os_error()
));
}
if unsafe { libc::setuid(target.uid) } != 0 {
return Err(anyhow!(
"setuid({}) failed: {}",
target.uid,
std::io::Error::last_os_error()
));
}
let (ruid, euid) = unsafe { (libc::getuid(), libc::geteuid()) };
let (rgid, egid) = unsafe { (libc::getgid(), libc::getegid()) };
if [ruid, euid] != [target.uid; 2] || [rgid, egid] != [target.gid; 2] {
return Err(anyhow!(
"uid/gid drop verification failed (uids {ruid}/{euid}, gids {rgid}/{egid})"
));
}
}
if unsafe { libc::setuid(0) } == 0 {
return Err(anyhow!("uid drop verification failed: setuid(0) succeeded"));
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_target_from_env_uses_sudo_ids() {
assert_eq!(
target_from_env(Some("501"), Some("20")),
DropTarget { uid: 501, gid: 20 }
);
}
#[test]
fn test_target_from_env_rejects_root_and_garbage() {
assert_eq!(target_from_env(Some("0"), Some("0")), NOBODY);
assert_eq!(target_from_env(Some("abc"), Some("1000")), NOBODY);
assert_eq!(target_from_env(Some("-1"), Some("1000")), NOBODY);
assert_eq!(target_from_env(Some("1000"), None), NOBODY);
assert_eq!(target_from_env(None, None), NOBODY);
}
#[test]
fn test_drop_to_rejects_root_target() {
assert!(drop_to(DropTarget { uid: 0, gid: 0 }).is_err());
}
#[test]
fn test_resolve_drop_target_none_when_not_root() {
if unsafe { libc::geteuid() } != 0 {
assert!(resolve_drop_target().is_none());
}
}
}