use std::ffi::OsString;
use std::path::{Path, PathBuf};
use std::process::{Command as StdCommand, Stdio};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SandboxBackend {
Bwrap,
Firejail,
}
pub const ALL_BACKENDS: [SandboxBackend; 2] = [SandboxBackend::Bwrap, SandboxBackend::Firejail];
impl SandboxBackend {
pub fn binary(self) -> &'static str {
match self {
SandboxBackend::Bwrap => "bwrap",
SandboxBackend::Firejail => "firejail",
}
}
pub fn parse(value: &str) -> Option<Self> {
match value.trim().to_ascii_lowercase().as_str() {
"bwrap" | "bubblewrap" => Some(SandboxBackend::Bwrap),
"firejail" | "fj" => Some(SandboxBackend::Firejail),
_ => None,
}
}
pub fn is_off(value: &str) -> bool {
matches!(
value.trim().to_ascii_lowercase().as_str(),
"off" | "none" | "no" | "false" | "0" | "disabled"
)
}
pub fn is_auto(value: &str) -> bool {
matches!(
value.trim().to_ascii_lowercase().as_str(),
"" | "auto" | "detect" | "yes" | "true" | "1" | "enabled"
)
}
}
impl std::fmt::Display for SandboxBackend {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.binary())
}
}
#[derive(Debug, Clone, Default)]
pub struct SandboxOptions {
pub read_only_paths: Vec<PathBuf>,
pub read_write_paths: Vec<PathBuf>,
pub home: Option<PathBuf>,
pub cargo_home: Option<PathBuf>,
pub rustup_home: Option<PathBuf>,
pub cargo_bin: Option<PathBuf>,
}
impl SandboxOptions {
pub fn home(&self) -> Option<&Path> {
self.home.as_deref()
}
}
#[derive(Debug, Clone)]
pub struct Sandbox {
backend: SandboxBackend,
workspace: PathBuf,
options: SandboxOptions,
symlinks: Vec<(PathBuf, PathBuf)>,
resolv_conf: Option<PathBuf>,
}
fn resolv_conf_target_at(link_path: &Path) -> Option<PathBuf> {
if !std::fs::symlink_metadata(link_path)
.ok()?
.file_type()
.is_symlink()
{
return None;
}
let target = std::fs::read_link(link_path).ok()?;
let absolute = if target.is_absolute() {
target
} else {
link_path.parent()?.join(target)
};
let resolved = normalize_existing(&absolute)?;
let etc = link_path.parent()?.canonicalize().ok()?;
if resolved.starts_with(&etc) || !resolved.is_file() {
return None;
}
Some(resolved)
}
fn resolv_conf_target() -> Option<PathBuf> {
resolv_conf_target_at(Path::new("/etc/resolv.conf"))
}
fn normalize_existing(path: &Path) -> Option<PathBuf> {
path.exists().then(|| path.canonicalize().ok()).flatten()
}
fn is_symlink_to(path: &Path, target: &str) -> bool {
std::fs::symlink_metadata(path)
.map(|m| m.file_type().is_symlink())
.unwrap_or(false)
&& std::fs::read_link(path)
.map(|t| t == Path::new(target))
.unwrap_or(false)
}
impl Sandbox {
pub fn new(
backend: SandboxBackend,
workspace: &Path,
options: SandboxOptions,
) -> Result<Self, String> {
let canonical = workspace.canonicalize().map_err(|e| {
format!(
"Failed to canonicalize sandbox workspace '{}': {}",
workspace.display(),
e
)
})?;
if !canonical.is_dir() {
return Err(format!(
"Sandbox workspace '{}' is not a directory",
workspace.display()
));
}
let symlinks = match backend {
SandboxBackend::Bwrap => [
("/bin", "usr/bin"),
("/sbin", "usr/sbin"),
("/lib", "usr/lib"),
("/lib64", "usr/lib64"),
]
.iter()
.filter(|(link, target)| is_symlink_to(Path::new(link), target))
.map(|(link, target)| (PathBuf::from(*link), PathBuf::from(*target)))
.collect(),
SandboxBackend::Firejail => Vec::new(),
};
let resolv_conf = match backend {
SandboxBackend::Bwrap => resolv_conf_target(),
SandboxBackend::Firejail => None,
};
let mut options = options;
options.read_only_paths = options
.read_only_paths
.iter()
.filter_map(|p| p.canonicalize().ok())
.collect();
options.read_write_paths = options
.read_write_paths
.iter()
.filter_map(|p| p.canonicalize().ok())
.collect();
Ok(Self {
backend,
workspace: canonical,
options,
symlinks,
resolv_conf,
})
}
pub fn backend(&self) -> SandboxBackend {
self.backend
}
pub fn workspace(&self) -> &Path {
&self.workspace
}
pub fn options(&self) -> &SandboxOptions {
&self.options
}
pub fn locate(backend: SandboxBackend) -> Option<PathBuf> {
let exe = format!("{}{}", backend.binary(), std::env::consts::EXE_SUFFIX);
let path = std::env::var_os("PATH")?;
for dir in std::env::split_paths(&path) {
if dir.as_os_str().is_empty() {
continue;
}
let candidate = dir.join(&exe);
if candidate.is_file() {
return Some(candidate);
}
}
None
}
pub fn available() -> Vec<SandboxBackend> {
ALL_BACKENDS
.into_iter()
.filter(|b| Self::locate(*b).is_some())
.collect()
}
pub fn detect(workspace: &Path, options: SandboxOptions) -> Result<Self, String> {
match Self::available().first().copied() {
Some(backend) => Self::new(backend, workspace, options),
None => Err(
"No sandbox backend found. Install bubblewrap (`bwrap`) or firejail, \
or start with --no-sandbox to run shell commands unsandboxed."
.to_string(),
),
}
}
pub fn from_setting(
value: &str,
workspace: &Path,
options: SandboxOptions,
) -> Result<Self, String> {
if SandboxBackend::is_off(value) {
return Err(format!(
"sandbox backend '{value}' disables sandboxing — nothing to build"
));
}
if SandboxBackend::is_auto(value) {
return Self::detect(workspace, options);
}
let backend = SandboxBackend::parse(value).ok_or_else(|| {
format!("Unknown sandbox backend '{value}'. Valid values: auto, bwrap, firejail, off")
})?;
if Self::locate(backend).is_none() {
return Err(format!(
"'{backend}' is not installed or not on PATH. \
Available: {}.",
if Self::available().is_empty() {
"none".to_string()
} else {
Self::available()
.into_iter()
.map(|b| b.to_string())
.collect::<Vec<_>>()
.join(", ")
}
));
}
Self::new(backend, workspace, options)
}
pub fn argv(&self, command: &str, cwd: Option<&Path>) -> (PathBuf, Vec<OsString>) {
self.argv_with_env(command, cwd, &[])
}
pub fn argv_with_env(
&self,
command: &str,
cwd: Option<&Path>,
extra: &[(String, String)],
) -> (PathBuf, Vec<OsString>) {
let program =
Self::locate(self.backend).unwrap_or_else(|| PathBuf::from(self.backend.binary()));
let mut args: Vec<OsString> = match self.backend {
SandboxBackend::Bwrap => self.bwrap_args(cwd, extra),
SandboxBackend::Firejail => self.firejail_args(),
};
args.push(OsString::from("/bin/sh"));
args.push(OsString::from("-c"));
args.push(OsString::from(command));
(program, args)
}
fn bwrap_args(&self, cwd: Option<&Path>, extra_env: &[(String, String)]) -> Vec<OsString> {
let mut a: Vec<OsString> = vec![
os("--unshare-user"),
os("--unshare-ipc"),
os("--unshare-pid"),
os("--unshare-uts"),
os("--unshare-cgroup"),
os("--die-with-parent"),
os("--new-session"),
os("--clearenv"),
os("--tmpfs"),
os("/"),
os("--tmpfs"),
os("/tmp"),
os("--proc"),
os("/proc"),
os("--dev"),
os("/dev"),
];
a.extend(bind_ro(Path::new("/usr")));
a.extend(bind_ro(Path::new("/etc")));
if let Some(resolv) = self.resolv_conf.as_deref() {
a.push(os("--ro-bind-try"));
a.push(resolv.as_os_str().to_owned());
a.push(resolv.as_os_str().to_owned());
}
for (link, target) in &self.symlinks {
a.push(os("--symlink"));
a.push(target.as_os_str().to_owned());
a.push(link.as_os_str().to_owned());
}
if let Some(bin) = self.options.cargo_bin.as_deref() {
a.extend(bind_ro(bin));
}
if let Some(rustup) = self.options.rustup_home.as_deref() {
a.extend(bind_ro(rustup));
}
if let Some(cargo_home) = self.options.cargo_home.as_deref() {
a.extend(bind_rw(cargo_home));
}
for p in &self.options.read_only_paths {
a.extend(bind_ro(p));
}
for p in &self.options.read_write_paths {
a.extend(bind_rw(p));
}
a.extend(bind_rw(&self.workspace));
for (key, value) in self.environment() {
a.push(os("--setenv"));
a.push(os(&key));
a.push(OsString::from(value));
}
for (key, value) in extra_env {
a.push(os("--setenv"));
a.push(os(key));
a.push(OsString::from(value));
}
a.push(os("--chdir"));
a.push(match cwd {
Some(dir) if dir.is_absolute() => OsString::from(dir.as_os_str()),
Some(dir) => OsString::from(self.workspace.join(dir).as_os_str()),
None => self.workspace.as_os_str().to_owned(),
});
a
}
fn firejail_args(&self) -> Vec<OsString> {
let mut a: Vec<OsString> = vec![
os("--noprofile"),
os("--quiet"),
os("--read-only"),
os("/"),
os(&format!("--bind={}", self.workspace.display())),
os("--caps.drop=all"),
os("--nonewprivs"),
os("--nogroups"),
os("--seccomp"),
os("--disable-mnt"),
];
for p in &self.options.read_only_paths {
if is_usable_dir(p) {
a.push(os(&format!("--bind-ro={}", p.display())));
}
}
for p in &self.options.read_write_paths {
if is_usable_dir(p) {
a.push(os(&format!("--bind={}", p.display())));
}
}
a
}
fn environment(&self) -> Vec<(String, String)> {
let mut out = Vec::new();
let host_path = std::env::var_os("PATH")
.map(PathBuf::from)
.unwrap_or_default();
let mut dirs: Vec<PathBuf> = Vec::new();
if let Some(bin) = self
.options
.cargo_bin
.as_deref()
.filter(|p| is_usable_dir(p))
{
dirs.push(bin.to_path_buf());
}
dirs.extend(std::env::split_paths(&host_path));
dirs.push(PathBuf::from("/usr/bin"));
dirs.push(PathBuf::from("/bin"));
out.push((
"PATH".to_string(),
std::env::join_paths(&dirs)
.map(|p| p.to_string_lossy().into_owned())
.unwrap_or_else(|_| "/usr/bin:/bin".to_string()),
));
for (key, value) in [
("HOME", self.options.home.as_deref()),
("CARGO_HOME", self.options.cargo_home.as_deref()),
("RUSTUP_HOME", self.options.rustup_home.as_deref()),
] {
if let Some(v) = value.filter(|p| is_usable_dir(p)) {
out.push((key.to_string(), v.to_string_lossy().into_owned()));
}
}
for key in ["LANG", "LC_ALL", "LC_CTYPE", "TERM"] {
if let Some(value) = std::env::var_os(key) {
out.push((key.to_string(), value.to_string_lossy().into_owned()));
}
}
out
}
pub fn probe(&self) -> Result<(), String> {
let (program, args) = self.argv("true", None);
let output = StdCommand::new(&program)
.args(&args)
.stdin(Stdio::null())
.output()
.map_err(|e| format!("Failed to run {}: {e}", program.display()))?;
if output.status.success() {
Ok(())
} else {
Err(format!(
"{} exited with {}: {}",
program.display(),
output.status.code().unwrap_or(-1),
String::from_utf8_lossy(&output.stderr).trim()
))
}
}
}
fn os(value: &str) -> OsString {
OsString::from(value)
}
fn is_usable_dir(path: &Path) -> bool {
path.is_dir()
}
fn bind_ro(path: &Path) -> Vec<OsString> {
if !is_usable_dir(path) {
return Vec::new();
}
vec![
os("--ro-bind"),
path.as_os_str().to_owned(),
path.as_os_str().to_owned(),
]
}
fn bind_rw(path: &Path) -> Vec<OsString> {
if !is_usable_dir(path) {
return Vec::new();
}
vec![
os("--bind"),
path.as_os_str().to_owned(),
path.as_os_str().to_owned(),
]
}
#[cfg(all(test, unix))]
mod tests {
use super::*;
fn sandbox_in(tmp: &Path, options: SandboxOptions) -> Sandbox {
Sandbox::new(SandboxBackend::Bwrap, tmp, options).unwrap()
}
#[test]
fn backend_parsing() {
assert_eq!(SandboxBackend::parse("bwrap"), Some(SandboxBackend::Bwrap));
assert_eq!(
SandboxBackend::parse("Bubblewrap"),
Some(SandboxBackend::Bwrap)
);
assert_eq!(
SandboxBackend::parse("Firejail"),
Some(SandboxBackend::Firejail)
);
assert_eq!(SandboxBackend::parse("auto"), None);
assert_eq!(SandboxBackend::parse("off"), None);
assert!(SandboxBackend::is_off("OFF"));
assert!(SandboxBackend::is_off("none"));
assert!(SandboxBackend::is_auto("auto"));
assert!(SandboxBackend::is_auto(""));
assert!(!SandboxBackend::is_auto("bwrap"));
assert!(!SandboxBackend::is_off("bwrap"));
assert_eq!(SandboxBackend::Bwrap.to_string(), "bwrap");
assert_eq!(SandboxBackend::Firejail.to_string(), "firejail");
}
#[test]
fn resolv_conf_target_follows_a_link_out_of_etc() {
let tmp = tempfile::tempdir().unwrap();
let etc = tmp.path().join("etc");
let run = tmp.path().join("run/systemd/resolve");
std::fs::create_dir_all(&etc).unwrap();
std::fs::create_dir_all(&run).unwrap();
let real = run.join("stub-resolv.conf");
std::fs::write(&real, "nameserver 127.0.0.53\n").unwrap();
std::os::unix::fs::symlink(&real, etc.join("resolv.conf")).unwrap();
assert_eq!(
resolv_conf_target_at(&etc.join("resolv.conf")),
Some(real.canonicalize().unwrap())
);
}
#[test]
fn resolv_conf_target_resolves_relative_links_against_etc() {
let tmp = tempfile::tempdir().unwrap();
let etc = tmp.path().join("etc");
let run = tmp.path().join("run/systemd/resolve");
std::fs::create_dir_all(&etc).unwrap();
std::fs::create_dir_all(&run).unwrap();
std::fs::write(run.join("stub-resolv.conf"), "nameserver 1.1.1.1\n").unwrap();
std::os::unix::fs::symlink(
"../run/systemd/resolve/stub-resolv.conf",
etc.join("resolv.conf"),
)
.unwrap();
let got = resolv_conf_target_at(&etc.join("resolv.conf")).unwrap();
assert_eq!(got, run.join("stub-resolv.conf").canonicalize().unwrap());
}
#[test]
fn resolv_conf_target_is_none_for_plain_files_and_internal_links() {
let tmp = tempfile::tempdir().unwrap();
let etc = tmp.path().join("etc");
std::fs::create_dir_all(&etc).unwrap();
let plain = etc.join("resolv.conf");
std::fs::write(&plain, "nameserver 8.8.8.8\n").unwrap();
assert_eq!(resolv_conf_target_at(&plain), None);
std::fs::write(etc.join("other.conf"), "nameserver 9.9.9.9\n").unwrap();
let internal = etc.join("resolv-link.conf");
std::os::unix::fs::symlink("other.conf", &internal).unwrap();
assert_eq!(resolv_conf_target_at(&internal), None);
let dangling = etc.join("resolv-dangling.conf");
std::os::unix::fs::symlink("/no/such/resolv.conf", &dangling).unwrap();
assert_eq!(resolv_conf_target_at(&dangling), None);
assert_eq!(resolv_conf_target_at(&etc.join("nope.conf")), None);
}
#[test]
fn bwrap_binds_dns_config_when_resolv_conf_is_a_link() {
let tmp = tempfile::tempdir().unwrap();
let sb = sandbox_in(tmp.path(), SandboxOptions::default());
let (_, args) = sb.argv("true", None);
let flat: Vec<String> = args
.iter()
.map(|a| a.to_string_lossy().into_owned())
.collect();
match resolv_conf_target() {
Some(target) => {
let t = target.to_string_lossy().into_owned();
assert!(
flat.windows(3)
.any(|w| w[0] == "--ro-bind-try" && w[1] == t && w[2] == t),
"DNS config {t} not bound: {flat:?}"
);
assert!(
!flat
.windows(3)
.any(|w| w[0] == "--ro-bind-try" && w[1] == "/etc/resolv.conf"),
"must not mount onto the /etc/resolv.conf symlink: {flat:?}"
);
}
None => assert!(
!flat.iter().any(|a| a == "--ro-bind-try"),
"no extra DNS bind expected on this host: {flat:?}"
),
}
}
#[test]
fn firejail_gets_no_dns_bind() {
let tmp = tempfile::tempdir().unwrap();
let sb = Sandbox::new(
SandboxBackend::Firejail,
tmp.path(),
SandboxOptions::default(),
)
.unwrap();
assert!(
sb.resolv_conf.is_none(),
"firejail must not carry DNS state"
);
let (_, args) = sb.argv("true", None);
let flat: Vec<String> = args
.iter()
.map(|a| a.to_string_lossy().into_owned())
.collect();
assert!(
!flat.iter().any(|a| a == "--ro-bind-try"),
"unexpected bwrap flag: {flat:?}"
);
}
#[test]
fn new_requires_existing_workspace_dir() {
let err = Sandbox::new(
SandboxBackend::Bwrap,
Path::new("/definitely/not/a/real/dir"),
SandboxOptions::default(),
)
.unwrap_err();
assert!(
err.contains("canonicalize") || err.contains("directory"),
"{err}"
);
}
#[test]
fn workspace_is_canonicalized() {
let tmp = tempfile::tempdir().unwrap();
let sb = sandbox_in(tmp.path(), SandboxOptions::default());
assert_eq!(sb.workspace(), tmp.path().canonicalize().unwrap());
assert_eq!(sb.backend(), SandboxBackend::Bwrap);
}
#[test]
fn bwrap_argv_contains_the_containment_flags() {
let tmp = tempfile::tempdir().unwrap();
let sb = sandbox_in(tmp.path(), SandboxOptions::default());
let (program, args) = sb.argv("echo hi", None);
let flat: Vec<String> = args
.iter()
.map(|a| a.to_string_lossy().into_owned())
.collect();
assert_eq!(program.file_name().unwrap(), "bwrap");
assert_eq!(flat.last().map(|s| s.as_str()), Some("echo hi"));
assert_eq!(flat[flat.len() - 3], "/bin/sh");
assert_eq!(flat[flat.len() - 2], "-c");
for flag in [
"--unshare-user",
"--unshare-pid",
"--unshare-ipc",
"--unshare-uts",
"--unshare-cgroup",
"--die-with-parent",
"--new-session",
"--clearenv",
"--tmpfs",
"--proc",
"--dev",
"--chdir",
] {
assert!(flat.iter().any(|a| a == flag), "missing {flag}: {flat:?}");
}
for flag in ["--unshare-net", "--net=none"] {
assert!(
!flat.iter().any(|a| a == flag),
"unexpected {flag}: {flat:?}"
);
}
assert!(!flat.windows(2).any(|w| w[0] == "--ro-bind" && w[1] == "/"));
assert!(!flat.windows(2).any(|w| w[0] == "--bind" && w[1] == "/"));
assert!(
flat.windows(3)
.any(|w| w[0] == "--ro-bind" && w[1] == "/usr")
);
assert!(
flat.windows(3)
.any(|w| w[0] == "--ro-bind" && w[1] == "/etc")
);
let ws = tmp
.path()
.canonicalize()
.unwrap()
.to_string_lossy()
.into_owned();
let last_bind = flat
.iter()
.rposition(|a| a == "--bind")
.expect("no rw bind");
assert_eq!(flat[last_bind + 1], ws);
assert_eq!(flat[last_bind + 2], ws);
}
#[test]
fn bwrap_chdir_follows_explicit_cwd() {
let tmp = tempfile::tempdir().unwrap();
let sub = tmp.path().canonicalize().unwrap().join("sub");
std::fs::create_dir(&sub).unwrap();
let sb = sandbox_in(tmp.path(), SandboxOptions::default());
let (_, args) = sb.argv("true", Some(&sub));
let flat: Vec<String> = args
.iter()
.map(|a| a.to_string_lossy().into_owned())
.collect();
let idx = flat.iter().rposition(|a| a == "--chdir").unwrap();
assert_eq!(flat[idx + 1], sub.to_string_lossy());
}
#[test]
fn bwrap_binds_extra_paths() {
let tmp = tempfile::tempdir().unwrap();
let ro = tempfile::tempdir().unwrap();
let rw = tempfile::tempdir().unwrap();
let sb = sandbox_in(
tmp.path(),
SandboxOptions {
read_only_paths: vec![ro.path().to_path_buf()],
read_write_paths: vec![rw.path().to_path_buf()],
..SandboxOptions::default()
},
);
let (_, args) = sb.argv("true", None);
let flat: Vec<String> = args
.iter()
.map(|a| a.to_string_lossy().into_owned())
.collect();
let ro_s = ro
.path()
.canonicalize()
.unwrap()
.to_string_lossy()
.into_owned();
let rw_s = rw
.path()
.canonicalize()
.unwrap()
.to_string_lossy()
.into_owned();
assert!(flat.windows(3).any(|w| w[0] == "--ro-bind" && w[1] == ro_s));
assert!(flat.windows(3).any(|w| w[0] == "--bind" && w[1] == rw_s));
}
#[test]
fn missing_bind_targets_are_skipped() {
let tmp = tempfile::tempdir().unwrap();
let ghost = Path::new("/no/such/dir/anywhere");
let sb = sandbox_in(
tmp.path(),
SandboxOptions {
read_only_paths: vec![ghost.to_path_buf()],
cargo_home: Some(ghost.to_path_buf()),
..SandboxOptions::default()
},
);
let (_, args) = sb.argv("true", None);
let flat: Vec<String> = args
.iter()
.map(|a| a.to_string_lossy().into_owned())
.collect();
assert!(
!flat.iter().any(|a| a == "/no/such/dir/anywhere"),
"{flat:?}"
);
}
#[test]
fn environment_is_a_whitelist() {
let tmp = tempfile::tempdir().unwrap();
let home = tempfile::tempdir().unwrap();
let cargo_home = tempfile::tempdir().unwrap();
let rustup = tempfile::tempdir().unwrap();
let bin = tempfile::tempdir().unwrap();
let sb = sandbox_in(
tmp.path(),
SandboxOptions {
home: Some(home.path().to_path_buf()),
cargo_home: Some(cargo_home.path().to_path_buf()),
rustup_home: Some(rustup.path().to_path_buf()),
cargo_bin: Some(bin.path().to_path_buf()),
..SandboxOptions::default()
},
);
let env = sb.environment();
let keys: Vec<&str> = env.iter().map(|(k, _)| k.as_str()).collect();
assert!(keys.contains(&"PATH"));
assert!(keys.contains(&"HOME"));
assert!(keys.contains(&"CARGO_HOME"));
assert!(keys.contains(&"RUSTUP_HOME"));
for key in keys.iter() {
assert!(
matches!(
*key,
"PATH"
| "HOME"
| "CARGO_HOME"
| "RUSTUP_HOME"
| "LANG"
| "LC_ALL"
| "LC_CTYPE"
| "TERM"
),
"unexpected env var leaked into sandbox: {key}"
);
}
let path = env.iter().find(|(k, _)| k == "PATH").unwrap().1.clone();
assert!(
path.starts_with(&bin.path().to_string_lossy().to_string()),
"{path}"
);
}
#[test]
fn environment_omits_unbound_toolchain_paths() {
let tmp = tempfile::tempdir().unwrap();
let sb = sandbox_in(
tmp.path(),
SandboxOptions {
cargo_home: Some(PathBuf::from("/no/such/cargo/home")),
cargo_bin: Some(PathBuf::from("/no/such/bin")),
..SandboxOptions::default()
},
);
let env = sb.environment();
let keys: Vec<&str> = env.iter().map(|(k, _)| k.as_str()).collect();
assert!(!keys.contains(&"CARGO_HOME"), "{keys:?}");
assert!(!keys.contains(&"RUSTUP_HOME"), "{keys:?}");
let path = env.iter().find(|(k, _)| k == "PATH").unwrap().1.clone();
assert!(!path.contains("/no/such/bin"), "{path}");
}
#[test]
fn home_is_never_bound_but_nested_paths_are() {
let tmp = tempfile::tempdir().unwrap();
let home = tempfile::tempdir().unwrap();
let nested = home.path().join(".local/share/data");
std::fs::create_dir_all(&nested).unwrap();
let sb = sandbox_in(
tmp.path(),
SandboxOptions {
home: Some(home.path().to_path_buf()),
read_only_paths: vec![nested.clone()],
..SandboxOptions::default()
},
);
let (_, args) = sb.argv("true", None);
let flat: Vec<String> = args
.iter()
.map(|a| a.to_string_lossy().into_owned())
.collect();
let home_s = home
.path()
.canonicalize()
.unwrap()
.to_string_lossy()
.into_owned();
assert!(
!flat.windows(3).any(|w| w[1] == home_s && w[2] == home_s),
"$HOME itself must never be bound: {flat:?}"
);
let nested_s = nested
.canonicalize()
.unwrap()
.to_string_lossy()
.into_owned();
assert!(
flat.windows(3)
.any(|w| w[0] == "--ro-bind" && w[1] == nested_s),
"nested allowed path was not bound: {flat:?}"
);
}
#[test]
fn extra_env_reaches_the_sandboxed_shell() {
let tmp = tempfile::tempdir().unwrap();
let sb = sandbox_in(tmp.path(), SandboxOptions::default());
let extra = [("TH_QUERY".to_string(), "hello world".to_string())];
let (_, args) = sb.argv_with_env("echo $TH_QUERY", None, &extra);
let flat: Vec<String> = args
.iter()
.map(|a| a.to_string_lossy().into_owned())
.collect();
let idx = flat
.iter()
.position(|a| a == "TH_QUERY")
.expect("TH_QUERY not passed through");
assert_eq!(flat[idx - 1], "--setenv");
assert_eq!(flat[idx + 1], "hello world");
assert_eq!(flat[flat.len() - 3], "/bin/sh");
assert_eq!(flat[flat.len() - 2], "-c");
assert_eq!(flat[flat.len() - 1], "echo $TH_QUERY");
}
#[test]
fn firejail_argv_shapes_expected_options() {
let tmp = tempfile::tempdir().unwrap();
let sb = Sandbox::new(
SandboxBackend::Firejail,
tmp.path(),
SandboxOptions::default(),
)
.unwrap();
let (program, args) = sb.argv("ls", None);
let flat: Vec<String> = args
.iter()
.map(|a| a.to_string_lossy().into_owned())
.collect();
assert_eq!(program.file_name().unwrap(), "firejail");
let ws = tmp
.path()
.canonicalize()
.unwrap()
.to_string_lossy()
.into_owned();
assert!(flat.contains(&format!("--bind={ws}")), "{flat:?}");
for flag in [
"--noprofile",
"--read-only",
"--caps.drop=all",
"--seccomp",
"--nogroups",
] {
assert!(flat.iter().any(|a| a == flag), "missing {flag}");
}
assert_eq!(flat.last().map(|s| s.as_str()), Some("ls"));
assert!(!flat.iter().any(|a| a == "--ro-bind"));
assert!(
!flat.iter().any(|a| a == "--net=none"),
"firejail must not block the network: {flat:?}"
);
}
#[test]
fn available_backends_are_locatable() {
let avail = Sandbox::available();
for backend in &avail {
assert!(Sandbox::locate(*backend).is_some());
}
if avail.len() == ALL_BACKENDS.len() {
assert_eq!(avail, ALL_BACKENDS.to_vec());
}
}
#[test]
fn detect_either_succeeds_or_explains_itself() {
let tmp = tempfile::tempdir().unwrap();
match Sandbox::detect(tmp.path(), SandboxOptions::default()) {
Ok(sb) => assert!(
ALL_BACKENDS.contains(&sb.backend()),
"unexpected backend {:?}",
sb.backend()
),
Err(e) => assert!(
e.contains("bubblewrap") && e.contains("firejail"),
"unhelpful error: {e}"
),
}
}
#[test]
fn from_setting_honours_explicit_backend_and_rejects_off() {
let tmp = tempfile::tempdir().unwrap();
assert!(
Sandbox::from_setting("off", tmp.path(), SandboxOptions::default())
.unwrap_err()
.contains("disables sandboxing")
);
let err =
Sandbox::from_setting("docker", tmp.path(), SandboxOptions::default()).unwrap_err();
assert!(err.contains("Unknown sandbox backend"), "{err}");
assert!(err.contains("bwrap"), "{err}");
match Sandbox::from_setting("bwrap", tmp.path(), SandboxOptions::default()) {
Ok(sb) => assert_eq!(sb.backend(), SandboxBackend::Bwrap),
Err(e) => assert!(e.contains("not installed"), "{e}"),
}
let auto = Sandbox::from_setting("auto", tmp.path(), SandboxOptions::default());
assert_eq!(auto.is_ok(), !Sandbox::available().is_empty());
}
#[test]
fn symlink_detection_ignores_real_dirs_and_missing_paths() {
assert!(!is_symlink_to(Path::new("/definitely/missing"), "usr/bin"));
let tmp = tempfile::tempdir().unwrap();
assert!(!is_symlink_to(tmp.path(), "usr/bin"));
let rel = tmp.path().join("rel");
std::os::unix::fs::symlink("usr/bin", &rel).unwrap();
assert!(is_symlink_to(&rel, "usr/bin"));
assert!(!is_symlink_to(&rel, "usr/lib"));
let abs = tmp.path().join("abs");
std::os::unix::fs::symlink("/usr/bin", &abs).unwrap();
assert!(!is_symlink_to(&abs, "usr/bin"));
}
}