Files
cflmy 4265231a14
CI / schema instance validation + consumers (push) Waiting to run
CI / runtime contract (macos-latest) (push) Waiting to run
CI / runtime contract (windows-latest) (push) Waiting to run
Linux strict security lane (G-C) / strict isolation escape matrix (push) Waiting to run
ci/woodpecker/push/woodpecker Pipeline was successful
CI / fmt + clippy + test (Linux x86_64) (push) Waiting to run
fix(portable): run the CLI on an 8 MiB thread and scope G3 tests
Windows gives the main thread 1 MiB, unlike Linux/macOS at 8 MiB. The bundled
regex self-test overflowed that stack even though the same document passed on
Linux, so run the CLI dispatch on an explicit 8 MiB thread on every platform.

The macOS package test compared a raw temp path with a canonicalized one; on
macOS /var is a symlink to /private/var. Compare canonical forms on both sides.

The adversarial security matrix is G3-only: ordinary cargo test --workspace on
a namespace-capable but non-disposable hosted runner turned G0 red. Make it
opt-in (MARQDO_REQUIRE_STRICT_SECURITY=1 for the G3 lane, or
MARQDO_RUN_STRICT_SECURITY=1 for a developer); the lane still requires the
mechanism and fails on a missing one.
2026-11-21 18:42:53 +08:00

328 lines
12 KiB
Rust

