#[test]
fn guardian_preserves_payload_loader_controls_without_exposing_them_to_setup() {
let inherited = || vec![(OsString::from("LD_BIND_NOW"), OsString::from("1"))];
let mut command = Command::new("/bin/true");
let expected = (b"LD_BIND_NOW".to_vec(), Some(b"1".to_vec()));
assert_eq!(
payload_environment(&command, false, inherited()),
vec![expected]
);
assert!(payload_environment(&command, true, inherited()).is_empty());
command.env_remove("LD_BIND_NOW");
let removed = payload_environment(&command, false, inherited());
assert_eq!(removed.last(), Some(&(b"LD_BIND_NOW".to_vec(), None)));
let mut guardian = Command::new("/bin/true");
strip_sensitive_parent_env(&mut guardian, inherited());
assert_eq!(
guardian.get_envs().collect::<Vec<_>>(),
vec![(std::ffi::OsStr::new("LD_BIND_NOW"), None)]
);
}
use std::collections::BTreeMap;
use super::*;
use crate::process::{EnvMode, OutputCapture, OwnerDeathPolicy};
#[test]
fn relative_file_capture_keeps_the_callers_directory_when_payload_cwd_differs() {
let caller = std::env::current_dir().unwrap();
let root = tempfile::tempdir_in(&caller).unwrap();
let payload = root.path().join("payload");
std::fs::create_dir(&payload).unwrap();
let relative = root.path().strip_prefix(&caller).unwrap();
let stdout_path = relative.join("stdout");
let stderr_path = relative.join("stderr");
std::fs::write(&stdout_path, "parent stdout").unwrap();
std::fs::write(&stderr_path, "parent stderr").unwrap();
std::fs::create_dir_all(payload.join(relative)).unwrap();
std::fs::write(payload.join(&stdout_path), "payload stdout untouched").unwrap();
std::fs::write(payload.join(&stderr_path), "payload stderr untouched").unwrap();
let mut process = crate::process::default_spawner()
.spawn(SpawnSpec {
builtin: "relative_capture_control",
program: "/bin/pwd".to_string(),
args: Vec::new(),
cwd: Some(payload.clone()),
env: BTreeMap::new(),
env_remove: Vec::new(),
env_mode: EnvMode::Replace,
use_stdin: false,
configure_process_group: true,
owner_death: OwnerDeathPolicy::KillContainment,
output_capture: OutputCapture::File {
stdout_path: stdout_path.clone(),
stderr_path: stderr_path.clone(),
},
})
.unwrap();
assert_eq!(process.wait().unwrap().code, Some(0));
assert_eq!(
std::fs::read_to_string(&stdout_path).unwrap(),
format!("{}\n", payload.canonicalize().unwrap().display())
);
assert!(std::fs::read(&stderr_path).unwrap().is_empty());
assert_eq!(
std::fs::read_to_string(payload.join(stdout_path)).unwrap(),
"payload stdout untouched"
);
assert_eq!(
std::fs::read_to_string(payload.join(stderr_path)).unwrap(),
"payload stderr untouched"
);
}
#[cfg(target_os = "linux")]
#[test]
fn guardian_request_refuses_overlapping_descriptor_custody_without_closing_the_descriptor() {
use std::os::fd::AsRawFd;
let retained = tempfile::tempfile().unwrap();
let descriptor = retained.as_raw_fd();
let mut request = GuardianCommandRequest::from_command(
&Command::new("/usr/bin/true"),
true,
"duplicate-descriptor-control".to_string(),
Some(GuardianConfinement::Bubblewrap {
descriptors: vec![descriptor],
}),
false,
);
request.pinned_verifier_descriptors = vec![descriptor];
let request: GuardianCommandRequest =
serde_json::from_slice(&serde_json::to_vec(&request).unwrap()).unwrap();
let Err(error) = (unsafe { PreparedCommand::from_inherited_request(request) }) else {
panic!("a cross-set duplicate must never construct a payload command");
};
assert!(error
.to_string()
.contains("repeated confinement descriptor"));
retained
.metadata()
.expect("refused wire input must not close an existing descriptor");
}
#[cfg(target_os = "linux")]
#[test]
fn guardian_request_refuses_verifier_aliases_of_the_reserved_ruleset_role() {
for confinement in [
GuardianConfinement::BeforeExec {
seccomp: Vec::new(),
ruleset: true,
},
GuardianConfinement::AfterNamespace { ruleset: true },
] {
let mut request = GuardianCommandRequest::from_command(
&Command::new("/usr/bin/true"),
true,
"ruleset-alias-control".to_string(),
Some(confinement),
false,
);
request.pinned_verifier_descriptors = vec![RULESET_FD];
let request: GuardianCommandRequest =
serde_json::from_slice(&serde_json::to_vec(&request).unwrap()).unwrap();
let error = unsafe { PreparedCommand::from_inherited_request(request) }
.err()
.expect("the ruleset role cannot also be verifier material");
assert!(error
.to_string()
.contains("repeated confinement descriptor"));
}
}
#[cfg(target_os = "linux")]
#[test]
fn guardian_request_refuses_invalid_inherited_descriptors() {
for descriptor in [-1, 0, 1, 2, i32::MAX] {
for verifier in [false, true] {
let mut request = GuardianCommandRequest::from_command(
&Command::new("/usr/bin/true"),
true,
"invalid-descriptor-control".to_string(),
None,
false,
);
if verifier {
request.pinned_verifier_descriptors = vec![descriptor];
} else {
request.confinement = Some(GuardianConfinement::Bubblewrap {
descriptors: vec![descriptor],
});
}
let request: GuardianCommandRequest =
serde_json::from_slice(&serde_json::to_vec(&request).unwrap()).unwrap();
assert!(unsafe { PreparedCommand::from_inherited_request(request) }.is_err());
}
}
}
#[test]
fn guardian_request_keeps_explicit_credentials_out_of_argv_and_env() {
let _environment = crate::process::test_support::declare_inherited();
let canary = "guardian-request-pipe-canary";
let spec = SpawnSpec {
builtin: "guardian_request_test",
program: "/usr/bin/env".to_string(),
args: Vec::new(),
cwd: None,
env: BTreeMap::from([("EXAMPLE_API_KEY".to_string(), canary.to_string())]),
env_remove: Vec::new(),
env_mode: EnvMode::Patch,
use_stdin: false,
configure_process_group: true,
owner_death: OwnerDeathPolicy::KillContainment,
output_capture: OutputCapture::Pipe,
};
let cleanup_token = harn_vm::op_interrupt::new_process_cleanup_token();
let PreparedGuardian {
command: guardian,
request,
..
} = prepare_guardian(&spec, cleanup_token.clone()).expect("prepare guardian");
harn_vm::op_interrupt::remove_process_owner_group_journal(&cleanup_token);
let decoded: GuardianCommandRequest =
serde_json::from_slice(&request).expect("decode private guardian request");
assert!(
decoded.env.iter().any(|(key, value)| {
key.as_slice() == b"EXAMPLE_API_KEY" && value.as_deref() == Some(canary.as_bytes())
}),
"the private request must still carry the explicit child credential"
);
assert!(
guardian
.get_args()
.all(|arg| !arg.to_string_lossy().contains(canary)),
"the guardian argv must not carry child credentials"
);
assert!(
guardian.get_envs().all(|(key, value)| {
!key.to_string_lossy().contains(canary)
&& !value.is_some_and(|value| value.to_string_lossy().contains(canary))
}),
"the guardian environment must not carry child credentials"
);
}
#[test]
fn guardian_scrubs_sensitive_values_inherited_from_its_parent() {
let mut guardian = Command::new("/usr/bin/true");
strip_sensitive_parent_env(
&mut guardian,
[
(
OsString::from("EXAMPLE_API_KEY"),
OsString::from("secret-canary"),
),
(OsString::from("PATH"), OsString::from("/usr/bin")),
(OsString::from("LD_BIND_NOW"), OsString::from("1")),
],
);
let env = guardian.get_envs().collect::<Vec<_>>();
assert!(env.iter().any(|(key, value)| *key == OsStr::new("LD_BIND_NOW") && value.is_none()),
"trusted guardian setup removes parent loader controls while the payload environment remains in its pipe request");
assert!(
env.iter()
.any(|(key, value)| { *key == OsStr::new("EXAMPLE_API_KEY") && value.is_none() }),
"the guardian must remove inherited credentials before re-exec"
);
assert!(
env.iter().all(|(key, _)| *key != OsStr::new("PATH")),
"the guardian must preserve ordinary inherited environment"
);
}