use rustix::thread::{CapabilitiesSecureBits, CapabilitySet, CapabilitySets};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Credentials {
pub uids: [u32; 3],
pub caps: CapabilitySets,
}
impl Credentials {
fn any_uid_is_root(&self) -> bool {
self.uids.contains(&0)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ServiceUser {
pub name: String,
pub uid: u32,
pub gid: u32,
pub groups: Vec<u32>,
}
impl ServiceUser {
fn final_groups(&self) -> FinalGroups {
let mut groups = self.groups.clone();
if !groups.contains(&self.gid) {
groups.insert(0, self.gid);
}
FinalGroups {
gid: self.gid,
groups,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Goal {
KeepSysAdmin,
DropAll,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Request {
pub goal: Goal,
pub user: Option<ServiceUser>,
pub allow_root: bool,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Op {
ClearAmbient,
SetCaps(CapabilitySets),
DropBoundingExcept(CapabilitySet),
SetSecureBits(CapabilitiesSecureBits),
SetKeepCaps(bool),
SetGroups(Vec<u32>),
SetResGid(u32),
SetResUid(u32),
SetNoNewPrivs,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Warning {
RunningAsRoot,
UserNotApplied {
user: String,
effective_uid: u32,
},
}
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub enum PlanError {
#[error(
"CAP_SYS_ADMIN is not permitted; run under systemd with AmbientCapabilities=CAP_SYS_ADMIN, \
or apply 'setcap cap_sys_admin+ep' to the binary"
)]
MissingSysAdmin,
#[error(
"refusing to run as root: configure daemon.user (or pass --user) so privileges can be \
dropped, or pass --allow-root for development and testing"
)]
RootWithoutUser,
#[error("service user '{0}' has UID 0; choose an unprivileged user")]
ServiceUserIsRoot(String),
#[error("cannot switch to user '{user}': {missing} is not permitted")]
CannotSwitchUser {
user: String,
missing: &'static str,
},
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PrivilegePlan {
pub ops: Vec<Op>,
pub warnings: Vec<Warning>,
pub final_uid: u32,
pub final_caps: CapabilitySet,
pub final_groups: Option<FinalGroups>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FinalGroups {
pub gid: u32,
pub groups: Vec<u32>,
}
pub const LOCKED_SECURE_BITS: CapabilitiesSecureBits = CapabilitiesSecureBits::NO_ROOT
.union(CapabilitiesSecureBits::NO_ROOT_LOCKED)
.union(CapabilitiesSecureBits::NO_SETUID_FIXUP)
.union(CapabilitiesSecureBits::NO_SETUID_FIXUP_LOCKED)
.union(CapabilitiesSecureBits::KEEP_CAPS_LOCKED)
.union(CapabilitiesSecureBits::NO_CAP_AMBIENT_RAISE)
.union(CapabilitiesSecureBits::NO_CAP_AMBIENT_RAISE_LOCKED);
pub fn plan(current: &Credentials, request: &Request) -> Result<PrivilegePlan, PlanError> {
let keep = match request.goal {
Goal::KeepSysAdmin => CapabilitySet::SYS_ADMIN,
Goal::DropAll => CapabilitySet::empty(),
};
let permitted = current.caps.permitted;
if request.goal == Goal::KeepSysAdmin && !permitted.contains(CapabilitySet::SYS_ADMIN) {
return Err(PlanError::MissingSysAdmin);
}
let mut warnings = Vec::new();
let effective_uid = current.uids[1];
let switch_to = match (current.any_uid_is_root(), &request.user) {
(true, Some(user)) if user.uid == 0 => {
return Err(PlanError::ServiceUserIsRoot(user.name.clone()));
}
(true, Some(user)) => Some(user),
(true, None) => {
if request.goal == Goal::KeepSysAdmin {
if !request.allow_root {
return Err(PlanError::RootWithoutUser);
}
warnings.push(Warning::RunningAsRoot);
}
None
}
(false, Some(user)) => {
if effective_uid != user.uid {
warnings.push(Warning::UserNotApplied {
user: user.name.clone(),
effective_uid,
});
}
None
}
(false, None) => None,
};
if let Some(user) = switch_to {
for (cap, label) in [
(CapabilitySet::SETUID, "CAP_SETUID"),
(CapabilitySet::SETGID, "CAP_SETGID"),
] {
if !permitted.contains(cap) {
return Err(PlanError::CannotSwitchUser {
user: user.name.clone(),
missing: label,
});
}
}
}
let has_setpcap = permitted.contains(CapabilitySet::SETPCAP);
let mut ops = vec![Op::ClearAmbient];
let mut needed = CapabilitySet::empty();
if has_setpcap {
needed |= CapabilitySet::SETPCAP;
}
if switch_to.is_some() {
needed |= CapabilitySet::SETUID | CapabilitySet::SETGID;
}
if !current.caps.effective.contains(needed) {
ops.push(Op::SetCaps(CapabilitySets {
effective: current.caps.effective | needed,
permitted,
inheritable: CapabilitySet::empty(),
}));
}
if has_setpcap {
ops.push(Op::DropBoundingExcept(keep));
ops.push(Op::SetSecureBits(LOCKED_SECURE_BITS));
}
if let Some(user) = switch_to {
if !has_setpcap {
ops.push(Op::SetKeepCaps(true));
}
let groups = user.final_groups();
ops.push(Op::SetGroups(groups.groups));
ops.push(Op::SetResGid(groups.gid));
ops.push(Op::SetResUid(user.uid));
if !has_setpcap {
ops.push(Op::SetKeepCaps(false));
}
}
ops.push(Op::SetCaps(CapabilitySets {
effective: keep,
permitted: keep,
inheritable: CapabilitySet::empty(),
}));
ops.push(Op::SetNoNewPrivs);
Ok(PrivilegePlan {
ops,
warnings,
final_uid: switch_to.map_or(effective_uid, |u| u.uid),
final_caps: keep,
final_groups: switch_to.map(ServiceUser::final_groups),
})
}
#[cfg(test)]
mod tests {
use super::*;
fn caps(effective: CapabilitySet, permitted: CapabilitySet) -> CapabilitySets {
CapabilitySets {
effective,
permitted,
inheritable: CapabilitySet::empty(),
}
}
fn creds(uid: u32, sets: CapabilitySets) -> Credentials {
Credentials {
uids: [uid; 3],
caps: sets,
}
}
fn user() -> ServiceUser {
ServiceUser {
name: "byssus".into(),
uid: 991,
gid: 991,
groups: vec![],
}
}
fn request(goal: Goal, user: Option<ServiceUser>, allow_root: bool) -> Request {
Request {
goal,
user,
allow_root,
}
}
const SYS_ADMIN: CapabilitySet = CapabilitySet::SYS_ADMIN;
fn keep_final(set: CapabilitySet) -> Op {
Op::SetCaps(caps(set, set))
}
#[test]
fn systemd_launch_only_sys_admin() {
let current = creds(991, caps(SYS_ADMIN, SYS_ADMIN));
let p = plan(¤t, &request(Goal::KeepSysAdmin, None, false)).unwrap();
assert_eq!(
p.ops,
[Op::ClearAmbient, keep_final(SYS_ADMIN), Op::SetNoNewPrivs]
);
assert_eq!(p.final_uid, 991);
assert_eq!(p.final_caps, SYS_ADMIN);
assert!(p.warnings.is_empty());
}
#[test]
fn setcap_launch_with_extra_caps_drops_them() {
let extra = SYS_ADMIN | CapabilitySet::NET_ADMIN | CapabilitySet::DAC_OVERRIDE;
let current = creds(1000, caps(extra, extra));
let p = plan(¤t, &request(Goal::KeepSysAdmin, None, false)).unwrap();
assert_eq!(
p.ops,
[Op::ClearAmbient, keep_final(SYS_ADMIN), Op::SetNoNewPrivs]
);
}
#[test]
fn missing_sys_admin_is_an_error() {
let current = creds(991, caps(CapabilitySet::empty(), CapabilitySet::empty()));
assert_eq!(
plan(¤t, &request(Goal::KeepSysAdmin, None, false)),
Err(PlanError::MissingSysAdmin)
);
}
#[test]
fn root_without_user_refused() {
let current = creds(0, caps(CapabilitySet::all(), CapabilitySet::all()));
assert_eq!(
plan(¤t, &request(Goal::KeepSysAdmin, None, false)),
Err(PlanError::RootWithoutUser)
);
}
#[test]
fn partially_root_uids_count_as_root() {
let current = Credentials {
uids: [1000, 1000, 0],
caps: caps(CapabilitySet::all(), CapabilitySet::all()),
};
assert_eq!(
plan(¤t, &request(Goal::KeepSysAdmin, None, false)),
Err(PlanError::RootWithoutUser)
);
}
#[test]
fn root_with_allow_root_drops_caps_and_locks_bits() {
let all = CapabilitySet::all();
let current = creds(0, caps(all, all));
let p = plan(¤t, &request(Goal::KeepSysAdmin, None, true)).unwrap();
assert_eq!(
p.ops,
[
Op::ClearAmbient,
Op::DropBoundingExcept(SYS_ADMIN),
Op::SetSecureBits(LOCKED_SECURE_BITS),
keep_final(SYS_ADMIN),
Op::SetNoNewPrivs,
]
);
assert_eq!(p.final_uid, 0);
assert_eq!(p.final_groups, None);
assert_eq!(p.warnings, [Warning::RunningAsRoot]);
}
#[test]
fn root_switches_to_service_user() {
let all = CapabilitySet::all();
let current = creds(0, caps(all, all));
let mut u = user();
u.groups = vec![5, 7];
let p = plan(¤t, &request(Goal::KeepSysAdmin, Some(u), false)).unwrap();
assert_eq!(
p.ops,
[
Op::ClearAmbient,
Op::DropBoundingExcept(SYS_ADMIN),
Op::SetSecureBits(LOCKED_SECURE_BITS),
Op::SetGroups(vec![991, 5, 7]),
Op::SetResGid(991),
Op::SetResUid(991),
keep_final(SYS_ADMIN),
Op::SetNoNewPrivs,
]
);
assert_eq!(p.final_uid, 991);
assert_eq!(
p.final_groups,
Some(FinalGroups {
gid: 991,
groups: vec![991, 5, 7],
})
);
assert!(p.warnings.is_empty());
}
#[test]
fn primary_group_not_duplicated() {
let all = CapabilitySet::all();
let current = creds(0, caps(all, all));
let mut u = user();
u.groups = vec![3, 991];
let p = plan(¤t, &request(Goal::KeepSysAdmin, Some(u), false)).unwrap();
assert!(p.ops.contains(&Op::SetGroups(vec![3, 991])));
}
#[test]
fn switch_without_setpcap_uses_keepcaps() {
let permitted = SYS_ADMIN | CapabilitySet::SETUID | CapabilitySet::SETGID;
let current = creds(0, caps(SYS_ADMIN, permitted));
let p = plan(¤t, &request(Goal::KeepSysAdmin, Some(user()), false)).unwrap();
assert_eq!(
p.ops,
[
Op::ClearAmbient,
Op::SetCaps(caps(permitted, permitted)),
Op::SetKeepCaps(true),
Op::SetGroups(vec![991]),
Op::SetResGid(991),
Op::SetResUid(991),
Op::SetKeepCaps(false),
keep_final(SYS_ADMIN),
Op::SetNoNewPrivs,
]
);
}
#[test]
fn needed_caps_raised_to_effective_first() {
let all = CapabilitySet::all();
let current = creds(0, caps(SYS_ADMIN, all));
let p = plan(¤t, &request(Goal::KeepSysAdmin, Some(user()), false)).unwrap();
assert_eq!(
p.ops[1],
Op::SetCaps(caps(
SYS_ADMIN | CapabilitySet::SETPCAP | CapabilitySet::SETUID | CapabilitySet::SETGID,
all
))
);
}
#[test]
fn cannot_switch_without_setuid_or_setgid() {
let current = creds(0, caps(SYS_ADMIN, SYS_ADMIN | CapabilitySet::SETGID));
assert_eq!(
plan(¤t, &request(Goal::KeepSysAdmin, Some(user()), false)),
Err(PlanError::CannotSwitchUser {
user: "byssus".into(),
missing: "CAP_SETUID"
})
);
let current = creds(0, caps(SYS_ADMIN, SYS_ADMIN | CapabilitySet::SETUID));
assert!(matches!(
plan(¤t, &request(Goal::KeepSysAdmin, Some(user()), false)),
Err(PlanError::CannotSwitchUser {
missing: "CAP_SETGID",
..
})
));
}
#[test]
fn service_user_must_not_be_root() {
let all = CapabilitySet::all();
let current = creds(0, caps(all, all));
let mut u = user();
u.uid = 0;
assert_eq!(
plan(¤t, &request(Goal::KeepSysAdmin, Some(u), false)),
Err(PlanError::ServiceUserIsRoot("byssus".into()))
);
}
#[test]
fn user_ignored_when_not_root() {
let current = creds(1000, caps(SYS_ADMIN, SYS_ADMIN));
let p = plan(¤t, &request(Goal::KeepSysAdmin, Some(user()), false)).unwrap();
assert_eq!(
p.warnings,
[Warning::UserNotApplied {
user: "byssus".into(),
effective_uid: 1000
}]
);
assert_eq!(p.final_uid, 1000);
let current = creds(991, caps(SYS_ADMIN, SYS_ADMIN));
let p = plan(¤t, &request(Goal::KeepSysAdmin, Some(user()), false)).unwrap();
assert!(p.warnings.is_empty());
}
#[test]
fn drop_all_as_unprivileged_user() {
let current = creds(1000, caps(CapabilitySet::empty(), CapabilitySet::empty()));
let p = plan(¤t, &request(Goal::DropAll, None, false)).unwrap();
assert_eq!(
p.ops,
[
Op::ClearAmbient,
keep_final(CapabilitySet::empty()),
Op::SetNoNewPrivs
]
);
assert_eq!(p.final_caps, CapabilitySet::empty());
}
#[test]
fn drop_all_as_root_switches_user_or_stays_root_without_error() {
let all = CapabilitySet::all();
let current = creds(0, caps(all, all));
let p = plan(¤t, &request(Goal::DropAll, Some(user()), false)).unwrap();
assert_eq!(p.final_uid, 991);
assert!(
p.ops
.contains(&Op::DropBoundingExcept(CapabilitySet::empty()))
);
let p = plan(¤t, &request(Goal::DropAll, None, false)).unwrap();
assert_eq!(p.final_uid, 0);
assert!(p.warnings.is_empty());
assert_eq!(p.ops.last(), Some(&Op::SetNoNewPrivs));
}
#[test]
fn plans_always_end_minimal() {
let all = CapabilitySet::all();
for current in [
creds(0, caps(all, all)),
creds(991, caps(SYS_ADMIN, SYS_ADMIN)),
creds(0, caps(SYS_ADMIN, all)),
] {
for user in [None, Some(user())] {
let Ok(p) = plan(¤t, &request(Goal::KeepSysAdmin, user, true)) else {
continue;
};
assert_eq!(p.ops[0], Op::ClearAmbient);
assert_eq!(p.ops[p.ops.len() - 2], keep_final(SYS_ADMIN));
assert_eq!(p.ops[p.ops.len() - 1], Op::SetNoNewPrivs);
}
}
}
}