use std::{fs, io};
use nix::sched::{CloneFlags, unshare};
use nix::sys::wait::{WaitStatus, waitpid};
use nix::unistd::{ForkResult, fork, getgid, getuid, pipe, read, write};
use nlink::netlink::tc::NetemConfig;
use nlink::{Connection, Route};
use crate::Error;
use crate::hardening::{CgroupGuard, SeccompProfile, install_seccomp};
pub fn enter_unprivileged_net_namespace() -> Result<(), Error> {
let uid = getuid();
let gid = getgid();
unshare(CloneFlags::CLONE_NEWUSER | CloneFlags::CLONE_NEWNET).map_err(Error::Namespace)?;
write_proc_self("/proc/self/setgroups", "deny")?;
write_proc_self("/proc/self/uid_map", &format!("0 {uid} 1"))?;
write_proc_self("/proc/self/gid_map", &format!("0 {gid} 1"))?;
Ok(())
}
fn write_proc_self(path: &'static str, contents: &str) -> Result<(), Error> {
fs::write(path, contents).map_err(|source| Error::IdMap { path, source })
}
pub fn enter_sibling_net_namespace() -> Result<(), Error> {
unshare(CloneFlags::CLONE_NEWNET).map_err(Error::Namespace)
}
pub fn fork_and_enter<F>(child_fn: F) -> Result<i32, Error>
where
F: FnOnce() -> i32,
{
fork_and_enter_inner(None, None, None, child_fn)
}
pub fn fork_and_enter_with_chaos<F>(netem: NetemConfig, child_fn: F) -> Result<i32, Error>
where
F: FnOnce() -> i32,
{
fork_and_enter_inner(Some(netem), None, None, child_fn)
}
pub(crate) fn fork_and_enter_with_options<F>(
netem: Option<NetemConfig>,
seccomp: Option<SeccompProfile>,
cgroup: Option<&CgroupGuard>,
child_fn: F,
) -> Result<i32, Error>
where
F: FnOnce() -> i32,
{
fork_and_enter_inner(netem, seccomp, cgroup, child_fn)
}
fn fork_and_enter_inner<F>(
netem: Option<NetemConfig>,
seccomp: Option<SeccompProfile>,
cgroup: Option<&CgroupGuard>,
child_fn: F,
) -> Result<i32, Error>
where
F: FnOnce() -> i32,
{
let cgroup_ready = cgroup.map(|_| pipe().map_err(Error::Pipe)).transpose()?;
match unsafe { fork() }.map_err(Error::Fork)? {
ForkResult::Parent { child } => {
if let Some((ready_r, ready_w)) = cgroup_ready {
drop(ready_r);
let release_result = match cgroup {
Some(cgroup) => cgroup
.add_pid(child)
.and_then(|()| write(&ready_w, &[1u8]).map_err(Error::Pipe).map(|_| ())),
None => Err(Error::Cgroup(io::Error::other(
"cgroup readiness pipe was created without a cgroup",
))),
};
drop(ready_w);
if let Err(error) = release_result {
let _ = waitpid(child, None);
return Err(error);
}
}
match waitpid(child, None).map_err(Error::Wait)? {
WaitStatus::Exited(_, code) => Ok(code),
other => Err(Error::ChildTerminated(other)),
}
}
ForkResult::Child => {
if let Some((ready_r, ready_w)) = cgroup_ready {
drop(ready_w);
let mut ready = [0u8; 1];
if read(&ready_r, &mut ready).ok() != Some(1) {
std::process::exit(114);
}
}
let code = match enter_unprivileged_net_namespace() {
Ok(()) => match run_loopback_setup(netem) {
Ok(()) => match seccomp {
Some(profile) => match install_seccomp(profile) {
Ok(()) => child_fn(),
Err(_) => 114,
},
None => child_fn(),
},
Err(_) => 113,
},
Err(_) => 111,
};
std::process::exit(code);
}
}
}
fn run_loopback_setup(netem: Option<NetemConfig>) -> Result<(), Error> {
let runtime = tokio::runtime::Runtime::new().map_err(Error::Runtime)?;
runtime.block_on(configure_loopback(netem))
}
async fn configure_loopback(netem: Option<NetemConfig>) -> Result<(), Error> {
let conn = Connection::<Route>::new().map_err(Error::Netlink)?;
conn.set_link_up("lo").await.map_err(Error::Netlink)?;
if let Some(netem) = netem {
conn.apply_netem("lo", netem)
.await
.map_err(Error::Netlink)?;
}
Ok(())
}
#[cfg(test)]
mod tests {
use std::fs;
use super::*;
#[test]
fn fork_and_enter_creates_a_new_net_namespace() {
let parent_netns =
fs::read_link("/proc/self/ns/net").expect("read parent /proc/self/ns/net");
let exit_code = fork_and_enter(move || {
let uid_is_root = getuid().is_root();
let child_netns = match fs::read_link("/proc/self/ns/net") {
Ok(link) => link,
Err(_) => return 2,
};
let netns_changed = child_netns != parent_netns;
if uid_is_root && netns_changed { 0 } else { 3 }
})
.expect("fork_and_enter should run to completion");
assert_eq!(
exit_code, 0,
"child did not observe uid 0 in a distinct net namespace (exit code {exit_code})"
);
}
#[test]
fn fork_and_enter_brings_loopback_up() {
use std::net::UdpSocket;
let exit_code = fork_and_enter(|| {
let socket = match UdpSocket::bind("127.0.0.1:0") {
Ok(s) => s,
Err(_) => return 2,
};
let addr = match socket.local_addr() {
Ok(a) => a,
Err(_) => return 3,
};
if socket.send_to(b"ping", addr).is_err() {
return 4;
}
let mut buf = [0u8; 4];
match socket.recv_from(&mut buf) {
Ok((n, _)) if &buf[..n] == b"ping" => 0,
_ => 5,
}
})
.expect("fork_and_enter should run to completion");
assert_eq!(
exit_code, 0,
"loopback UDP send-to-self failed inside the sandbox (exit code {exit_code}) \
— lo is probably still down"
);
}
#[test]
fn fork_and_enter_with_chaos_applies_real_kernel_delay() {
use std::net::UdpSocket;
use std::time::{Duration, Instant};
use crate::chaos::NetemConfig;
let netem = NetemConfig::new().delay(Duration::from_millis(200)).build();
let exit_code = fork_and_enter_with_chaos(netem, || {
let socket = match UdpSocket::bind("127.0.0.1:0") {
Ok(s) => s,
Err(_) => return 2,
};
let addr = match socket.local_addr() {
Ok(a) => a,
Err(_) => return 3,
};
if socket
.set_read_timeout(Some(Duration::from_secs(5)))
.is_err()
{
return 4;
}
let start = Instant::now();
if socket.send_to(b"ping", addr).is_err() {
return 5;
}
let mut buf = [0u8; 4];
if socket.recv_from(&mut buf).is_err() {
return 6;
}
let elapsed = start.elapsed();
if elapsed >= Duration::from_millis(150) {
0
} else {
eprintln!("gateflow test: observed delay {elapsed:?}, expected >= 150ms");
7
}
})
.expect("fork_and_enter_with_chaos should run to completion");
assert_eq!(
exit_code, 0,
"did not observe the expected netem-induced delay (exit code {exit_code})"
);
}
}