From fd6e4c74360194de3c96b1e03d82d55753676f12 Mon Sep 17 00:00:00 2001 From: Marko Vejnovic Date: Sat, 14 Nov 2026 10:27:32 +0000 Subject: [PATCH 1/8] fix(hyperrs-process): lower euid again when elevate fails to raise egid --- native/hyperrs-process/src/privilege.rs | 4 +- .../tests/privilege_setuid_model.rs | 244 ++++++++++++++++++ 2 files changed, 246 insertions(+), 2 deletions(-) create mode 100644 native/hyperrs-process/tests/privilege_setuid_model.rs diff --git a/native/hyperrs-process/src/privilege.rs b/native/hyperrs-process/src/privilege.rs index fcda2025..26296d91 100644 --- a/native/hyperrs-process/src/privilege.rs +++ b/native/hyperrs-process/src/privilege.rs @@ -141,11 +141,11 @@ impl Unprivileged { pub fn elevate(&mut self) -> Result, PrivilegeError> { seteuid(ROOT_UID).map_err(PrivilegeError::RaiseUser)?; - setegid(ROOT_GID).map_err(PrivilegeError::RaiseGroup)?; - + // Held before the egid raise so that, if it fails, dropping the guard lowers euid again. let root = Root { _token: PhantomData, }; + setegid(ROOT_GID).map_err(PrivilegeError::RaiseGroup)?; Ok(root) } diff --git a/native/hyperrs-process/tests/privilege_setuid_model.rs b/native/hyperrs-process/tests/privilege_setuid_model.rs new file mode 100644 index 00000000..fa4a918d --- /dev/null +++ b/native/hyperrs-process/tests/privilege_setuid_model.rs @@ -0,0 +1,244 @@ +//! The privilege API under the credentials a setuid-root exec really produces: real ids are the +//! caller's, effective and saved uid are 0, and the kernel marks the exec `AT_SECURE`. +//! +//! A root parent cannot fake that inside its own process, so each `*_as_root` test re-execs this +//! test binary into one ignored `child_*` scenario with `setresuid(caller, 0, 0)` and the +//! caller's gids. The child then sits exactly where a freshly exec'd setuid helper sits. +//! +//! Laws: +//! - the pre-main drop refuses a dynamically linked setuid exec before any Rust code runs; +//! - `take` refuses while euid or egid differs from the real ids, and a refused `take` does not +//! spend the one token; +//! - `elevate` raises euid and egid to 0 and nothing else; dropping the guard restores exactly the +//! caller's ids, keeps saved uid 0, and the cycle repeats; +//! - a child spawned with `spawn_as_root` is genuine root (all uids and gids 0, groups `[0]`) with +//! none of the caller's environment, while the spawning process keeps the caller's real ids; +//! - a failed `elevate` leaves the process unprivileged, never half-raised. + +use hyperrs_process::privilege::{ + drop_to_real, PrivilegeError, RootCommandExt, TakeError, Unprivileged, +}; +use nix::libc; +use nix::unistd::{ + getegid, geteuid, getgid, getgroups, getresuid, getuid, setegid, seteuid, setgroups, setresgid, + setresuid, Gid, Uid, +}; +use pretty_assertions::assert_eq; +use rstest::rstest; +use std::os::unix::process::CommandExt; +use std::process::{Command, Output}; + +const SCENARIO: &str = "HYPERRS_SETUID_MODEL_SCENARIO"; +const CALLER_UID: u32 = 65_534; +const CALLER_GID: u32 = 65_534; +const CALLER_GROUPS: [u32; 2] = [65_534, 4_242]; +const CAP_SETGID: libc::c_ulong = 6; + +fn in_scenario(name: &str) -> bool { + std::env::var(SCENARIO).as_deref() == Ok(name) +} + +fn exec_setuid_child(scenario: &str, drop_setgid_cap: bool) -> Output { + let mut cmd = Command::new(std::env::current_exe().unwrap()); + cmd.args([ + scenario, + "--exact", + "--ignored", + "--nocapture", + "--test-threads=1", + ]) + .env_clear() + .env(SCENARIO, scenario) + .env("CALLER_SECRET", "leaked") + .current_dir("/"); + // SAFETY: the hook runs in the forked child before exec and only makes id and prctl syscalls. + unsafe { + cmd.pre_exec(move || { + let groups: Vec = CALLER_GROUPS.iter().copied().map(Gid::from_raw).collect(); + setgroups(&groups)?; + let gid = Gid::from_raw(CALLER_GID); + setresgid(gid, gid, gid)?; + if drop_setgid_cap && libc::prctl(libc::PR_CAPBSET_DROP, CAP_SETGID, 0, 0, 0) != 0 { + return Err(std::io::Error::last_os_error()); + } + setresuid( + Uid::from_raw(CALLER_UID), + Uid::from_raw(0), + Uid::from_raw(0), + )?; + Ok(()) + }); + } + cmd.output().unwrap() +} + +fn describe(out: &Output) -> String { + format!( + "status {:?}\nstdout:\n{}\nstderr:\n{}", + out.status, + String::from_utf8_lossy(&out.stdout), + String::from_utf8_lossy(&out.stderr) + ) +} + +fn mirror_the_pre_main_drop() { + setegid(getgid()).unwrap(); + seteuid(getuid()).unwrap(); +} + +fn status_ids(status: &str, key: &str) -> Vec { + status + .lines() + .find_map(|line| line.strip_prefix(key)) + .unwrap_or_else(|| panic!("no {key} in {status}")) + .split_whitespace() + .map(|n| n.parse().unwrap()) + .collect() +} + +#[rstest] +#[case::the_pre_main_drop_refuses_a_dynamic_setuid_exec("child_drop_to_real", false, Some(1))] +#[case::elevate_and_drop_restore_the_caller_exactly("child_elevate_cycle", false, Some(0))] +#[case::a_spawned_root_child_is_genuine_root_with_no_caller_env( + "child_spawn_as_root", + false, + Some(0) +)] +#[case::a_failed_elevate_leaves_the_process_unprivileged("child_failed_elevate", true, Some(0))] +fn setuid_exec_model_as_root( + #[case] scenario: &str, + #[case] drop_setgid_cap: bool, + #[case] code: Option, +) { + if !geteuid().is_root() { + eprintln!("SKIP setuid model: needs root to exec a child with setuid credentials"); + return; + } + let out = exec_setuid_child(scenario, drop_setgid_cap); + assert_eq!(out.status.code(), code, "{}", describe(&out)); + if scenario == "child_drop_to_real" { + assert!( + String::from_utf8_lossy(&out.stderr) + .contains("refusing to run setuid as a dynamically linked binary"), + "{}", + describe(&out) + ); + } else { + assert!( + String::from_utf8_lossy(&out.stdout).contains("1 passed"), + "the scenario did not run: {}", + describe(&out) + ); + } +} + +#[test] +#[ignore = "re-exec'd with setuid credentials by setuid_exec_model_as_root"] +fn child_drop_to_real() { + if !in_scenario("child_drop_to_real") { + return; + } + drop_to_real(); + panic!("drop_to_real returned in a dynamically linked AT_SECURE exec"); +} + +#[test] +#[ignore = "re-exec'd with setuid credentials by setuid_exec_model_as_root"] +fn child_elevate_cycle() { + if !in_scenario("child_elevate_cycle") { + return; + } + let caller = (Uid::from_raw(CALLER_UID), Gid::from_raw(CALLER_GID)); + assert_eq!( + getresuid().unwrap().effective, + Uid::from_raw(0), + "simulation" + ); + assert!(matches!( + Unprivileged::take(), + Err(TakeError::StillPrivileged { euid, egid }) if euid.is_root() && egid == caller.1 + )); + + mirror_the_pre_main_drop(); + let groups = getgroups().unwrap(); + let mut token = Unprivileged::take().expect("a refused take must not spend the token"); + + for round in 0..3 { + let root = token.elevate().unwrap(); + assert_eq!( + (geteuid(), getegid()), + (Uid::from_raw(0), Gid::from_raw(0)), + "round {round}" + ); + assert_eq!((getuid(), getgid()), caller, "round {round}"); + assert_eq!(getgroups().unwrap(), groups, "round {round}"); + drop(root); + assert_eq!((geteuid(), getegid()), caller, "round {round}"); + assert_eq!((getuid(), getgid()), caller, "round {round}"); + assert_eq!( + getresuid().unwrap().saved, + Uid::from_raw(0), + "round {round}" + ); + assert_eq!(getgroups().unwrap(), groups, "round {round}"); + } +} + +#[test] +#[ignore = "re-exec'd with setuid credentials by setuid_exec_model_as_root"] +fn child_spawn_as_root() { + if !in_scenario("child_spawn_as_root") { + return; + } + mirror_the_pre_main_drop(); + let mut token = Unprivileged::take().unwrap(); + let root = token.elevate().unwrap(); + + let status = Command::new("/bin/cat") + .arg("/proc/self/status") + .spawn_as_root(&root, &[]) + .output() + .unwrap(); + let env = Command::new("/usr/bin/env") + .spawn_as_root(&root, &[]) + .output() + .unwrap(); + + assert_eq!( + (getuid(), getgid()), + (Uid::from_raw(CALLER_UID), Gid::from_raw(CALLER_GID)) + ); + drop(root); + let status = String::from_utf8(status.stdout).unwrap(); + assert_eq!(status_ids(&status, "Uid:"), [0, 0, 0, 0]); + assert_eq!(status_ids(&status, "Gid:"), [0, 0, 0, 0]); + assert_eq!(status_ids(&status, "Groups:"), [0]); + assert_eq!( + String::from_utf8_lossy(&env.stdout), + "", + "caller env reached root" + ); +} + +#[test] +#[ignore = "re-exec'd with setuid credentials by setuid_exec_model_as_root"] +fn child_failed_elevate() { + if !in_scenario("child_failed_elevate") { + return; + } + mirror_the_pre_main_drop(); + let mut token = Unprivileged::take().unwrap(); + + let raised = token.elevate(); + + assert!( + matches!(raised, Err(PrivilegeError::RaiseGroup(_))), + "without CAP_SETGID the egid raise must fail: {raised:?}" + ); + drop(raised); + assert_eq!( + (geteuid(), getegid()), + (Uid::from_raw(CALLER_UID), Gid::from_raw(CALLER_GID)), + "elevate failed but left the process with root ids" + ); +} From 8dc10fbe7ca7c6e83ad84e50096095ae9f25fdc9 Mon Sep 17 00:00:00 2001 From: Marko Vejnovic Date: Sat, 14 Nov 2026 10:29:16 +0000 Subject: [PATCH 2/8] fix(net): drop conntrack-invalid packets forwarded into the transit range The host forward chain dropped ct state invalid only for traffic from VM veths, so an invalid segment from the internet to 10.200.0.0/16 was forwarded. --- native/suidhelper/Cargo.toml | 4 + native/suidhelper/src/net/host.rs | 42 +- native/suidhelper/tests/e2e/net_hostile.rs | 550 +++++++++++++++++++++ 3 files changed, 574 insertions(+), 22 deletions(-) create mode 100644 native/suidhelper/tests/e2e/net_hostile.rs diff --git a/native/suidhelper/Cargo.toml b/native/suidhelper/Cargo.toml index eb9e1609..6a1faac4 100644 --- a/native/suidhelper/Cargo.toml +++ b/native/suidhelper/Cargo.toml @@ -59,6 +59,10 @@ path = "tests/e2e/vm_net_traffic.rs" name = "e2e_caller_gate" path = "tests/e2e/caller_gate.rs" +[[test]] +name = "e2e_net_hostile" +path = "tests/e2e/net_hostile.rs" + [[test]] name = "e2e_argv" path = "tests/e2e/argv.rs" diff --git a/native/suidhelper/src/net/host.rs b/native/suidhelper/src/net/host.rs index 448d7f25..b430e2d6 100644 --- a/native/suidhelper/src/net/host.rs +++ b/native/suidhelper/src/net/host.rs @@ -131,28 +131,26 @@ impl HostNet<'_> { }; Self::from_vms(daddr, Action::Drop) })) - .chain([ - Rule { - matches: vec![ - Match::Iifname(VM_VETHS.clone()), - Match::Ipv6Daddr(self.prefix.get()), - not_vm_range(), - Match::CtState(CtState::New), - ], - action: Action::Drop, - }, - Rule { - matches: vec![ - Match::Ipv4Daddr(NetId::transit_range()), - Match::CtState(CtState::New), - ], - action: Action::Drop, - }, - Rule { - matches: vec![Match::Oifname(VM_VETHS.clone()), not_vm_range()], - action: Action::Drop, - }, - ]) + .chain([Rule { + matches: vec![ + Match::Iifname(VM_VETHS.clone()), + Match::Ipv6Daddr(self.prefix.get()), + not_vm_range(), + Match::CtState(CtState::New), + ], + action: Action::Drop, + }]) + .chain([CtState::Invalid, CtState::New].map(|state| Rule { + matches: vec![ + Match::Ipv4Daddr(NetId::transit_range()), + Match::CtState(state), + ], + action: Action::Drop, + })) + .chain([Rule { + matches: vec![Match::Oifname(VM_VETHS.clone()), not_vm_range()], + action: Action::Drop, + }]) .collect(), } .chain() diff --git a/native/suidhelper/tests/e2e/net_hostile.rs b/native/suidhelper/tests/e2e/net_hostile.rs new file mode 100644 index 00000000..d52dbef9 --- /dev/null +++ b/native/suidhelper/tests/e2e/net_hostile.rs @@ -0,0 +1,550 @@ +//! The host firewall `host_init` installs, attacked from a compromised VM namespace. +//! +//! Four scratch namespaces stand in for the host, two VMs' namespaces (`vm-veth-0`, +//! `vm-veth-1`) and the internet beyond `if0`. Every address a probe uses is routed both +//! ways, so a refused probe is the firewall and not a missing route. Laws: +//! - a VM namespace opens nothing on the host: not through its veth's IPv4 or link-local +//! address, not through host addresses off the uplink, not over UDP; +//! - a VM namespace reaches no other VM's transit addresses, only its public IPv6; +//! - a packet from a VM leaves the host only from that VM's transit or VM-range source; +//! - a TCP or UDP packet whose first transport byte reads as a neighbour-discovery type is +//! not neighbour discovery: the host's ND allowance never admits it; +//! - isolation from the host and the transit range holds even with `[net] blocked = []`; +//! - nothing the internet sends, conntrack-invalid or not, is forwarded into the transit +//! range; +//! - `vm_firewall` acts only on a real namespace pinned at the VM's own name: a plain file +//! or a symlink there is refused, and no other namespace gains a table. +#![cfg(feature = "insecure_mode")] + +use assert_fs::TempDir; +use hyperrs_linux::net::link::DuplicateAddrDetection; +use hyperrs_linux::net::netns::NetNs; +use hyperrs_linux::net::route::Route; +use hyperrs_linux::net::{IfIndex, IfName, IpNet, Rtnl}; +use predicates::str::contains; +use pretty_assertions::assert_eq; +use rstest::rstest; +use serde_json::json; +use socket2::{Domain, Protocol, Socket, Type}; +use std::fs; +use std::io::Read; +use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV6, TcpListener, UdpSocket}; +use std::os::unix::fs::{symlink, PermissionsExt}; +use std::path::{Path, PathBuf}; +use std::process::Command; +use std::time::Duration; + +mod support; +use support::{is_root, ScratchNs}; + +const PORT: u16 = 7080; +const DROPPED_AFTER: Duration = Duration::from_secs(3); +const NEIGHBOR_SOLICIT_SPORT: u16 = 135 << 8; +const NEIGHBOR_ADVERT_SPORT: u16 = 136 << 8; + +#[derive(Debug, Clone, Copy)] +enum Side { + Vm0, + Wan, +} + +struct Lab { + _host: ScratchNs, + vm0: ScratchNs, + _vm1: ScratchNs, + wan: ScratchNs, + vm0_uplink: IfIndex, + _tcp: Vec, + udp: Vec<(&'static str, UdpSocket)>, +} + +impl Lab { + fn new(test: &str, net_extra: &str) -> Self { + let host = ScratchNs::new(&format!("{test}-h")); + let vm0 = ScratchNs::new(&format!("{test}-0")); + let vm1 = ScratchNs::new(&format!("{test}-1")); + let wan = ScratchNs::new(&format!("{test}-w")); + let h = host.get().rtnl().unwrap(); + let v0 = vm0.get().rtnl().unwrap(); + let v1 = vm1.get().rtnl().unwrap(); + let w = wan.get().rtnl().unwrap(); + + h.create_veth(&name("vm-veth-0"), &name("uplink"), vm0.get()) + .unwrap(); + h.create_veth(&name("vm-veth-1"), &name("uplink"), vm1.get()) + .unwrap(); + h.create_veth(&name("if0"), &name("wan"), wan.get()) + .unwrap(); + up(&h, "lo", &["198.51.100.7/32"]); + let veth0 = up(&h, "vm-veth-0", &["10.200.0.1/30", "fe80::1/64"]); + let veth1 = up(&h, "vm-veth-1", &["10.200.0.5/30", "fe80::1/64"]); + let if0 = up( + &h, + "if0", + &[ + "203.0.113.2/24", + "10.9.0.2/24", + "169.254.0.2/16", + "fe80::a/64", + "2001:db8::2/64", + ], + ); + up(&v0, "lo", &["192.0.2.50/32", "2001:db8:1::9/128"]); + let vm0_uplink = up( + &v0, + "uplink", + &["10.200.0.2/30", "fe80::2/64", "2001:db8::1:0:0:0/128"], + ); + up(&v1, "lo", &[]); + let vm1_uplink = up( + &v1, + "uplink", + &["10.200.0.6/30", "fe80::2/64", "2001:db8::1:0:0:1/128"], + ); + up(&w, "lo", &[]); + let wan_link = up( + &w, + "wan", + &[ + "203.0.113.1/24", + "10.9.0.1/24", + "169.254.169.254/16", + "fe80::b/64", + "2001:db8:ffff::1/128", + ], + ); + for (rtnl, route) in [ + (&v0, route("0.0.0.0/0", "10.200.0.1", vm0_uplink)), + (&v0, route("::/0", "fe80::1", vm0_uplink)), + (&v1, route("0.0.0.0/0", "10.200.0.5", vm1_uplink)), + (&v1, route("::/0", "fe80::1", vm1_uplink)), + (&h, route("2001:db8::1:0:0:0/128", "fe80::2", veth0)), + (&h, route("2001:db8::1:0:0:1/128", "fe80::2", veth1)), + (&h, route("2001:db8:1::/64", "fe80::2", veth0)), + (&h, route("192.0.2.50/32", "10.200.0.2", veth0)), + (&h, route("::/0", "fe80::b", if0)), + (&w, route("10.200.0.0/16", "203.0.113.2", wan_link)), + (&w, route("192.0.2.50/32", "203.0.113.2", wan_link)), + (&w, route("2001:db8:0:0:1::/80", "fe80::a", wan_link)), + (&w, route("2001:db8:1::/64", "fe80::a", wan_link)), + ] { + rtnl.add_route(&route).unwrap(); + } + + let tmp = TempDir::new().unwrap(); + let cfg = tmp.path().join("config.toml"); + fs::write( + &cfg, + format!( + "work_dir = \"/srv/hyper\"\n[net]\nuplink = \"if0\"\n\ + ipv6_prefix = \"2001:db8::/64\"\n{net_extra}" + ), + ) + .unwrap(); + fs::set_permissions(&cfg, fs::Permissions::from_mode(0o644)).unwrap(); + host.get().enable_forwarding().unwrap(); + host.run(&cfg, json!({"op": "host_init"})).success(); + + let tcp = [&host, &vm0, &vm1, &wan] + .into_iter() + .map(|ns| { + ns.get() + .scoped(|| TcpListener::bind((Ipv6Addr::UNSPECIFIED, PORT))) + .unwrap() + .unwrap() + }) + .collect(); + let udp = [("host", &host), ("wan", &wan)] + .into_iter() + .map(|(side, ns)| { + let socket = ns + .get() + .scoped(|| UdpSocket::bind((Ipv6Addr::UNSPECIFIED, PORT))) + .unwrap() + .unwrap(); + socket.set_read_timeout(Some(DROPPED_AFTER)).unwrap(); + (side, socket) + }) + .collect(); + Self { + _host: host, + vm0, + _vm1: vm1, + wan, + vm0_uplink, + _tcp: tcp, + udp, + } + } + + fn ns(&self, side: Side) -> &NetNs { + match side { + Side::Vm0 => self.vm0.get(), + Side::Wan => self.wan.get(), + } + } + + /// Link-local destinations are scoped to vm0's `uplink`, the only link a VM has. + fn target(&self, to: &str) -> SocketAddr { + match to.parse().unwrap() { + IpAddr::V6(addr) if addr.is_unicast_link_local() => { + SocketAddrV6::new(addr, PORT, 0, self.vm0_uplink.get()).into() + } + addr => SocketAddr::new(addr, PORT), + } + } + + fn socket(&self, ty: Type, src: Option<&str>, sport: u16, to: SocketAddr) -> Socket { + let socket = Socket::new(Domain::for_address(to), ty, None).unwrap(); + socket.set_reuse_address(true).unwrap(); + let src = src.map_or_else( + || match to { + SocketAddr::V4(_) => IpAddr::from([0, 0, 0, 0]), + SocketAddr::V6(_) => Ipv6Addr::UNSPECIFIED.into(), + }, + |src| src.parse().unwrap(), + ); + socket.bind(&SocketAddr::new(src, sport).into()).unwrap(); + socket + } + + fn connects(&self, from: Side, src: Option<&str>, sport: u16, to: &str) -> bool { + let to = self.target(to); + self.ns(from) + .scoped(|| { + self.socket(Type::STREAM, src, sport, to) + .connect_timeout(&to.into(), DROPPED_AFTER) + .is_ok() + }) + .unwrap() + } + + /// Whether a datagram vm0 sends to `to` arrives at the listener on `side`. + fn datagram_arrives(&self, sport: u16, to: &str, side: &str) -> bool { + let to = self.target(to); + self.vm0 + .get() + .scoped(|| { + self.socket(Type::DGRAM, None, sport, to) + .send_to(b"probe", &to.into()) + .unwrap(); + }) + .unwrap(); + let (_, listener) = self.udp.iter().find(|(s, _)| *s == side).unwrap(); + let mut buf = [0u8; 16]; + listener.recv(&mut buf).is_ok_and(|n| &buf[..n] == b"probe") + } + + /// The sources of SYN+FIN segments (conntrack-invalid) to `dst` that the wan sends + /// and vm0's namespace receives. + fn invalid_segment_from_wan_reaches_vm0(&self, dst: Ipv4Addr) -> Vec { + let capture = self + .vm0 + .get() + .scoped(|| Socket::new(Domain::IPV4, Type::RAW, Some(Protocol::TCP))) + .unwrap() + .unwrap(); + capture.set_read_timeout(Some(DROPPED_AFTER)).unwrap(); + let src = Ipv4Addr::new(203, 0, 113, 1); + let segment = syn_fin(src, dst); + self.wan + .get() + .scoped(|| { + let send = Socket::new(Domain::IPV4, Type::RAW, Some(Protocol::TCP)).unwrap(); + send.send_to(&segment, &SocketAddr::new(dst.into(), 0).into()) + .unwrap(); + }) + .unwrap(); + + let mut seen = Vec::new(); + let mut packet = [0u8; 1500]; + while let Ok(n) = (&capture).read(&mut packet) { + let ihl = usize::from(packet[0] & 0x0f) * 4; + if n >= ihl + 4 && u16::from_be_bytes([packet[ihl + 2], packet[ihl + 3]]) == PORT { + seen.push(Ipv4Addr::new( + packet[12], packet[13], packet[14], packet[15], + )); + } + } + seen + } +} + +/// A checksummed TCP header with SYN and FIN both set, which conntrack calls invalid. +fn syn_fin(src: Ipv4Addr, dst: Ipv4Addr) -> [u8; 20] { + let mut segment = [0u8; 20]; + segment[0..2].copy_from_slice(&40_000u16.to_be_bytes()); + segment[2..4].copy_from_slice(&PORT.to_be_bytes()); + segment[4..8].copy_from_slice(&1u32.to_be_bytes()); + segment[12] = 5 << 4; + segment[13] = 0x03; + segment[14..16].copy_from_slice(&64_240u16.to_be_bytes()); + let sum = [ + &src.octets()[..], + &dst.octets()[..], + &[0, 6, 0, 20], + &segment[..], + ] + .concat() + .chunks(2) + .map(|w| u32::from(u16::from_be_bytes([w[0], w[1]]))) + .sum::(); + let folded = !(((sum & 0xffff) + (sum >> 16)) as u16); + segment[16..18].copy_from_slice(&folded.to_be_bytes()); + segment +} + +fn name(s: &str) -> IfName { + s.parse().unwrap() +} + +fn up(rtnl: &Rtnl, link: &str, addrs: &[&str]) -> IfIndex { + let link = rtnl.link(&name(link)).unwrap().unwrap(); + for addr in addrs { + link.add_addr(addr.parse().unwrap(), DuplicateAddrDetection::Disabled) + .unwrap(); + } + link.set_up().unwrap(); + link.index() +} + +fn route(dst: &str, via: &str, dev: IfIndex) -> Route { + match dst.parse::().unwrap() { + IpNet::V4(dst) => Route::V4 { + dst, + via: Some(via.parse().unwrap()), + dev, + }, + IpNet::V6(dst) => Route::V6 { + dst, + via: Some(via.parse().unwrap()), + dev, + }, + } +} + +fn lab_name(parts: &str) -> String { + let mut name: String = parts + .to_lowercase() + .chars() + .map(|c| if c.is_ascii_alphanumeric() { c } else { '-' }) + .collect(); + name.truncate(48); + name +} + +#[rstest] +#[case::to_the_internet(Side::Vm0, None, 0, "203.0.113.1", true)] +#[case::to_another_vms_public_ipv6(Side::Vm0, None, 0, "2001:db8::1:0:0:1", true)] +#[case::to_another_vms_host_veth(Side::Vm0, None, 0, "10.200.0.5", false)] +#[case::to_another_vms_uplink(Side::Vm0, None, 0, "10.200.0.6", false)] +#[case::to_a_host_address_off_the_uplink(Side::Vm0, None, 0, "198.51.100.7", false)] +#[case::to_the_hosts_own_node_prefix_address(Side::Vm0, None, 0, "2001:db8::2", false)] +#[case::to_the_host_veth_link_local(Side::Vm0, None, 0, "fe80::1", false)] +#[case::spoofed_ipv4_source(Side::Vm0, Some("192.0.2.50"), 0, "203.0.113.1", false)] +#[case::spoofed_ipv6_source(Side::Vm0, Some("2001:db8:1::9"), 0, "2001:db8:ffff::1", false)] +#[case::nd_lookalike_port_to_the_internet( + Side::Vm0, + None, + NEIGHBOR_SOLICIT_SPORT, + "203.0.113.1", + true +)] +#[case::solicit_lookalike_port_to_the_host_veth( + Side::Vm0, + None, + NEIGHBOR_SOLICIT_SPORT, + "10.200.0.1", + false +)] +#[case::advert_lookalike_port_to_the_host_veth( + Side::Vm0, + None, + NEIGHBOR_ADVERT_SPORT, + "10.200.0.1", + false +)] +#[case::solicit_lookalike_port_to_the_host_over_ipv6( + Side::Vm0, + None, + NEIGHBOR_SOLICIT_SPORT, + "2001:db8::2", + false +)] +#[case::advert_lookalike_port_to_the_host_link_local( + Side::Vm0, + None, + NEIGHBOR_ADVERT_SPORT, + "fe80::1", + false +)] +#[case::internet_to_another_vms_uplink(Side::Wan, None, 0, "10.200.0.6", false)] +fn a_hostile_vm_namespace_is_confined_as_root( + #[case] from: Side, + #[case] src: Option<&str>, + #[case] sport: u16, + #[case] to: &str, + #[case] reachable: bool, +) { + if !is_root() { + eprintln!("SKIP hostile VM namespace: needs root"); + return; + } + let lab = Lab::new(&lab_name(&format!("nh-{from:?}-{sport}-{to}")), ""); + + assert_eq!(lab.connects(from, src, sport, to), reachable); +} + +#[rstest] +#[case::to_the_internet(0, "203.0.113.1", "wan", true)] +#[case::to_the_host_veth(0, "10.200.0.1", "host", false)] +#[case::to_a_host_address_off_the_uplink(0, "198.51.100.7", "host", false)] +#[case::to_the_host_veth_link_local(0, "fe80::1", "host", false)] +#[case::solicit_lookalike_port_to_the_host_veth( + NEIGHBOR_SOLICIT_SPORT, + "10.200.0.1", + "host", + false +)] +#[case::advert_lookalike_port_to_the_host_over_ipv6( + NEIGHBOR_ADVERT_SPORT, + "2001:db8::2", + "host", + false +)] +fn udp_from_a_vm_namespace_reaches_only_the_internet_as_root( + #[case] sport: u16, + #[case] to: &str, + #[case] side: &str, + #[case] delivered: bool, +) { + if !is_root() { + eprintln!("SKIP hostile VM namespace: needs root"); + return; + } + let lab = Lab::new(&lab_name(&format!("nu-{sport}-{to}")), ""); + + assert_eq!(lab.datagram_arrives(sport, to, side), delivered); +} + +#[rstest] +#[case::a_private_network_once_unblocked("10.9.0.1", true)] +#[case::its_host_veth("10.200.0.1", false)] +#[case::another_vms_uplink("10.200.0.6", false)] +#[case::the_host_uplink("203.0.113.2", false)] +#[case::the_hosts_own_node_prefix_address("2001:db8::2", false)] +fn with_nothing_blocked_a_vm_namespace_still_never_reaches_the_host_or_other_vms_as_root( + #[case] to: &str, + #[case] reachable: bool, +) { + if !is_root() { + eprintln!("SKIP hostile VM namespace: needs root"); + return; + } + let lab = Lab::new(&lab_name(&format!("nb-{to}")), "blocked = []\n"); + + assert_eq!(lab.connects(Side::Vm0, None, 0, to), reachable); +} + +#[rstest] +fn an_operator_blocked_ipv6_range_is_unreachable_from_a_vm_as_root() { + if !is_root() { + eprintln!("SKIP hostile VM namespace: needs root"); + return; + } + let lab = Lab::new("nb6", "blocked = [\"2001:db8:ffff::/48\"]\n"); + + assert_eq!( + ( + lab.connects(Side::Vm0, None, 0, "2001:db8:ffff::1"), + lab.connects(Side::Vm0, None, 0, "203.0.113.1"), + ), + (false, true) + ); +} + +#[rstest] +fn an_invalid_segment_from_the_internet_never_reaches_the_transit_range_as_root() { + if !is_root() { + eprintln!("SKIP hostile VM namespace: needs root"); + return; + } + let lab = Lab::new("ninv", ""); + + assert_eq!( + lab.invalid_segment_from_wan_reaches_vm0(Ipv4Addr::new(10, 200, 0, 2)), + Vec::::new() + ); +} + +fn firewall_table_in(ns: &NetNs) -> bool { + ns.scoped(|| { + Command::new("nft") + .args(["list", "table", "inet", "hyper-firewall"]) + .output() + .unwrap() + .status + .success() + }) + .unwrap() +} + +/// A file planted where `vm_firewall` looks for VM `id`'s namespace, removed on drop. +struct Pin(PathBuf); + +impl Drop for Pin { + fn drop(&mut self) { + let _ = fs::remove_file(&self.0); + } +} + +#[rstest] +#[case::the_vms_own_namespace("namespace", true)] +#[case::plain_file("file", false)] +#[case::symlink_to_another_namespace("symlink", false)] +fn vm_firewall_acts_only_on_the_vms_own_namespace_as_root( + #[case] kind: &str, + #[case] applied: bool, +) { + if !is_root() { + eprintln!("SKIP vm_firewall pin: needs root"); + return; + } + let caller = ScratchNs::new(&format!("npin-{kind}-c")); + let target = ScratchNs::new(&format!("npin-{kind}-t")); + let id = match kind { + "namespace" => { + target.get().name().as_os_str().to_str().unwrap()["hyper-".len()..].to_owned() + } + _ => format!("npin{kind}{}", std::process::id()), + }; + let _pin = (kind != "namespace").then(|| { + let pin = Pin(Path::new("/run/netns").join(format!("hyper-{id}"))); + match kind { + "file" => fs::write(&pin.0, "").unwrap(), + _ => symlink(target.get().path().as_path(), &pin.0).unwrap(), + } + pin + }); + let tmp = TempDir::new().unwrap(); + let cfg = tmp.path().join("config.toml"); + fs::write(&cfg, "work_dir = \"/srv/hyper\"\n").unwrap(); + fs::set_permissions(&cfg, fs::Permissions::from_mode(0o644)).unwrap(); + + let out = caller.run( + &cfg, + json!({"op": "vm_firewall", "id": id, "firewall": { + "inbound": [{"protocol": "tcp", "ports": [1, 65535]}], "outbound_blocked": []}}), + ); + if !applied { + out.code(2).stderr(contains("network namespace")); + } + + assert_eq!( + ( + firewall_table_in(caller.get()), + firewall_table_in(target.get()) + ), + (false, applied) + ); +} From af1489aed204a1e3292d9e817de312217bbb8b46 Mon Sep 17 00:00:00 2001 From: Marko Vejnovic Date: Sat, 14 Nov 2026 10:34:36 +0000 Subject: [PATCH 3/8] fix(hyperrs-linux): run dmsetup and thin_dump as genuine root Dmsetup and ThinDump now take the Root guard and spawn through spawn_as_root, so the tool runs with real, effective and saved ids 0, groups [0] and no caller fds beyond its own binary and thin_dump's metadata device. Previously only the environment was cleared: the caller's real uid/gid, supplementary groups and open fds reached the root tool. --- native/hyperrs-linux/src/dm/device.rs | 27 +- native/hyperrs-linux/src/dm/mod.rs | 29 +- native/hyperrs-linux/src/dm/thin.rs | 64 ++- native/hyperrs-linux/src/dm/thin_dump.rs | 12 +- native/suidhelper/Cargo.toml | 4 + native/suidhelper/src/cli/dm.rs | 11 +- native/suidhelper/src/cli/fork_delta.rs | 23 +- native/suidhelper/src/cli/img.rs | 4 +- native/suidhelper/src/cli/thin.rs | 14 +- native/suidhelper/tests/e2e/setuid.rs | 629 +++++++++++++++++++++++ 10 files changed, 743 insertions(+), 74 deletions(-) create mode 100644 native/suidhelper/tests/e2e/setuid.rs diff --git a/native/hyperrs-linux/src/dm/device.rs b/native/hyperrs-linux/src/dm/device.rs index 34833200..100ab215 100644 --- a/native/hyperrs-linux/src/dm/device.rs +++ b/native/hyperrs-linux/src/dm/device.rs @@ -1,6 +1,7 @@ use super::{DmName, Dmsetup, RemoveMode, RunError}; use hyperrs_fs::dev::{DeviceNumber, ParseDeviceNumberError}; use hyperrs_fs::path::{IsAbsolute, SafePathBuf, StrictComponents}; +use hyperrs_process::privilege::Root; use std::ffi::OsStr; use thiserror::Error as ThisError; @@ -15,6 +16,7 @@ pub enum NumberError { #[derive(Debug, Clone)] pub struct Device<'a> { pub(super) dmsetup: &'a Dmsetup, + pub(super) root: &'a Root<'a>, pub(super) name: DmName, } @@ -28,26 +30,29 @@ impl<'a> Device<'a> { } pub fn number(&self) -> Result { - let out = self.dmsetup.run([ - OsStr::new("info"), - OsStr::new("-c"), - OsStr::new("--noheadings"), - OsStr::new("-o"), - OsStr::new("major,minor"), - self.name.as_ref(), - ])?; + let out = self.dmsetup.run( + self.root, + [ + OsStr::new("info"), + OsStr::new("-c"), + OsStr::new("--noheadings"), + OsStr::new("-o"), + OsStr::new("major,minor"), + self.name.as_ref(), + ], + )?; Ok(out.trim().parse()?) } pub fn suspend(&self) -> Result<(), RunError> { self.dmsetup - .run([OsStr::new("suspend"), self.name.as_ref()]) + .run(self.root, [OsStr::new("suspend"), self.name.as_ref()]) .map(drop) } pub fn resume(&self) -> Result<(), RunError> { self.dmsetup - .run([OsStr::new("resume"), self.name.as_ref()]) + .run(self.root, [OsStr::new("resume"), self.name.as_ref()]) .map(drop) } @@ -57,6 +62,6 @@ impl<'a> Device<'a> { args.push(OsStr::new("--retry")); } args.push(self.name.as_ref()); - self.dmsetup.run(args).map(drop) + self.dmsetup.run(self.root, args).map(drop) } } diff --git a/native/hyperrs-linux/src/dm/mod.rs b/native/hyperrs-linux/src/dm/mod.rs index 1dd67351..c88d156a 100644 --- a/native/hyperrs-linux/src/dm/mod.rs +++ b/native/hyperrs-linux/src/dm/mod.rs @@ -12,9 +12,11 @@ use derive_more::Constructor; pub use dev_path::{DevPath, DevPathError}; pub use device::{Device, NumberError}; use hyperrs_process::binary::RootSafeBin; +use hyperrs_process::privilege::{Root, RootCommandExt}; pub use name::{DmName, InvalidDmName, OpenDeviceError, ParseDmDeviceError, SizeError}; use std::ffi::OsStr; use std::io; +use std::os::unix::io::AsFd; pub use table::{ DmTable, LinearTable, Origin, ParseTableError, Persistence, Role, SnapshotTable, ThinPoolTable, ThinTable, @@ -46,34 +48,40 @@ pub struct Dmsetup { } impl Dmsetup { - pub fn create( - &self, + pub fn create<'a>( + &'a self, + root: &'a Root<'a>, name: &DmName, table: &DmTable, access: Access, - ) -> Result, RunError> { + ) -> Result, RunError> { let table = table.to_string(); let mut args = vec![OsStr::new("create"), name.as_ref()]; if access == Access::ReadOnly { args.push(OsStr::new("--readonly")); } args.extend([OsStr::new("--table"), OsStr::new(&table)]); - self.run(args)?; - Ok(self.device(name)) + self.run(root, args)?; + Ok(self.device(root, name)) } - pub fn device(&self, name: &DmName) -> Device<'_> { + pub fn device<'a>(&'a self, root: &'a Root<'a>, name: &DmName) -> Device<'a> { Device { dmsetup: self, + root, name: name.clone(), } } - pub fn thin_pool(&self, name: &DmName) -> Result, ThinPoolError> { - ThinPool::open(self, name) + pub fn thin_pool<'a>( + &'a self, + root: &'a Root<'a>, + name: &DmName, + ) -> Result, ThinPoolError> { + ThinPool::open(self, root, name) } - fn run(&self, args: I) -> Result + fn run(&self, root: &Root<'_>, args: I) -> Result where I: IntoIterator, S: AsRef, @@ -82,7 +90,8 @@ impl Dmsetup { .bin .command() .args(args) - .env_clear() + // The binary fd stays open so an interpreted tool can reopen itself via /proc/self/fd. + .spawn_as_root(root, &[self.bin.as_fd()]) .output() .map_err(RunError::Spawn)?; if !out.status.success() { diff --git a/native/hyperrs-linux/src/dm/thin.rs b/native/hyperrs-linux/src/dm/thin.rs index c41a472b..148b6c7a 100644 --- a/native/hyperrs-linux/src/dm/thin.rs +++ b/native/hyperrs-linux/src/dm/thin.rs @@ -4,6 +4,7 @@ use super::{ use crate::Access; use derive_more::{Display, Into}; use hyperrs_fs::dev::DeviceNumber; +use hyperrs_process::privilege::Root; use std::ffi::OsStr; use std::num::ParseIntError; use std::str::FromStr; @@ -149,11 +150,15 @@ pub struct Thin<'a, S> { } impl<'a> ThinPool<'a> { - pub(super) fn open(dmsetup: &'a Dmsetup, name: &DmName) -> Result { - let table = dmsetup.run([OsStr::new("table"), name.as_ref()])?; + pub(super) fn open( + dmsetup: &'a Dmsetup, + root: &'a Root<'a>, + name: &DmName, + ) -> Result { + let table = dmsetup.run(root, [OsStr::new("table"), name.as_ref()])?; match Self::pool_metadata(&table) { Some(metadata) => Ok(Self { - device: dmsetup.device(name), + device: dmsetup.device(root, name), metadata, }), None => Err(ThinPoolError::NotAThinPool { @@ -191,8 +196,8 @@ impl<'a> ThinPool<'a> { } pub fn open_thin(&self, name: &DmName) -> Result>, OpenThinError> { - let dmsetup = self.device.dmsetup; - let table = dmsetup.run([OsStr::new("table"), name.as_ref()])?; + let Device { dmsetup, root, .. } = self.device; + let table = dmsetup.run(root, [OsStr::new("table"), name.as_ref()])?; let pool = self.device.number()?; let not_a_thin = || OpenThinError::NotAThin { name: name.clone(), @@ -206,7 +211,7 @@ impl<'a> ThinPool<'a> { Ok(Thin { pool: self.clone(), id: id.parse()?, - state: Active(dmsetup.device(name)), + state: Active(dmsetup.device(root, name)), }) } _ => Err(not_a_thin()), @@ -233,12 +238,15 @@ impl<'a> ThinPool<'a> { let message = message.to_string(); self.device .dmsetup - .run([ - OsStr::new("message"), - self.device.name().as_ref(), - OsStr::new("0"), - OsStr::new(&message), - ]) + .run( + self.device.root, + [ + OsStr::new("message"), + self.device.name().as_ref(), + OsStr::new("0"), + OsStr::new(&message), + ], + ) .map(drop) } } @@ -262,11 +270,8 @@ impl<'a> Thin<'a, Inactive> { id: self.id, origin, }); - let device = self - .pool - .device - .dmsetup - .create(name, &table, Access::ReadWrite)?; + let Device { dmsetup, root, .. } = self.pool.device; + let device = dmsetup.create(root, name, &table, Access::ReadWrite)?; Ok(Thin { pool: self.pool, id: self.id, @@ -329,6 +334,7 @@ mod tests { use assert_fs::prelude::*; use assert_fs::TempDir; use hyperrs_process::binary::RootSafeBin; + use hyperrs_process::privilege::Unprivileged; use pretty_assertions::assert_eq; use proptest::prelude::*; use rstest::rstest; @@ -544,8 +550,10 @@ mod tests { eprintln!("SKIP thin_pool_refuses: needs root to own the fake dmsetup"); return; } + let mut token = Unprivileged::take().unwrap(); + let root = token.elevate().unwrap(); let fake = Fake::new(table, &[]); - let got = fake.dmsetup.thin_pool(&name("hyper-x")); + let got = fake.dmsetup.thin_pool(&root, &name("hyper-x")); assert_matches!(got, Err(ThinPoolError::NotAThinPool { .. })); assert_eq!(fake.calls(), ["table hyper-x"]); } @@ -569,8 +577,10 @@ mod tests { eprintln!("SKIP snapshot_always_resumes: needs root to own the fake dmsetup"); return; } + let mut token = Unprivileged::take().unwrap(); + let root = token.elevate().unwrap(); let fake = Fake::new(POOL_TABLE, failing); - let pool = fake.dmsetup.thin_pool(&name("hyper-pool")).unwrap(); + let pool = fake.dmsetup.thin_pool(&root, &name("hyper-pool")).unwrap(); let active = pool .create_thin(ThinId::new(1).unwrap()) .unwrap() @@ -589,8 +599,10 @@ mod tests { eprintln!("SKIP delete_removes: needs root to own the fake dmsetup"); return; } + let mut token = Unprivileged::take().unwrap(); + let root = token.elevate().unwrap(); let fake = Fake::new(POOL_TABLE, &[]); - let pool = fake.dmsetup.thin_pool(&name("hyper-pool")).unwrap(); + let pool = fake.dmsetup.thin_pool(&root, &name("hyper-pool")).unwrap(); pool.create_thin(ThinId::new(1).unwrap()) .unwrap() .activate(&name("hyper-vol"), 100, None) @@ -612,6 +624,8 @@ mod tests { eprintln!("SKIP open_thin: needs root to own the fake dmsetup"); return; } + let mut token = Unprivileged::take().unwrap(); + let root = token.elevate().unwrap(); let fake = Fake::with_tables( &[ ("hyper-pool", POOL_TABLE), @@ -619,7 +633,7 @@ mod tests { ], &[], ); - let pool = fake.dmsetup.thin_pool(&name("hyper-pool")).unwrap(); + let pool = fake.dmsetup.thin_pool(&root, &name("hyper-pool")).unwrap(); let snap = pool .open_thin(&name("hyper-vol")) @@ -652,8 +666,10 @@ mod tests { eprintln!("SKIP open_thin refusal: needs root to own the fake dmsetup"); return; } + let mut token = Unprivileged::take().unwrap(); + let root = token.elevate().unwrap(); let fake = Fake::with_tables(&[("hyper-pool", POOL_TABLE), ("hyper-vol", table)], &[]); - let pool = fake.dmsetup.thin_pool(&name("hyper-pool")).unwrap(); + let pool = fake.dmsetup.thin_pool(&root, &name("hyper-pool")).unwrap(); assert_matches!( pool.open_thin(&name("hyper-vol")), @@ -669,8 +685,10 @@ mod tests { eprintln!("SKIP open_thin id: needs root to own the fake dmsetup"); return; } + let mut token = Unprivileged::take().unwrap(); + let root = token.elevate().unwrap(); let fake = Fake::with_tables(&[("hyper-pool", POOL_TABLE), ("hyper-vol", table)], &[]); - let pool = fake.dmsetup.thin_pool(&name("hyper-pool")).unwrap(); + let pool = fake.dmsetup.thin_pool(&root, &name("hyper-pool")).unwrap(); assert_matches!( pool.open_thin(&name("hyper-vol")), diff --git a/native/hyperrs-linux/src/dm/thin_dump.rs b/native/hyperrs-linux/src/dm/thin_dump.rs index 279a4cf4..533de4bb 100644 --- a/native/hyperrs-linux/src/dm/thin_dump.rs +++ b/native/hyperrs-linux/src/dm/thin_dump.rs @@ -3,15 +3,14 @@ use super::ThinId; use derive_more::{Constructor, Into}; use hyperrs_fs::file::{IsBlockDevice, SafeFile}; use hyperrs_process::binary::RootSafeBin; +use hyperrs_process::privilege::{self, RootCommandExt}; use serde::Deserialize; use std::io; -use std::os::unix::io::AsRawFd; +use std::os::unix::io::{AsFd, AsRawFd}; use thiserror::Error as ThisError; #[derive(Debug, ThisError)] pub enum DumpError { - #[error("passing the metadata device: {0}")] - Inherit(#[source] nix::Error), #[error("running thin_dump: {0}")] Spawn(#[source] io::Error), #[error("thin_dump failed: {0}")] @@ -44,16 +43,17 @@ pub struct ThinDump { impl ThinDump { pub fn dump( &self, + root: &privilege::Root<'_>, metadata: &SafeFile, id: ThinId, ) -> Result { - let inherited = metadata.inheritable().map_err(DumpError::Inherit)?; let out = self .bin .command() .args(["--metadata-snap", "--dev-id", &id.to_string()]) - .arg(format!("/proc/self/fd/{}", inherited.as_raw_fd())) - .env_clear() + .arg(format!("/proc/self/fd/{}", metadata.as_raw_fd())) + // The binary fd stays open so an interpreted tool can reopen itself via /proc/self/fd. + .spawn_as_root(root, &[self.bin.as_fd(), metadata.as_fd()]) .output() .map_err(DumpError::Spawn)?; diff --git a/native/suidhelper/Cargo.toml b/native/suidhelper/Cargo.toml index 6a1faac4..fd06d713 100644 --- a/native/suidhelper/Cargo.toml +++ b/native/suidhelper/Cargo.toml @@ -63,6 +63,10 @@ path = "tests/e2e/caller_gate.rs" name = "e2e_net_hostile" path = "tests/e2e/net_hostile.rs" +[[test]] +name = "e2e_setuid" +path = "tests/e2e/setuid.rs" + [[test]] name = "e2e_argv" path = "tests/e2e/argv.rs" diff --git a/native/suidhelper/src/cli/dm.rs b/native/suidhelper/src/cli/dm.rs index f61c19d4..8fad228e 100644 --- a/native/suidhelper/src/cli/dm.rs +++ b/native/suidhelper/src/cli/dm.rs @@ -77,8 +77,8 @@ impl Op for Remove { RemoveMode::Once }; let dm = dm::Dmsetup::new(Config::get().dmsetup()?); - let _root = token.elevate()?; - dm.device(&name).remove(mode)?; + let root = token.elevate()?; + dm.device(&root, &name).remove(mode)?; Ok(DmOut::Removed) } } @@ -106,7 +106,7 @@ impl HyperDmTable { ) -> Result { let dm = dm::Dmsetup::new(Config::get().dmsetup()?); let (device, loops) = { - let _root = token.elevate()?; + let root = token.elevate()?; let control = LoopControl::open()?; let mut loops = BTreeMap::new(); let mut attached = self.attach(|role, backing| { @@ -126,7 +126,10 @@ impl HyperDmTable { DmTable::ThinPool(t) => t.sectors = sectors, DmTable::Thin(t) => t.sectors = sectors, } - (dm.create(name, &attached, access)?.path().into(), loops) + ( + dm.create(&root, name, &attached, access)?.path().into(), + loops, + ) }; Ok(Created { device, diff --git a/native/suidhelper/src/cli/fork_delta.rs b/native/suidhelper/src/cli/fork_delta.rs index 0a047543..cde8dad8 100644 --- a/native/suidhelper/src/cli/fork_delta.rs +++ b/native/suidhelper/src/cli/fork_delta.rs @@ -14,7 +14,7 @@ use hyperrs_linux::dm::{ }; use hyperrs_linux::Access; use hyperrs_process::binary::RootSafeBinError; -use hyperrs_process::privilege::{PrivilegeError, Unprivileged}; +use hyperrs_process::privilege::{PrivilegeError, Root, Unprivileged}; use nix::fcntl::{Flock, FlockArg}; use serde::Deserialize; use serde::Serialize; @@ -107,9 +107,9 @@ impl Op for ThinForkDelta { let scratch: HyperDmName = format!("hyper-scratch-{}", self.scratch_id).parse()?; let meta = { - let _root = token.elevate()?; + let root = token.elevate()?; let sectors = self.origin.sectors().map_err(DmError::from)?; - let pool = dmsetup.thin_pool(&self.pool)?; + let pool = dmsetup.thin_pool(&root, &self.pool)?; let meta = SafeFile::::open_block( pool.metadata(), OpenFlags::RDONLY, @@ -131,9 +131,9 @@ impl Op for ThinForkDelta { let copied = self.copy_scratch(&scratch, target, &dmsetup, &thin_dump, &meta, &mut token); let destroyed = (|| { - let _root = token.elevate()?; + let root = token.elevate()?; dmsetup - .thin_pool(&self.pool)? + .thin_pool(&root, &self.pool)? .open_thin(&scratch)? .deactivate() .and_then(|thin| thin.delete()) @@ -156,8 +156,8 @@ impl ThinForkDelta { token: &mut Unprivileged, ) -> Result { let (id, dumped) = { - let _root = token.elevate()?; - self.dump_reserved(dmsetup, thin_dump, meta, scratch)? + let root = token.elevate()?; + self.dump_reserved(&root, dmsetup, thin_dump, meta, scratch)? }; let mappings = dumped.parse()?.mappings(id)?; @@ -179,9 +179,9 @@ impl ThinForkDelta { Ok::<_, ForkDeltaError>(stats) })(); let removed = (|| { - let _root = token.elevate()?; + let root = token.elevate()?; dmsetup - .device(&target_name) + .device(&root, &target_name) .remove(RemoveMode::Retry) .map_err(ForkDeltaError::Remove) })(); @@ -192,6 +192,7 @@ impl ThinForkDelta { fn dump_reserved( &self, + root: &Root<'_>, dmsetup: &dm::Dmsetup, thin_dump: &dump::ThinDump, device: &SafeFile, @@ -203,14 +204,14 @@ impl ThinForkDelta { .map_err(ForkDeltaError::Lock)?; let _lock = Flock::lock(lock_fd, FlockArg::LockExclusive) .map_err(|(_, e)| ForkDeltaError::Lock(e.into()))?; - let pool = dmsetup.thin_pool(&self.pool)?; + let pool = dmsetup.thin_pool(root, &self.pool)?; let id = pool.open_thin(src)?.id(); if pool.send(ThinMessage::ReserveMetadataSnap).is_err() { let _ = pool.send(ThinMessage::ReleaseMetadataSnap); pool.send(ThinMessage::ReserveMetadataSnap) .map_err(ForkDeltaError::Reserve)?; } - let dumped = thin_dump.dump(device, id); + let dumped = thin_dump.dump(root, device, id); let released = pool .send(ThinMessage::ReleaseMetadataSnap) .map_err(ForkDeltaError::Release); diff --git a/native/suidhelper/src/cli/img.rs b/native/suidhelper/src/cli/img.rs index aaa8da13..0e03e519 100644 --- a/native/suidhelper/src/cli/img.rs +++ b/native/suidhelper/src/cli/img.rs @@ -54,9 +54,9 @@ impl Op for ImgActivate { created.push(name); } Err(e) => { - let _root = token.elevate().map_err(DmError::from)?; + let root = token.elevate().map_err(DmError::from)?; for name in created.iter().rev() { - let _ = dm.device(name).remove(RemoveMode::Retry); + let _ = dm.device(&root, name).remove(RemoveMode::Retry); } return Err(e.into()); } diff --git a/native/suidhelper/src/cli/thin.rs b/native/suidhelper/src/cli/thin.rs index d45fa213..943afca9 100644 --- a/native/suidhelper/src/cli/thin.rs +++ b/native/suidhelper/src/cli/thin.rs @@ -90,10 +90,10 @@ impl Op for ThinPoolCreate { .map_err(DmError::from)?; let dm = dm::Dmsetup::new(Config::get().dmsetup().map_err(DmError::from)?); { - let _root = token.elevate()?; - if let Err(e) = dm.device(&self.name).remove(RemoveMode::Retry) { + let root = token.elevate()?; + if let Err(e) = dm.device(&root, &self.name).remove(RemoveMode::Retry) { if !matches!( - dm.device(&self.name).number(), + dm.device(&root, &self.name).number(), Err(NumberError::Run(RunError::Failed(_))) ) { return Err(e.into()); @@ -116,9 +116,9 @@ impl Op for ThinVolumeCreate { fn run(self, mut token: Unprivileged) -> Result { let dm = dm::Dmsetup::new(Config::get().dmsetup().map_err(DmError::from)?); - let _root = token.elevate()?; + let root = token.elevate()?; let sectors = self.origin.sectors().map_err(DmError::from)?; - let pool = dm.thin_pool(&self.pool)?; + let pool = dm.thin_pool(&root, &self.pool)?; let thin = match &self.parent { None => pool.create_thin(self.thin_id)?, Some(parent) => match pool.open_thin(parent)?.snapshot(self.thin_id) { @@ -149,8 +149,8 @@ impl Op for ThinDestroy { fn run(self, mut token: Unprivileged) -> Result { let dm = dm::Dmsetup::new(Config::get().dmsetup().map_err(DmError::from)?); - let _root = token.elevate()?; - dm.thin_pool(&self.pool)? + let root = token.elevate()?; + dm.thin_pool(&root, &self.pool)? .open_thin(&self.name)? .deactivate()? .delete()?; diff --git a/native/suidhelper/tests/e2e/setuid.rs b/native/suidhelper/tests/e2e/setuid.rs new file mode 100644 index 00000000..aa4f5698 --- /dev/null +++ b/native/suidhelper/tests/e2e/setuid.rs @@ -0,0 +1,629 @@ +//! The privilege gate observed on real setuid-root installs, driven by callers that are not +//! root. Static builds are compiled on demand for the musl target (the only kind the helper +//! may be installed as); the dynamically linked test binary stands in for a mis-install. +//! +//! Laws: +//! - a dynamically linked build installed setuid refuses every request before parsing it; +//! - `version` answers any caller of a static setuid install; +//! - a caller outside the install group is refused every privileged op with `NotInGroup` +//! before the config is read, while a primary or supplementary member gets past the gate; +//! - an install with group root refuses every privileged op to every non-root caller; +//! - the config is read as the caller, never as root: a root-only config is unreadable to a +//! member's setuid invocation and readable to root's; +//! - a production build ignores the insecure-mode env seams entirely; +//! - neither the caller's `PATH` nor `LD_PRELOAD` reaches the tool the helper runs as root; +//! - the tool the helper runs as root starts with an empty environment; +//! - that tool is genuine root (real, effective and saved ids 0, groups `[0]`) and inherits no +//! descriptor the caller passed in, the contract `RootCommandExt::spawn_as_root` states; +//! - a request nested to the argv length limit is refused, never a crash. + +use assert_fs::TempDir; +use nix::unistd::{setgroups, setresgid, setresuid, Gid, Uid}; +use pretty_assertions::assert_eq; +use rstest::rstest; +use serde_json::{json, Value}; +use std::fs; +use std::os::unix::fs::PermissionsExt; +use std::os::unix::process::{CommandExt, ExitStatusExt}; +use std::path::{Path, PathBuf}; +use std::process::{Command, Output}; + +mod support; +use support::{is_root, BIN}; + +const MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR"); +const DYNAMIC_REFUSAL: &str = + "hyper-suidhelper: refusing to run setuid as a dynamically linked binary\n"; +const INSTALL_GROUP: u32 = 61_001; +const MALFORMED_TOML: &str = "this is not = valid = toml ==="; +const ABSENT_DM: &str = "hyper-setuid-e2e-absent"; + +#[derive(Clone, Copy)] +struct Caller { + uid: u32, + gid: u32, + groups: &'static [u32], +} + +const MEMBER: Caller = Caller { + uid: 61_010, + gid: INSTALL_GROUP, + groups: &[], +}; +const SUPPLEMENTARY_MEMBER: Caller = Caller { + uid: 61_011, + gid: 61_020, + groups: &[61_021, INSTALL_GROUP], +}; +const OUTSIDER: Caller = Caller { + uid: 61_012, + gid: 61_022, + groups: &[61_023], +}; +const ROOT_GROUP_OUTSIDER: Caller = Caller { + uid: 61_013, + gid: 0, + groups: &[0], +}; + +#[derive(Clone, Copy, PartialEq, Eq)] +enum Build { + Production, + Insecure, +} + +fn has_interpreter(elf: &[u8]) -> bool { + const PT_INTERP: u32 = 3; + let u16_at = |at: usize| usize::from(u16::from_le_bytes([elf[at], elf[at + 1]])); + let phoff = usize::try_from(u64::from_le_bytes(elf[0x20..0x28].try_into().unwrap())).unwrap(); + let (phentsize, phnum) = (u16_at(0x36), u16_at(0x38)); + (0..phnum).any(|idx| { + let at = phoff + idx * phentsize; + u32::from_le_bytes(elf[at..at + 4].try_into().unwrap()) == PT_INTERP + }) +} + +fn home_of(uid: u32) -> Option { + nix::unistd::User::from_uid(Uid::from_raw(uid)) + .ok() + .flatten() + .map(|user| user.dir) +} + +fn static_helper(build: Build) -> PathBuf { + let target = format!("{}-unknown-linux-musl", std::env::consts::ARCH); + let variant = match build { + Build::Production => "production", + Build::Insecure => "insecure", + }; + let target_dir = Path::new(MANIFEST_DIR) + .join("../target/setuid-e2e") + .join(variant); + let mut cargo = Command::new(std::env::var("CARGO").unwrap_or_else(|_| "cargo".to_owned())); + cargo.current_dir(MANIFEST_DIR).args([ + "build", + "--quiet", + "-p", + "hyper-suidhelper", + "--bin", + "hyper-suidhelper", + "--target", + &target, + "--target-dir", + ]); + cargo.arg(&target_dir); + if build == Build::Insecure { + cargo.args(["--features", "insecure_mode"]); + } + for coverage_or_target in [ + "RUSTFLAGS", + "CARGO_ENCODED_RUSTFLAGS", + "RUSTC_WRAPPER", + "RUSTC_WORKSPACE_WRAPPER", + "LLVM_PROFILE_FILE", + "CARGO_TARGET_DIR", + "CARGO_BUILD_TARGET_DIR", + "CARGO_LLVM_COV", + "CARGO_LLVM_COV_TARGET_DIR", + ] { + cargo.env_remove(coverage_or_target); + } + let invoker = std::env::var("SUDO_UID") + .ok() + .zip(std::env::var("SUDO_GID").ok()) + .and_then(|(uid, gid)| Some((uid.parse::().ok()?, gid.parse::().ok()?))); + if let Some((uid, gid)) = invoker { + if let Some(home) = home_of(uid) { + cargo.env("HOME", home); + } + cargo.uid(uid).gid(gid); + } + let status = cargo.status().expect("spawning cargo"); + assert!( + status.success(), + "building the {variant} static helper failed" + ); + let bin = target_dir.join(&target).join("debug/hyper-suidhelper"); + assert!( + !has_interpreter(&fs::read(&bin).unwrap()), + "{} is not static", + bin.display() + ); + bin +} + +struct Install { + dir: TempDir, + bin: PathBuf, +} + +impl Install { + fn setuid(source: &Path, group: u32) -> Self { + let dir = TempDir::new().unwrap(); + fs::set_permissions(dir.path(), fs::Permissions::from_mode(0o755)).unwrap(); + let bin = dir.path().join("hyper-suidhelper"); + fs::copy(source, &bin).unwrap(); + nix::unistd::chown(&bin, Some(Uid::from_raw(0)), Some(Gid::from_raw(group))).unwrap(); + fs::set_permissions(&bin, fs::Permissions::from_mode(0o4755)).unwrap(); + Self { dir, bin } + } + + fn config(&self, body: &str, mode: u32) -> PathBuf { + let path = self.dir.path().join(format!("config-{mode:o}.toml")); + fs::write(&path, body).unwrap(); + fs::set_permissions(&path, fs::Permissions::from_mode(mode)).unwrap(); + path + } + + fn run(&self, caller: Caller, request: &Value, env: &[(&str, &Path)]) -> Output { + let mut cmd = Command::new(&self.bin); + cmd.arg(request.to_string()).env_clear(); + for (key, value) in env { + cmd.env(key, value); + } + let Caller { uid, gid, groups } = caller; + // SAFETY: the hook runs in the forked child before exec and makes only raw id syscalls. + unsafe { + cmd.pre_exec(move || { + let groups: Vec = groups.iter().copied().map(Gid::from_raw).collect(); + setgroups(&groups)?; + setresgid(Gid::from_raw(gid), Gid::from_raw(gid), Gid::from_raw(gid))?; + setresuid(Uid::from_raw(uid), Uid::from_raw(uid), Uid::from_raw(uid))?; + Ok(()) + }) + }; + cmd.output().unwrap() + } +} + +fn stderr(out: &Output) -> String { + String::from_utf8_lossy(&out.stderr).into_owned() +} + +fn privileged_requests() -> Vec { + let fixture: serde_json::Map = + serde_json::from_str(include_str!("../fixtures/requests.json")).unwrap(); + fixture + .into_iter() + .map(|(_, request)| request) + .filter(|request| request["op"] != "version") + .collect() +} + +fn insecure_env(config: &Path) -> [(&'static str, &Path); 2] { + [ + ("HYPER_SETUIDHELPER_IS_INSECURE_MODE", Path::new("1")), + ("HYPER_SETUIDHELPER_CONFIG_PATH", config), + ] +} + +#[rstest] +#[case::version(json!({"op": "version"}))] +#[case::privileged(json!({"op": "vm_teardown", "id": "v1"}))] +#[case::malformed(json!("not a request"))] +fn a_dynamically_linked_setuid_install_refuses_every_request_as_root(#[case] request: Value) { + if !is_root() { + eprintln!("SKIP dynamic setuid install: needs root to install setuid"); + return; + } + assert!( + has_interpreter(&fs::read(BIN).unwrap()), + "the test binary must be dynamic" + ); + let install = Install::setuid(Path::new(BIN), INSTALL_GROUP); + + let out = install.run(MEMBER, &request, &[]); + + assert_eq!( + (out.status.code(), stderr(&out), out.stdout.len()), + (Some(1), DYNAMIC_REFUSAL.to_owned(), 0) + ); +} + +#[rstest] +#[case::member(MEMBER)] +#[case::outsider(OUTSIDER)] +#[case::root_group_outsider(ROOT_GROUP_OUTSIDER)] +fn version_answers_any_caller_of_a_static_setuid_install_as_root(#[case] caller: Caller) { + if !is_root() { + eprintln!("SKIP static setuid version: needs root to install setuid"); + return; + } + let install = Install::setuid(&static_helper(Build::Production), INSTALL_GROUP); + + let out = install.run(caller, &json!({"op": "version"}), &[]); + + assert!(out.status.success(), "{}", stderr(&out)); + let reply: Value = serde_json::from_slice(&out.stdout).unwrap(); + assert_eq!(reply["version"], env!("CARGO_PKG_VERSION")); +} + +#[rstest] +fn an_outsider_is_refused_every_privileged_op_before_the_config_is_read_as_root() { + if !is_root() { + eprintln!("SKIP outsider gate: needs root to install setuid"); + return; + } + let install = Install::setuid(&static_helper(Build::Insecure), INSTALL_GROUP); + let config = install.config(MALFORMED_TOML, 0o644); + let refusal = format!( + "uid {} is not in the helper's group {INSTALL_GROUP}", + OUTSIDER.uid + ); + + for request in privileged_requests() { + let outsider = install.run(OUTSIDER, &request, &insecure_env(&config)); + let member = install.run(MEMBER, &request, &insecure_env(&config)); + let supplementary = install.run(SUPPLEMENTARY_MEMBER, &request, &insecure_env(&config)); + + assert_eq!(outsider.status.code(), Some(2), "{request}"); + assert!( + stderr(&outsider).contains(&refusal), + "{request}: {}", + stderr(&outsider) + ); + assert!(!stderr(&outsider).contains("not valid TOML"), "{request}"); + for passed in [member, supplementary] { + assert!( + stderr(&passed).contains("not valid TOML"), + "{request}: a member must reach the config: {}", + stderr(&passed) + ); + } + } +} + +#[rstest] +#[case::member_of_nothing(OUTSIDER)] +#[case::primary_group_root(ROOT_GROUP_OUTSIDER)] +fn a_root_group_install_refuses_every_privileged_op_to_non_root_callers_as_root( + #[case] caller: Caller, +) { + if !is_root() { + eprintln!("SKIP root-group install: needs root to install setuid"); + return; + } + let install = Install::setuid(&static_helper(Build::Insecure), 0); + let config = install.config(MALFORMED_TOML, 0o644); + + for request in privileged_requests() { + let out = install.run(caller, &request, &insecure_env(&config)); + + assert_eq!(out.status.code(), Some(2), "{request}"); + assert!( + stderr(&out).contains("installed with group root, so only root may run it"), + "{request}: {}", + stderr(&out) + ); + } +} + +#[rstest] +#[case::member_cannot_read_a_root_only_config(MEMBER, 0o600, "open failed: EACCES")] +#[case::member_reads_a_world_readable_config(MEMBER, 0o644, "not valid TOML")] +#[case::root_reads_a_root_only_config( + Caller { uid: 0, gid: 0, groups: &[0] }, 0o600, "not valid TOML")] +fn the_config_is_read_as_the_caller_never_as_root_as_root( + #[case] caller: Caller, + #[case] mode: u32, + #[case] outcome: &str, +) { + if !is_root() { + eprintln!("SKIP config read identity: needs root to install setuid"); + return; + } + let install = Install::setuid(&static_helper(Build::Insecure), INSTALL_GROUP); + let config = install.config(MALFORMED_TOML, mode); + + let out = install.run( + caller, + &json!({"op": "vm_teardown", "id": "v1"}), + &insecure_env(&config), + ); + + assert_eq!(out.status.code(), Some(2)); + assert!(stderr(&out).contains(outcome), "{}", stderr(&out)); +} + +#[rstest] +#[case::production(Build::Production, false)] +#[case::insecure(Build::Insecure, true)] +fn only_an_insecure_build_honours_the_insecure_seams_as_root( + #[case] build: Build, + #[case] honoured: bool, +) { + if !is_root() { + eprintln!("SKIP insecure seams: needs root to install setuid"); + return; + } + let install = Install::setuid(&static_helper(build), INSTALL_GROUP); + let config = install.config(MALFORMED_TOML, 0o644); + + let out = install.run( + MEMBER, + &json!({"op": "dm_remove", "name": ABSENT_DM, "retry": false}), + &insecure_env(&config), + ); + + let stderr = stderr(&out); + assert_eq!(out.status.code(), Some(2), "{stderr}"); + assert_eq!( + ( + stderr.contains("INSECURE TEST MODE"), + stderr.contains("not valid TOML") + ), + (honoured, honoured), + "{stderr}" + ); +} + +fn compile_preload(dir: &Path, marker: &Path) -> PathBuf { + let source = dir.join("preload.c"); + let library = dir.join("preload.so"); + fs::write( + &source, + format!( + "#include \n#include \n\ + __attribute__((constructor)) static void hijack(void) {{\n\ + FILE *f = fopen(\"{}\", \"a\"); if (f) {{ fprintf(f, \"preload uid=%d euid=%d\\n\", \ + getuid(), geteuid()); fclose(f); }} }}\n", + marker.display() + ), + ) + .unwrap(); + let status = Command::new("cc") + .args(["-shared", "-fPIC", "-o"]) + .arg(&library) + .arg(&source) + .status() + .expect("a C compiler builds the preload library"); + assert!(status.success()); + fs::set_permissions(&library, fs::Permissions::from_mode(0o755)).unwrap(); + library +} + +fn plant_path_tool(dir: &Path, marker: &Path) -> PathBuf { + let bin = dir.join("path-bin"); + fs::create_dir(&bin).unwrap(); + fs::set_permissions(&bin, fs::Permissions::from_mode(0o755)).unwrap(); + let tool = bin.join("dmsetup"); + fs::write( + &tool, + format!( + "#!/bin/sh\necho \"path dmsetup $(id -u)\" >> '{}'\n", + marker.display() + ), + ) + .unwrap(); + fs::set_permissions(&tool, fs::Permissions::from_mode(0o755)).unwrap(); + bin +} + +#[rstest] +fn the_callers_path_and_preload_never_reach_the_root_tool_as_root() { + if !is_root() { + eprintln!("SKIP env poisoning: needs root to install setuid"); + return; + } + let install = Install::setuid(&static_helper(Build::Production), INSTALL_GROUP); + let scratch = TempDir::new().unwrap(); + fs::set_permissions(scratch.path(), fs::Permissions::from_mode(0o777)).unwrap(); + let marker = scratch.path().join("hijacked"); + let preload = compile_preload(scratch.path(), &marker); + let path = plant_path_tool(scratch.path(), &marker); + + let control = Command::new("/bin/true") + .env("LD_PRELOAD", &preload) + .status() + .unwrap(); + assert!( + control.success() && marker.exists(), + "the preload library must work" + ); + fs::remove_file(&marker).unwrap(); + + let out = install.run( + MEMBER, + &json!({"op": "dm_remove", "name": ABSENT_DM, "retry": false}), + &[ + ("PATH", &path), + ("LD_PRELOAD", &preload), + ("LD_LIBRARY_PATH", scratch.path()), + ], + ); + + assert!( + stderr(&out).contains(ABSENT_DM), + "the helper must reach its dmsetup: {}", + stderr(&out) + ); + assert!( + !marker.exists(), + "caller env reached a tool: {}", + fs::read_to_string(&marker).unwrap_or_default() + ); +} + +const RECORDER_C: &str = r#" +#define _GNU_SOURCE +#include +#include +#include +#include +extern char **environ; +int main(void) { + char links[64][512]; + int fds[64], nfds = 0; + DIR *dir = opendir("/proc/self/fd"); + struct dirent *entry; + while (dir && (entry = readdir(dir)) && nfds < 64) { + if (entry->d_name[0] == '.' || atoi(entry->d_name) == dirfd(dir)) continue; + char path[64]; + snprintf(path, sizeof path, "/proc/self/fd/%s", entry->d_name); + ssize_t len = readlink(path, links[nfds], sizeof links[nfds] - 1); + links[nfds][len < 0 ? 0 : len] = 0; + fds[nfds++] = atoi(entry->d_name); + } + if (dir) closedir(dir); + uid_t ru, eu, su; + gid_t rg, eg, sg, groups[64]; + getresuid(&ru, &eu, &su); + getresgid(&rg, &eg, &sg); + int ngroups = getgroups(64, groups), nenv = 0; + while (environ[nenv]) nenv++; + FILE *out = fopen(RECORD, "w"); + fprintf(out, "{\"uids\":[%u,%u,%u],\"gids\":[%u,%u,%u],\"groups\":[", ru, eu, su, rg, eg, sg); + for (int i = 0; i < ngroups; i++) fprintf(out, "%s%u", i ? "," : "", groups[i]); + fprintf(out, "],\"env\":%d,\"fds\":{", nenv); + for (int i = 0; i < nfds; i++) fprintf(out, "%s\"%d\":\"%s\"", i ? "," : "", fds[i], links[i]); + fprintf(out, "}}"); + fclose(out); + return 0; +} +"#; + +const CALLER_FD: i32 = 37; + +fn record_the_root_tool() -> Value { + let install = Install::setuid(&static_helper(Build::Insecure), INSTALL_GROUP); + let record = install.dir.path().join("record.json"); + let source = install.dir.path().join("recorder.c"); + let tool = install.dir.path().join("dmsetup"); + fs::write(&source, RECORDER_C).unwrap(); + let built = Command::new("cc") + .arg(format!("-DRECORD=\"{}\"", record.display())) + .arg("-o") + .arg(&tool) + .arg(&source) + .status() + .expect("a C compiler builds the recording tool"); + assert!(built.success()); + fs::set_permissions(&tool, fs::Permissions::from_mode(0o755)).unwrap(); + fs::set_permissions(install.dir.path(), fs::Permissions::from_mode(0o777)).unwrap(); + let config = install.config( + &format!( + "work_dir = \"/srv/hyper\"\n[tools]\ndmsetup = \"{}\"\n", + tool.display() + ), + 0o644, + ); + let secret = install.dir.path().join("caller-secret"); + fs::write(&secret, "caller").unwrap(); + let passed = fs::File::open(&secret).unwrap(); + + let mut cmd = Command::new(&install.bin); + cmd.arg(json!({"op": "dm_remove", "name": ABSENT_DM, "retry": false}).to_string()) + .env_clear() + .env("HYPER_SETUIDHELPER_IS_INSECURE_MODE", "1") + .env("HYPER_SETUIDHELPER_CONFIG_PATH", &config) + .env("LD_PRELOAD", "/nonexistent/preload.so") + .env("PATH", install.dir.path()); + let Caller { uid, gid, groups } = SUPPLEMENTARY_MEMBER; + let raw = std::os::unix::io::AsRawFd::as_raw_fd(&passed); + // SAFETY: the hook runs in the forked child before exec and makes only raw fd/id syscalls. + unsafe { + cmd.pre_exec(move || { + if nix::libc::dup2(raw, CALLER_FD) < 0 { + return Err(std::io::Error::last_os_error()); + } + let groups: Vec = groups.iter().copied().map(Gid::from_raw).collect(); + setgroups(&groups)?; + setresgid(Gid::from_raw(gid), Gid::from_raw(gid), Gid::from_raw(gid))?; + setresuid(Uid::from_raw(uid), Uid::from_raw(uid), Uid::from_raw(uid))?; + Ok(()) + }) + }; + let out = cmd.output().unwrap(); + assert!(out.status.success(), "{}", stderr(&out)); + let recorded: Value = serde_json::from_str(&fs::read_to_string(&record).unwrap()).unwrap(); + let leaked_caller_fd = recorded["fds"] + .as_object() + .unwrap() + .values() + .any(|target| target == secret.to_str().unwrap()); + json!({ + "uids": recorded["uids"], + "gids": recorded["gids"], + "groups": recorded["groups"], + "env": recorded["env"], + "caller_fd_inherited": leaked_caller_fd, + }) +} + +#[rstest] +fn the_root_tool_starts_with_an_empty_environment_as_root() { + if !is_root() { + eprintln!("SKIP root tool env: needs root to install setuid"); + return; + } + assert_eq!(record_the_root_tool()["env"], json!(0)); +} + +#[rstest] +fn the_root_tool_is_genuine_root_and_inherits_no_caller_fd_as_root() { + if !is_root() { + eprintln!("SKIP root tool identity: needs root to install setuid"); + return; + } + let recorded = record_the_root_tool(); + + assert_eq!( + json!({ + "uids": recorded["uids"], + "gids": recorded["gids"], + "groups": recorded["groups"], + "caller_fd_inherited": recorded["caller_fd_inherited"], + }), + json!({ + "uids": [0, 0, 0], + "gids": [0, 0, 0], + "groups": [0], + "caller_fd_inherited": false, + }) + ); +} + +#[rstest] +#[case::arrays("[", "]")] +#[case::objects("{\"op\":", "}")] +fn a_request_nested_to_the_argv_limit_is_refused_not_crashed( + #[case] open: &str, + #[case] close: &str, +) { + let depth = (128 * 1024 - 64) / (open.len() + close.len()); + let request = format!("{}0{}", open.repeat(depth), close.repeat(depth)); + + let out = Command::new(BIN) + .arg(&request) + .env_clear() + .output() + .unwrap(); + + assert_eq!(out.status.signal(), None, "{}", stderr(&out)); + assert_eq!(out.status.code(), Some(2)); + assert!( + stderr(&out).starts_with("invalid request:"), + "{}", + stderr(&out) + ); +} From ac858b5bf2bc94314e5466caf890944c92cdf8fb Mon Sep 17 00:00:00 2001 From: Marko Vejnovic Date: Sun, 15 Nov 2026 22:29:01 +0000 Subject: [PATCH 4/8] docs(suidhelper): describe the transit-range drop and genuine-root tool spawns --- docs/cookbook/networking.md | 5 +++-- native/suidhelper/README.md | 5 +++-- native/suidhelper/src/net/host.rs | 4 ++-- 3 files changed, 8 insertions(+), 6 deletions(-) diff --git a/docs/cookbook/networking.md b/docs/cookbook/networking.md index a5883898..260b6e5d 100644 --- a/docs/cookbook/networking.md +++ b/docs/cookbook/networking.md @@ -324,8 +324,9 @@ The host's `inet hyper` table holds the rules that are the same for every VM: their networks and metadata services in: private, shared and link-local IPv4, unique local IPv6, and the NAT64, 6to4 and IPv4-mapped prefixes that lead back to them. -- **No transit access.** New connections into the transit network are dropped - whatever `blocked` says, so VMs can't talk to each other over it. +- **No transit access.** New connections into the transit network, and packets + into it that conntrack can't track, are dropped whatever `blocked` says, so + neither VMs nor the internet reach it. - **No untranslated traffic.** Packets conntrack can't track are dropped, as is anything from a VM whose source is outside the transit network and the VM range. diff --git a/native/suidhelper/README.md b/native/suidhelper/README.md index edd5ded6..e26f6b21 100644 --- a/native/suidhelper/README.md +++ b/native/suidhelper/README.md @@ -68,8 +68,9 @@ elsewhere via dm-thin), so there is no read-write attach. - **`--bin` is validated, not trusted.** It must be an absolute path whose basename matches the subcommand, and a **root-owned, non-symlink, not group/other-writable** regular file. An unprivileged caller therefore can't - point it at a binary it controls. The tool is exec'd with a cleared - environment (no `LD_PRELOAD`/`PATH` inheritance). + point it at a binary it controls. The tool runs as genuine root (real, + effective and saved ids 0, groups `[0]`) with a cleared environment (no + `LD_PRELOAD`/`PATH` inheritance) and only the fds it is handed. - **Operands are validated by type, at parse time.** Loop devices must be `/dev/loopN`; block operands must be a loop or a `/dev/mapper/hyper-*` device; dm names must be `hyper-*`; backing files must canonicalize under `/srv/hyper` diff --git a/native/suidhelper/src/net/host.rs b/native/suidhelper/src/net/host.rs index b430e2d6..4e5c2dff 100644 --- a/native/suidhelper/src/net/host.rs +++ b/native/suidhelper/src/net/host.rs @@ -109,8 +109,8 @@ impl HostNet<'_> { .chain() } - /// VMs reach only public addresses. What reaches a VM is its own namespace's - /// firewall to decide. + /// VMs reach only public addresses. Nothing new or untracked reaches the transit + /// range; what reaches a VM's public address is its own namespace's firewall to decide. fn forward(&self) -> Chain { let vm_range = Match::Ipv6Daddr(self.prefix.vm_range()); let not_vm_range = || Match::Not(Box::new(vm_range.clone())); From c064505471023d19e050127cc7840aa65a9c9c1e Mon Sep 17 00:00:00 2001 From: Marko Vejnovic Date: Mon, 16 Nov 2026 02:03:44 +0000 Subject: [PATCH 5/8] test(dm): kill the changed-code mutants of the root-spawned dmsetup Pull the thin-pool table check out of ThinPool::open so the unprivileged suite can refuse non-pool tables directly. The remaining dmsetup spawns need genuine root and are excluded, naming the _as_root tests that kill them in the privileged job. --- native/.cargo/mutants.toml | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/native/.cargo/mutants.toml b/native/.cargo/mutants.toml index 6aea6231..0aa0d229 100644 --- a/native/.cargo/mutants.toml +++ b/native/.cargo/mutants.toml @@ -26,6 +26,15 @@ exclude_re = [ "suidhelper/src/net/vm\\.rs:.*VmNet<'_>::", "suidhelper/src/cli/vm/claim\\.rs:.*SocketPin<'_>::", "suidhelper/src/cli/vm/teardown\\.rs:.*Teardown::unpin_sockets", + # dmsetup runs as genuine root from a root-owned binary; killed by the fake-dmsetup + # dm::thin _as_root tests in hyperrs-linux (snapshot_always_resumes_the_origin_as_root, + # deactivate_then_delete_removes_the_device_then_frees_its_id_as_root) and, for the old-pool + # check, suidhelper's pool_create_zeroes_the_metadata_only_once_no_old_pool_is_live_as_root, + # all in the privileged E2E job. + "hyperrs-linux/src/dm/mod\\.rs:.*Dmsetup::run ", + "hyperrs-linux/src/dm/device\\.rs:.*Device<'a>::(suspend|resume|remove) ", + "hyperrs-linux/src/dm/thin\\.rs:.*ThinPool<'a>::send ", + "suidhelper/src/cli/thin\\.rs:.*delete ! in ::run$", # Guest network setup runs inside a booted guest; killed by test/e2e/guest_network_test.exs # in the KVM integration job. "guest-agent/src/net\\.rs:.*GuestNet::(from_proc|configure)", From cc5b7b46fa9b3b9e9a8efc03ae49077b96e53103 Mon Sep 17 00:00:00 2001 From: Marko Vejnovic Date: Mon, 16 Nov 2026 02:15:13 +0000 Subject: [PATCH 6/8] test(suidhelper): build the helper in the invoker's cargo home, not root's --- native/suidhelper/tests/e2e/setuid.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/native/suidhelper/tests/e2e/setuid.rs b/native/suidhelper/tests/e2e/setuid.rs index aa4f5698..342464f1 100644 --- a/native/suidhelper/tests/e2e/setuid.rs +++ b/native/suidhelper/tests/e2e/setuid.rs @@ -136,6 +136,9 @@ fn static_helper(build: Build) -> PathBuf { if let Some(home) = home_of(uid) { cargo.env("HOME", home); } + // Root's cargo exports its own CARGO_HOME, which the invoker cannot write; + // without it cargo falls back to the invoker's $HOME/.cargo. + cargo.env_remove("CARGO_HOME"); cargo.uid(uid).gid(gid); } let status = cargo.status().expect("spawning cargo"); From 5c2b9c9cb43ab2d18c5521ad38e55ba4c5b76f6b Mon Sep 17 00:00:00 2001 From: Marko Vejnovic Date: Mon, 16 Nov 2026 02:25:24 +0000 Subject: [PATCH 7/8] test(suidhelper): give the invoker's helper build its own target dir --- native/suidhelper/tests/e2e/setuid.rs | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/native/suidhelper/tests/e2e/setuid.rs b/native/suidhelper/tests/e2e/setuid.rs index 342464f1..4aa34a5e 100644 --- a/native/suidhelper/tests/e2e/setuid.rs +++ b/native/suidhelper/tests/e2e/setuid.rs @@ -139,6 +139,15 @@ fn static_helper(build: Build) -> PathBuf { // Root's cargo exports its own CARGO_HOME, which the invoker cannot write; // without it cargo falls back to the invoker's $HOME/.cargo. cargo.env_remove("CARGO_HOME"); + // Root may have created target/ first (the coverage run does), so hand the + // build its own directories rather than asking the invoker to create them. + fs::create_dir_all(&target_dir).expect("creating the helper's target dir"); + for dir in [ + target_dir.parent().expect("target dir has a parent"), + &target_dir, + ] { + std::os::unix::fs::chown(dir, Some(uid), Some(gid)).expect("chowning target dir"); + } cargo.uid(uid).gid(gid); } let status = cargo.status().expect("spawning cargo"); From 9203fcc34a7d78e598ef31d438d82a8fae35a1b2 Mon Sep 17 00:00:00 2001 From: Marko Vejnovic Date: Mon, 16 Nov 2026 02:56:24 +0000 Subject: [PATCH 8/8] test(dm): pass genuine root to the dm and thin_dump test call sites --- .../tests/dm_kernel_argv_as_root.rs | 5 +- native/hyperrs-linux/tests/dm_live_as_root.rs | 66 +++++++++++++------ 2 files changed, 50 insertions(+), 21 deletions(-) diff --git a/native/hyperrs-linux/tests/dm_kernel_argv_as_root.rs b/native/hyperrs-linux/tests/dm_kernel_argv_as_root.rs index f4e7947f..4fdeccce 100644 --- a/native/hyperrs-linux/tests/dm_kernel_argv_as_root.rs +++ b/native/hyperrs-linux/tests/dm_kernel_argv_as_root.rs @@ -14,6 +14,7 @@ use hyperrs_linux::dm::{DevPath, DmName, DmTable, Dmsetup, LinearTable, Origin, use hyperrs_linux::loopdev::{LoopControl, LoopDevice}; use hyperrs_linux::Access; use hyperrs_process::binary::RootSafeBin; +use hyperrs_process::privilege::Unprivileged; use pretty_assertions::assert_eq; use rstest::rstest; use std::ffi::OsStr; @@ -66,6 +67,8 @@ fn a_linear_table_is_backed_by_the_path_it_names_as_root( eprintln!("SKIP: needs root"); return; } + let mut token = Unprivileged::take().unwrap(); + let root = token.elevate().unwrap(); let dir = TempDir::new().unwrap(); let base = fs::canonicalize(dir.path()).unwrap(); let wanted = attach(&base.join("wanted.img")); @@ -86,7 +89,7 @@ fn a_linear_table_is_backed_by_the_path_it_names_as_root( sectors: 8, origin: Origin::Path(origin), }); - let device = dm.create(&name, &table, Access::ReadOnly).unwrap(); + let device = dm.create(&root, &name, &table, Access::ReadOnly).unwrap(); let live = Command::new(DMSETUP) .args(["table", &name.to_string()]) diff --git a/native/hyperrs-linux/tests/dm_live_as_root.rs b/native/hyperrs-linux/tests/dm_live_as_root.rs index 33892c9c..f0113faa 100644 --- a/native/hyperrs-linux/tests/dm_live_as_root.rs +++ b/native/hyperrs-linux/tests/dm_live_as_root.rs @@ -29,6 +29,7 @@ use hyperrs_linux::dm::{ use hyperrs_linux::loopdev::{LoopControl, LoopDevice}; use hyperrs_linux::Access; use hyperrs_process::binary::RootSafeBin; +use hyperrs_process::privilege::{Root, Unprivileged}; use pretty_assertions::assert_eq; use proptest::prelude::*; use proptest::strategy::ValueTree; @@ -144,6 +145,8 @@ fn table() -> impl Strategy { #[test] fn create_passes_the_whole_table_as_one_argument_and_no_environment_as_root() { require_root!(); + let mut token = Unprivileged::take().unwrap(); + let root = token.elevate().unwrap(); std::env::set_var("HYPER_LEAK_PROBE", "leaked"); let fake = FakeDmsetup::new(""); let mut runner = proptest::test_runner::TestRunner::new(ProptestConfig::with_cases(24)); @@ -156,7 +159,7 @@ fn create_passes_the_whole_table_as_one_argument_and_no_environment_as_root() { } else { Access::ReadWrite }; - let dev = fake.dmsetup.create(&name(&n), &t, access).unwrap(); + let dev = fake.dmsetup.create(&root, &name(&n), &t, access).unwrap(); let mut expected = vec!["create".to_string(), n.clone()]; if ro { expected.push("--readonly".into()); @@ -176,8 +179,10 @@ type Verb = fn(&Device) -> Result<(), RunError>; #[test] fn every_device_verb_names_exactly_the_device_as_root() { require_root!(); + let mut token = Unprivileged::take().unwrap(); + let root = token.elevate().unwrap(); let fake = FakeDmsetup::new(""); - let dev = fake.dmsetup.device(&name("hyper-vol")); + let dev = fake.dmsetup.device(&root, &name("hyper-vol")); let verbs: [(Verb, &[&str]); 4] = [ (|d| d.suspend(), &["suspend", "hyper-vol"]), @@ -200,13 +205,15 @@ fn every_device_verb_names_exactly_the_device_as_root() { #[test] fn a_failing_dmsetup_is_an_error_carrying_its_trimmed_stderr_as_root() { require_root!(); + let mut token = Unprivileged::take().unwrap(); + let root = token.elevate().unwrap(); let fake = FakeDmsetup::new( "printf 'looks fine\\n'\nprintf '\\n device-mapper: reload ioctl failed \\n\\n' >&2\nexit 3", ); let err = fake .dmsetup - .device(&name("hyper-vol")) + .device(&root, &name("hyper-vol")) .suspend() .unwrap_err(); @@ -219,6 +226,8 @@ fn a_failing_dmsetup_is_an_error_carrying_its_trimmed_stderr_as_root() { #[test] fn device_number_accepts_only_a_major_minor_pair_as_root() { require_root!(); + let mut token = Unprivileged::take().unwrap(); + let root = token.elevate().unwrap(); for (out, expected) in [ ("253:7", Some((253, 7))), (" 253:7 ", Some((253, 7))), @@ -229,7 +238,7 @@ fn device_number_accepts_only_a_major_minor_pair_as_root() { ("253:-1", None), ] { let fake = FakeDmsetup::new(&format!("printf '%s\\n' '{out}'")); - let got = fake.dmsetup.device(&name("hyper-vol")).number(); + let got = fake.dmsetup.device(&root, &name("hyper-vol")).number(); assert_eq!( got.ok().map(|n| (n.major(), n.minor())), expected, @@ -343,6 +352,8 @@ fn live_dmsetup() -> Option { #[test] fn a_live_linear_table_is_sized_numbered_and_protected_as_requested_as_root() { require_root!(); + let mut token = Unprivileged::take().unwrap(); + let root = token.elevate().unwrap(); let Some(dm) = live_dmsetup() else { eprintln!("SKIP: no root-owned {DMSETUP}"); return; @@ -357,6 +368,7 @@ fn a_live_linear_table_is_sized_numbered_and_protected_as_requested_as_root() { let dev = dm .create( + &root, &name(&n), &DmTable::Linear(LinearTable { sectors, @@ -433,6 +445,8 @@ fn metadata_device(dir: &Path, marker: &[u8; 16]) -> (Loop, SafeFile", )); @@ -440,7 +454,7 @@ fn thin_dump_reads_the_metadata_through_the_inherited_fd_as_root() { let (_lo, meta) = metadata_device(&fake.base, &marker); let id = ThinId::new(5).unwrap(); - let dumped = fake.dump.dump(&meta, id).unwrap(); + let dumped = fake.dump.dump(&root, &meta, id).unwrap(); let argv = recorded_argv(&fake.base.join("argv")); assert_eq!(argv[..3], ["--metadata-snap", "--dev-id", "5"]); @@ -465,13 +479,15 @@ fn thin_dump_reads_the_metadata_through_the_inherited_fd_as_root() { #[test] fn a_mapping_total_that_overflows_is_refused_not_a_panic_as_root() { require_root!(); + let mut token = Unprivileged::take().unwrap(); + let root = token.elevate().unwrap(); let fake = FakeThinDump::new(&superblock(&format!( "", u64::MAX ))); let (_lo, meta) = metadata_device(&fake.base, b"0123456789abcdef"); let id = ThinId::new(5).unwrap(); - let superblock = fake.dump.dump(&meta, id).unwrap().parse().unwrap(); + let superblock = fake.dump.dump(&root, &meta, id).unwrap().parse().unwrap(); let got = std::panic::catch_unwind(|| superblock.mappings(id)); @@ -484,6 +500,8 @@ fn a_mapping_total_that_overflows_is_refused_not_a_panic_as_root() { #[test] fn a_failing_thin_dump_is_an_error_not_an_empty_dump_as_root() { require_root!(); + let mut token = Unprivileged::take().unwrap(); + let root = token.elevate().unwrap(); let dir = TempDir::new().unwrap(); let base = real(&dir); let bin = install( @@ -494,7 +512,9 @@ fn a_failing_thin_dump_is_an_error_not_an_empty_dump_as_root() { let dump = ThinDump::new(RootSafeBin::open(&bin).unwrap()); let (_lo, meta) = metadata_device(&base, b"0123456789abcdef"); - let err = dump.dump(&meta, ThinId::new(1).unwrap()).unwrap_err(); + let err = dump + .dump(&root, &meta, ThinId::new(1).unwrap()) + .unwrap_err(); assert_eq!(err.to_string(), "thin_dump failed: no metadata snap"); } @@ -514,7 +534,7 @@ const VOLUME_SECTORS: u64 = 16 << 11; const VOLUME_BLOCKS: u64 = VOLUME_SECTORS / BLOCK_SECTORS; impl LivePool { - fn new(tag: &str) -> Option { + fn new(root: &Root<'_>, tag: &str) -> Option { let dm = live_dmsetup()?; let dir = TempDir::new().unwrap(); let base = real(&dir); @@ -525,6 +545,7 @@ impl LivePool { let pool = format!("hyper-t-{tag}-pool-{}", std::process::id()); let guard = DmGuard(vec![pool.clone()]); dm.create( + root, &name(&pool), &DmTable::ThinPool(ThinPoolTable { sectors: POOL_DATA_BYTES / 512, @@ -570,11 +591,11 @@ fn read_block(dev: &Path, block: u64) -> Vec { buf } -fn mapped_blocks(pool: &LivePool, id: ThinId) -> BTreeSet { - let thin_pool = pool.dm.thin_pool(&pool.pool).unwrap(); +fn mapped_blocks(pool: &LivePool, root: &Root<'_>, id: ThinId) -> BTreeSet { + let thin_pool = pool.dm.thin_pool(root, &pool.pool).unwrap(); let dump = ThinDump::new(RootSafeBin::open(Path::new(THIN_DUMP)).unwrap()); thin_pool.reserve_metadata_snap().unwrap(); - let dumped = dump.dump(&pool.meta_dev, id); + let dumped = dump.dump(root, &pool.meta_dev, id); thin_pool.release_metadata_snap().unwrap(); dumped .unwrap() @@ -591,18 +612,20 @@ fn mapped_blocks(pool: &LivePool, id: ThinId) -> BTreeSet { #[test] fn a_real_pools_ids_snapshots_and_dumped_mappings_obey_their_laws_as_root() { require_root!(); + let mut token = Unprivileged::take().unwrap(); + let root = token.elevate().unwrap(); if RootSafeBin::<"thin_dump">::open(Path::new(THIN_DUMP)).is_err() { eprintln!("SKIP: no root-owned {THIN_DUMP}"); return; } - let Some(mut live) = LivePool::new("laws") else { + let Some(mut live) = LivePool::new(&root, "laws") else { eprintln!("SKIP: dm-thin unavailable"); return; }; let vol_name = live.volume_name("vol"); let snap_name = live.volume_name("snap"); let (one, two) = (ThinId::new(1).unwrap(), ThinId::new(2).unwrap()); - let pool = live.dm.thin_pool(&live.pool).unwrap(); + let pool = live.dm.thin_pool(&root, &live.pool).unwrap(); let vol = pool .create_thin(one) @@ -622,7 +645,7 @@ fn a_real_pools_ids_snapshots_and_dumped_mappings_obey_their_laws_as_root() { for &b in &written { write_block(vol.device().path().as_path(), b, (b % 250) as u8 + 1); } - assert_eq!(mapped_blocks(&live, one), written); + assert_eq!(mapped_blocks(&live, &root, one), written); let snap = vol.snapshot(two).unwrap(); let snap = snap.activate(&snap_name, VOLUME_SECTORS, None).unwrap(); @@ -637,10 +660,10 @@ fn a_real_pools_ids_snapshots_and_dumped_mappings_obey_their_laws_as_root() { read_block(snap.device().path().as_path(), fresh), vec![0u8; BLOCK_BYTES as usize] ); - assert_eq!(mapped_blocks(&live, two), written); + assert_eq!(mapped_blocks(&live, &root, two), written); let mut grown = written.clone(); grown.insert(fresh); - assert_eq!(mapped_blocks(&live, one), grown); + assert_eq!(mapped_blocks(&live, &root, one), grown); assert_eq!(pool.open_thin(&vol_name).unwrap().id(), one); assert_eq!(pool.open_thin(&snap_name).unwrap().id(), two); @@ -660,11 +683,13 @@ fn a_real_pools_ids_snapshots_and_dumped_mappings_obey_their_laws_as_root() { #[test] fn a_thin_over_an_external_origin_maps_only_what_diverged_as_root() { require_root!(); + let mut token = Unprivileged::take().unwrap(); + let root = token.elevate().unwrap(); if RootSafeBin::<"thin_dump">::open(Path::new(THIN_DUMP)).is_err() { eprintln!("SKIP: no root-owned {THIN_DUMP}"); return; } - let Some(mut live) = LivePool::new("ext") else { + let Some(mut live) = LivePool::new(&root, "ext") else { eprintln!("SKIP: dm-thin unavailable"); return; }; @@ -675,6 +700,7 @@ fn a_thin_over_an_external_origin_maps_only_what_diverged_as_root() { let origin_name = live.volume_name("origin"); live.dm .create( + &root, &origin_name, &DmTable::Linear(LinearTable { sectors: VOLUME_SECTORS, @@ -685,7 +711,7 @@ fn a_thin_over_an_external_origin_maps_only_what_diverged_as_root() { .unwrap(); let vol_name = live.volume_name("vol"); let id = ThinId::new(3).unwrap(); - let pool = live.dm.thin_pool(&live.pool).unwrap(); + let pool = live.dm.thin_pool(&root, &live.pool).unwrap(); let vol = pool .create_thin(id) .unwrap() @@ -701,14 +727,14 @@ fn a_thin_over_an_external_origin_maps_only_what_diverged_as_root() { vec![0x11; BLOCK_BYTES as usize] ); assert!( - mapped_blocks(&live, id).is_empty(), + mapped_blocks(&live, &root, id).is_empty(), "reads must not provision" ); write_block(vol.device().path().as_path(), 5, 0x22); write_block(vol.device().path().as_path(), VOLUME_BLOCKS - 1, 0x33); assert_eq!( - mapped_blocks(&live, id), + mapped_blocks(&live, &root, id), BTreeSet::from([5, VOLUME_BLOCKS - 1]) ); assert_eq!(