From c100cead20abfeb0111981afb8590167daec733b Mon Sep 17 00:00:00 2001 From: M3gA-Mind Date: Wed, 11 Nov 2026 16:56:29 +0530 Subject: [PATCH] Claim scope limits only for controllers the user manager was delegated A trusted systemd-run on disk was taken as proof that the 2.1 native resource jail enforces CPU, memory and pid limits. The limits are applied by the user's systemd manager, which must be reachable and must have been delegated each cgroup controller; without that a scope fails to start or runs without the limit. tinybox_linux::ScopeProbe reads the manager's socket and the controllers delegated to user@.service. The resource backend claims Cpu, Memory and Pids from it, and a requested limit whose controller is missing is refused before anything starts. --- crates/tinybox-linux/src/lib.rs | 2 +- crates/tinybox-linux/src/probe/mod.rs | 4 + crates/tinybox-linux/src/probe/scope.rs | 113 ++++++++++++++++++ crates/tinybox-linux/src/probe/scope_tests.rs | 51 ++++++++ .../src/tinybus_module/native_jail.rs | 27 ++++- .../src/tinybus_module/native_jail_tests.rs | 41 +++++++ docs/specs/constraint-preflight.md | 7 +- 7 files changed, 239 insertions(+), 6 deletions(-) create mode 100644 crates/tinybox-linux/src/probe/scope.rs create mode 100644 crates/tinybox-linux/src/probe/scope_tests.rs diff --git a/crates/tinybox-linux/src/lib.rs b/crates/tinybox-linux/src/lib.rs index 74ffe242..875083ec 100644 --- a/crates/tinybox-linux/src/lib.rs +++ b/crates/tinybox-linux/src/lib.rs @@ -44,7 +44,7 @@ mod probe; mod sandbox; -pub use probe::{NamespaceProbe, UsernsStatus}; +pub use probe::{NamespaceProbe, ScopeProbe, UsernsStatus}; pub use sandbox::{ NAME, NamespaceSandbox, NativeJailCommand, WORKSPACE_MOUNT, native_jail_argv, diff --git a/crates/tinybox-linux/src/probe/mod.rs b/crates/tinybox-linux/src/probe/mod.rs index 9cc403c8..746fe75b 100644 --- a/crates/tinybox-linux/src/probe/mod.rs +++ b/crates/tinybox-linux/src/probe/mod.rs @@ -10,6 +10,10 @@ use std::path::{Path, PathBuf}; +mod scope; + +pub use scope::ScopeProbe; + /// Whether an unprivileged process may create a user namespace. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum UsernsStatus { diff --git a/crates/tinybox-linux/src/probe/scope.rs b/crates/tinybox-linux/src/probe/scope.rs new file mode 100644 index 00000000..72f40999 --- /dev/null +++ b/crates/tinybox-linux/src/probe/scope.rs @@ -0,0 +1,113 @@ +//! Whether a rootless systemd scope can really hold CPU, memory and pid limits. +//! +//! A trusted `systemd-run` on disk is not enough. The limits are applied by the +//! user's own systemd manager, which must be running and reachable, and which +//! can only set a limit for a cgroup controller it was delegated. Without that +//! a scope either fails to start or starts with the limit silently missing. +//! [`ScopeProbe`] reads both before any limit is claimed. + +use tinybox_core::{Constraint, ConstraintSupport, Enforcement}; + +/// Which resource limits a rootless systemd scope can enforce here. +/// +/// Each field is true only when the user manager is reachable and was +/// delegated that controller. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] +pub struct ScopeProbe { + /// The `cpu` controller can be limited. + pub cpu: bool, + /// The `memory` controller can be limited. + pub memory: bool, + /// The `pids` controller can be limited. + pub pids: bool, +} + +impl ScopeProbe { + /// Probe this machine: the user manager's socket under `$XDG_RUNTIME_DIR` + /// (or the session bus socket), and the controllers listed in + /// `/sys/fs/cgroup/user.slice/user-.slice/user@.service/cgroup.controllers`. + #[must_use] + pub fn detect() -> Self { + let Some(uid) = current_uid() else { + return Self::default(); + }; + let controllers = std::fs::read_to_string(format!( + "/sys/fs/cgroup/user.slice/user-{uid}.slice/user@{uid}.service/cgroup.controllers" + )) + .ok(); + Self::from_parts(manager_socket_exists(), controllers.as_deref()) + } + + /// Build a probe from what was read: whether a manager socket exists, and + /// the space-separated contents of the user manager's `cgroup.controllers`. + #[must_use] + pub fn from_parts(manager: bool, controllers: Option<&str>) -> Self { + let has = |name: &str| { + manager + && controllers.is_some_and(|list| list.split_whitespace().any(|item| item == name)) + }; + Self { + cpu: has("cpu"), + memory: has("memory"), + pids: has("pids"), + } + } + + /// `Cpu`, `Memory` and `Pids`: each `Enforced` only when its controller is + /// delegated to a reachable manager, otherwise `Unsupported`. + #[must_use] + pub fn constraint_support(&self) -> ConstraintSupport { + let level = |delegated: bool| { + if delegated { + Enforcement::Enforced + } else { + Enforcement::Unsupported + } + }; + ConstraintSupport::NONE + .with(Constraint::Cpu, level(self.cpu)) + .with(Constraint::Memory, level(self.memory)) + .with(Constraint::Pids, level(self.pids)) + } +} + +/// The real uid, read from the owner of `/proc/self`. +#[cfg(unix)] +fn current_uid() -> Option { + use std::os::unix::fs::MetadataExt as _; + std::fs::metadata("/proc/self").ok().map(|meta| meta.uid()) +} + +#[cfg(not(unix))] +fn current_uid() -> Option { + None +} + +/// `$XDG_RUNTIME_DIR/systemd/private`, or the session bus's `unix:path=` +/// socket, which `systemd-run --user` can reach the manager through. +#[cfg(unix)] +fn manager_socket_exists() -> bool { + use std::os::unix::fs::FileTypeExt as _; + let is_socket = |path: std::path::PathBuf| { + path.is_absolute() && std::fs::metadata(path).is_ok_and(|meta| meta.file_type().is_socket()) + }; + let private = std::env::var_os("XDG_RUNTIME_DIR") + .map(|dir| std::path::PathBuf::from(dir).join("systemd/private")); + let bus = std::env::var("DBUS_SESSION_BUS_ADDRESS") + .ok() + .and_then(|address| { + address + .strip_prefix("unix:path=") + .map(std::path::PathBuf::from) + }); + private.into_iter().chain(bus).any(is_socket) +} + +#[cfg(not(unix))] +fn manager_socket_exists() -> bool { + false +} + +#[cfg(test)] +#[path = "scope_tests.rs"] +mod tests; diff --git a/crates/tinybox-linux/src/probe/scope_tests.rs b/crates/tinybox-linux/src/probe/scope_tests.rs new file mode 100644 index 00000000..1886dff0 --- /dev/null +++ b/crates/tinybox-linux/src/probe/scope_tests.rs @@ -0,0 +1,51 @@ +//! The scope probe claims a limit only for a delegated controller. + +use super::*; + +#[test] +fn each_limit_follows_its_own_delegated_controller() { + let probe = ScopeProbe::from_parts(true, Some("cpuset cpu io memory\n")); + let support = probe.constraint_support(); + + assert_eq!(support.enforcement(Constraint::Cpu), Enforcement::Enforced); + assert_eq!( + support.enforcement(Constraint::Memory), + Enforcement::Enforced + ); + assert_eq!( + support.enforcement(Constraint::Pids), + Enforcement::Unsupported + ); +} + +#[test] +fn nothing_is_claimed_without_a_reachable_manager() { + let probe = ScopeProbe::from_parts(false, Some("cpu memory pids")); + + assert_eq!(probe, ScopeProbe::default()); + for constraint in [Constraint::Cpu, Constraint::Memory, Constraint::Pids] { + assert_eq!( + probe.constraint_support().enforcement(constraint), + Enforcement::Unsupported + ); + } +} + +#[test] +fn nothing_is_claimed_without_a_delegated_cgroup() { + // cgroup v1, or no user manager cgroup at all. + let probe = ScopeProbe::from_parts(true, None); + + assert!(!probe.cpu && !probe.memory && !probe.pids); + assert_eq!( + probe.constraint_support().enforcement(Constraint::Memory), + Enforcement::Unsupported + ); +} + +#[test] +fn a_controller_name_must_match_exactly() { + // `cpuset` is not `cpu`. + let probe = ScopeProbe::from_parts(true, Some("cpuset")); + assert!(!probe.cpu); +} diff --git a/crates/tinybox-module/src/tinybus_module/native_jail.rs b/crates/tinybox-module/src/tinybus_module/native_jail.rs index f8171582..441f4191 100644 --- a/crates/tinybox-module/src/tinybus_module/native_jail.rs +++ b/crates/tinybox-module/src/tinybus_module/native_jail.rs @@ -263,13 +263,19 @@ fn unavailable() -> Error { struct NativeResourceBackend { expected: Mutex>>, requested: Mutex>, + scope: tinybox_linux::ScopeProbe, } impl NativeResourceBackend { fn new() -> Self { + Self::with_scope(tinybox_linux::ScopeProbe::detect()) + } + + fn with_scope(scope: tinybox_linux::ScopeProbe) -> Self { Self { expected: Mutex::new(None), requested: Mutex::new(None), + scope, } } @@ -318,14 +324,16 @@ impl JailBackend for NativeResourceBackend { fn constraint_support(&self) -> tinybox_core::ConstraintSupport { use tinybox_core::{Constraint, ConstraintSupport, Enforcement}; + let scope = self.scope.constraint_support(); ConstraintSupport::NONE .with(Constraint::Filesystem, Enforcement::Enforced) .with(Constraint::Network, Enforcement::Enforced) // `prepare_with_resources` refuses a request that denies them. .with(Constraint::Subprocess, Enforcement::Unsupported) - .with(Constraint::Cpu, Enforcement::Enforced) - .with(Constraint::Memory, Enforcement::Enforced) - .with(Constraint::Pids, Enforcement::Enforced) + // Only what the user manager was delegated a controller for. + .with(Constraint::Cpu, scope.enforcement(Constraint::Cpu)) + .with(Constraint::Memory, scope.enforcement(Constraint::Memory)) + .with(Constraint::Pids, scope.enforcement(Constraint::Pids)) .with(Constraint::Disk, Enforcement::Unsupported) } @@ -388,6 +396,19 @@ fn prepare_with_resources( { return Err(invalid()); } + // A limit the scope cannot apply is refused, never dropped. + let support = backend.constraint_support(); + if [ + (resources.cpu_millis, tinybox_core::Constraint::Cpu), + (resources.memory_bytes, tinybox_core::Constraint::Memory), + (resources.pids_max, tinybox_core::Constraint::Pids), + ] + .into_iter() + .any(|(limit, constraint)| { + limit.is_some() && support.enforcement(constraint) != tinybox_core::Enforcement::Enforced + }) { + return Err(unavailable()); + } backend.bind_resources(resources)?; let jail = prepare(root, &request.jail, command, backend)?; if request.jail.allow_net || !request.jail.allow_subprocess { diff --git a/crates/tinybox-module/src/tinybus_module/native_jail_tests.rs b/crates/tinybox-module/src/tinybus_module/native_jail_tests.rs index 2aaec697..124ab60b 100644 --- a/crates/tinybox-module/src/tinybus_module/native_jail_tests.rs +++ b/crates/tinybox-module/src/tinybus_module/native_jail_tests.rs @@ -207,6 +207,47 @@ fn requested_native_resource_limits_are_refused_before_spawn() Ok(()) } +#[test] +fn a_limit_whose_controller_is_not_delegated_is_refused_not_dropped() +-> std::result::Result<(), Box> { + // A user manager that was delegated cpu and memory, but not pids. + let scope = tinybox_linux::ScopeProbe::from_parts(true, Some("cpu memory")); + let backend = super::NativeResourceBackend::with_scope(scope); + let support = backend.constraint_support(); + assert_eq!( + support.enforcement(tinybox_core::Constraint::Cpu), + tinybox_core::Enforcement::Enforced + ); + assert_eq!( + support.enforcement(tinybox_core::Constraint::Pids), + tinybox_core::Enforcement::Unsupported + ); + + let root = tempfile::tempdir()?; + let mut command = tinybox_core::ExecRequest::new(["target-program"]); + command.cwd = Some(root.path().into()); + let original = command.clone(); + // Everything else about the request is acceptable, so only the missing + // controller can refuse it. + let mut jail = config(); + jail.allow_subprocess = true; + let request = NativeJailRequest { + jail, + resources: Some(tinybox_bus::NativeJailResourceRequest { + cpu_millis: Some(1000), + memory_bytes: None, + pids_max: Some(16), + disk_bytes: None, + }), + }; + let error = prepare_with_resources(root.path(), &request, &mut command, &backend) + .err() + .ok_or("a pids limit with no pids controller must be refused")?; + assert_eq!(error.wire_name(), tinybox_bus::UNSUPPORTED_OPERATION); + assert_eq!(command.argv, original.argv); + Ok(()) +} + #[cfg(not(target_os = "linux"))] #[test] fn contract_21_resource_requests_refuse_before_spawn_on_non_linux() diff --git a/docs/specs/constraint-preflight.md b/docs/specs/constraint-preflight.md index 8cf2608e..ae8a5cd8 100644 --- a/docs/specs/constraint-preflight.md +++ b/docs/specs/constraint-preflight.md @@ -10,13 +10,16 @@ coarse lifecycle capabilities do not imply resource enforcement. | --- | --- | --- | --- | --- | --- | --- | --- | | Docker | Enforced | Enforced | Enforced | Enforced | Enforced | Unsupported | Unsupported | | Namespaces | Enforced | Enforced | Enforced with cgroups | Enforced with cgroups | Enforced with cgroups | Unsupported | Unsupported | -| Native resource jail (contract 2.1) | Enforced | Enforced | Enforced | Enforced | Enforced | Unsupported | Unsupported | +| Native resource jail (contract 2.1) | Enforced | Enforced | Enforced when delegated | Enforced when delegated | Enforced when delegated | Unsupported | Unsupported | | MicroVM | Enforced | Enforced | BestEffort | BestEffort | Unsupported | Unsupported | Unsupported | | Landlock | Enforced when full filesystem ABI available | Unsupported | Unsupported | Unsupported | Unsupported | Unsupported | Unsupported | | Seatbelt | BestEffort when present | BestEffort when present | Unsupported | Unsupported | Unsupported | Unsupported | BestEffort when present | | Noop / unavailable platform | Unsupported | Unsupported | Unsupported | Unsupported | Unsupported | Unsupported | Unsupported | -The native resource jail allows subprocesses always, and claims kernel +The native resource jail claims CPU, memory or pids only when the user's +systemd manager is reachable and was delegated that cgroup controller +(`tinybox_linux::ScopeProbe`); a requested limit it cannot apply is refused. +It allows subprocesses always, and claims kernel isolation only when its `bwrap` supports `--disable-userns`. The MicroVM has no network interface, so it refuses any egress.