//! Adversarial Linux strict-isolation lane.
//!
//! These tests launch a native helper through the **same** `marqdo-sandbox`
//! supervisor used by `marqdo run --mode strict`, then exercise direct
//! syscalls for filesystem, network, process, privilege and resource escapes.
//!
//! They are **opt-in** so an ordinary `cargo test --workspace` on a
//! namespace-capable but non-disposable host does not become a false G0 gate.
//! Set `MARQDO_REQUIRE_STRICT_SECURITY=1` (the G-C lane does; a missing
//! mechanism then fails) or `MARQDO_RUN_STRICT_SECURITY=1` (developer opt-in;
//! an incapable host skips).
//!
//! The helper path can be supplied with `MARQDO_SECURITY_HELPER` (used when
//! running this test binary inside the disposable security VM). Otherwise the
//! test compiles `tests/security/escape_helper.c` with `cc`.
#![cfg(target_os = "linux")]
use std::ffi::OsString;
use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::OnceLock;
use std::time::Duration;
use marqdo_sandbox::{launch_strict_capture, probe, StrictHostCommand, StrictOutcome};
fn required() -> bool {
std::env::var("MARQDO_REQUIRE_STRICT_SECURITY")
.ok()
.as_deref()
== Some("1")
}
/// The adversarial matrix is G3-only. Ordinary `cargo test --workspace` on a
/// developer host or GitHub-hosted runner must not turn a namespace-capable but
/// non-disposable environment into a red G0 gate. The G3 lane sets
/// `MARQDO_REQUIRE_STRICT_SECURITY=1`; a developer can opt in with
/// `MARQDO_RUN_STRICT_SECURITY=1`.
fn enabled() -> bool {
required() || std::env::var("MARQDO_RUN_STRICT_SECURITY").ok().as_deref() == Some("1")
}
/// Compile the escape helper exactly once even when the test binary runs its
/// tests in parallel.
fn helper() -> Option<PathBuf> {
static HELPER: OnceLock<Option<PathBuf>> = OnceLock::new();
HELPER
.get_or_init(|| {
if let Ok(path) = std::env::var("MARQDO_SECURITY_HELPER") {
let path = PathBuf::from(path);
assert!(path.is_file(), "MARQDO_SECURITY_HELPER does not exist");
return Some(path);
}
let source =
Path::new(env!("CARGO_MANIFEST_DIR")).join("../../tests/security/escape_helper.c");
let output = std::env::temp_dir().join(format!(
"marqdo-escape-helper-{}{}",
std::process::id(),
std::env::consts::EXE_SUFFIX
));
let status = Command::new("cc")
.args(["-O2", "-o"])
.arg(&output)
.arg(&source)
.status()
.ok()?;
if !status.success() {
return None;
}
Some(output)
})
.clone()
}
fn setup() -> Option<(PathBuf, PathBuf, PathBuf)> {
if !enabled() {
eprintln!(
"skipping strict security lane: set MARQDO_REQUIRE_STRICT_SECURITY=1 \
(G3) or MARQDO_RUN_STRICT_SECURITY=1 to opt in"
);
return None;
}
if let Err(reason) = probe() {
if required() {
panic!("G-C security lane requires strict isolation but probe failed: {reason}");
}
eprintln!("skipping strict security lane: {reason}");
return None;
}
let helper = match helper() {
Some(helper) => helper,
None => {
if required() {
panic!("G-C security lane could not build or find escape_helper");
}
eprintln!("skipping strict security lane: no escape helper/cc");
return None;
}
};
// `cargo test` runs these tests in parallel. The project and outside
// paths must be unique per test or two tests can remove each other's
// project between the supervisor mount and the assertion.
static NEXT: AtomicU64 = AtomicU64::new(0);
let id = NEXT.fetch_add(1, Ordering::Relaxed);
let project = std::env::temp_dir().join(format!("marqdo-security-{}-{id}", std::process::id()));
let _ = fs::remove_dir_all(&project);
fs::create_dir_all(&project).expect("create security project");
fs::write(project.join("allowed.txt"), "allowed\n").expect("write allowed file");
// A host-only path that is not mounted into the sandbox for any user. The
// sandbox has no `$HOME`, so attempting to write here must fail.
let home = std::env::var_os("HOME")
.map(PathBuf::from)
.unwrap_or_else(|| PathBuf::from("/home"));
let outside = home.join(format!("marqdo-escape-{}-{id}", std::process::id()));
let _ = fs::remove_file(&outside);
Some((helper, project, outside))
}
fn run(helper: &Path, project: &Path, outside: &Path, mode: &str) -> StrictOutcome {
let args = vec![OsString::from(mode), outside.as_os_str().to_os_string()];
let command = StrictHostCommand {
program: helper,
args: &args,
project_root: project,
document: None,
original_document: None,
output_limit: 64 * 1024,
timeout: Duration::from_secs(3),
stdlib_dir: None,
};
launch_strict_capture(&command).unwrap_or_else(|error| panic!("{mode}: {error}"))
}
fn text(outcome: &StrictOutcome) -> String {
String::from_utf8_lossy(&outcome.stdout).to_string()
}
#[test]
fn strict_child_identity_is_unprivileged_and_namespaced() {
let Some((helper, project, outside)) = setup() else {
return;
};
let outcome = run(&helper, &project, &outside, "alive");
assert_eq!(outcome.exit_code, Some(0), "{}", text(&outcome));
let output = text(&outcome);
assert!(
output.contains("uid=1000") || output.contains("uid=1001"),
"{output}"
);
assert!(
!output.contains("uid=0 "),
"strict child ran as root: {output}"
);
assert!(
output.contains("pid=1"),
"strict child is not PID 1: {output}"
);
assert!(output.contains("NoNewPrivs:\t1"), "{output}");
let cap_eff = output
.lines()
.find_map(|line| line.strip_prefix("CapEff:"))
.unwrap_or("")
.trim();
assert!(
cap_eff.bytes().all(|byte| byte == b'0'),
"strict child kept capabilities: {cap_eff}"
);
let _ = fs::remove_dir_all(&project);
}
#[test]
fn strict_child_cannot_read_host_files_but_reads_the_project() {
let Some((helper, project, outside)) = setup() else {
return;
};
let outcome = run(&helper, &project, &outside, "read");
let output = text(&outcome);
assert!(output.contains("read_project_allowed=OK"), "{output}");
for key in ["read_etc_shadow", "read_root_key", "read_home_key"] {
assert!(output.contains(&format!("{key}=DENIED")), "{key}: {output}");
assert!(!output.contains(&format!("{key}=LEAK")), "{key}: {output}");
}
let _ = fs::remove_dir_all(&project);
}
#[test]
fn strict_child_cannot_write_outside_or_into_the_project() {
let Some((helper, project, outside)) = setup() else {
return;
};
let outcome = run(&helper, &project, &outside, "write");
let output = text(&outcome);
assert!(output.contains("write_outside=DENIED"), "{output}");
assert!(output.contains("write_project=DENIED"), "{output}");
assert!(output.contains("write_tmp=WROTE"), "{output}");
assert!(
!outside.exists(),
"strict child created a host file at {}",
outside.display()
);
let _ = fs::remove_dir_all(&project);
}
#[test]
fn strict_child_cannot_escape_via_proc_or_privileges() {
let Some((helper, project, outside)) = setup() else {
return;
};
let proc = run(&helper, &project, &outside, "proc");
let output = text(&proc);
assert!(output.contains("proc_pid1_root_etc=DENIED"), "{output}");
assert!(
output.contains("inherited_fds_above_stdio=NONE"),
"{output}"
);
let privileges = run(&helper, &project, &outside, "priv");
let output = text(&privileges);
assert!(output.contains("setuid_root=DENIED"), "{output}");
assert!(output.contains("mount_tmpfs=DENIED"), "{output}");
assert!(!output.contains("setuid_root=OK"), "{output}");
assert!(!output.contains("mount_tmpfs=OK"), "{output}");
let _ = fs::remove_dir_all(&project);
}
#[test]
fn strict_child_cannot_reach_the_network() {
let Some((helper, project, outside)) = setup() else {
return;
};
let outcome = run(&helper, &project, &outside, "net");
let output = text(&outcome);
assert!(!output.contains("CONNECTED"), "{output}");
assert!(output.contains("socket_ipv4=DENIED"), "{output}");
assert!(output.contains("socket_raw=DENIED"), "{output}");
let _ = fs::remove_dir_all(&project);
}
#[test]
fn strict_supervisor_enforces_fd_and_process_limits() {
let Some((helper, project, outside)) = setup() else {
return;
};
let fds = run(&helper, &project, &outside, "fds");
let output = text(&fds);
assert!(output.contains("fd_limit=BOUNDED"), "{output}");
let count: usize = output
.lines()
.find_map(|line| line.strip_prefix("open_fds="))
.and_then(|value| value.parse().ok())
.unwrap_or(usize::MAX);
assert!(count <= 64, "strict child opened {count} fds");
let forks = run(&helper, &project, &outside, "fork");
let output = text(&forks);
assert!(output.contains("process_limit=BOUNDED"), "{output}");
let forked: usize = output
.lines()
.find_map(|line| line.strip_prefix("forked="))
.and_then(|value| value.parse().ok())
.unwrap_or(usize::MAX);
assert!(forked < 200, "strict child forked {forked} processes");
let _ = fs::remove_dir_all(&project);
}
#[test]
fn strict_supervisor_enforces_memory_cpu_and_output_limits() {
let Some((helper, project, outside)) = setup() else {
return;
};
let memory = run(&helper, &project, &outside, "mem");
let output = text(&memory);
assert!(
!output.contains("malloc_768m=OK"),
"768 MiB allocation escaped the memory limit: {output}"
);
let args = vec![OsString::from("cpu")];
let command = StrictHostCommand {
program: &helper,
args: &args,
project_root: &project,
document: None,
original_document: None,
output_limit: 64 * 1024,
timeout: Duration::from_secs(2),
stdlib_dir: None,
};
let cpu = launch_strict_capture(&command).expect_err("CPU loop must be stopped");
let message = cpu.to_string();
assert!(
message.contains("wall-clock") || message.contains("CPU"),
"unexpected CPU failure: {message}"
);
let output_limit = launch_strict_capture(&StrictHostCommand {
program: &helper,
args: &[OsString::from("output")],
project_root: &project,
document: None,
original_document: None,
output_limit: 64 * 1024,
timeout: Duration::from_secs(3),
stdlib_dir: None,
})
.expect("output helper should be captured, not spawn-failed");
assert!(
output_limit.signal == Some(libc::SIGXFSZ) || output_limit.exit_code != Some(0),
"output limit was not enforced: signal={:?} exit={:?}",
output_limit.signal,
output_limit.exit_code
);
assert!(
output_limit.stdout.len() <= 64 * 1024,
"captured {} bytes beyond the limit",
output_limit.stdout.len()
);
// The helper cannot always report after the file hits RLIMIT_FSIZE: the
// report itself would exceed the limit. A non-zero exit, a terminating
// signal, and a bounded capture are the observable contract.
let written = output_limit
.stdout
.windows(b"output_4m=WRITTEN".len())
.any(|window| window == b"output_4m=WRITTEN");
assert!(!written, "the helper reported writing 4 MiB");
let _ = fs::remove_dir_all(&project);
}