From 4265231a14e66341579cfc5db7a66b8f565e4e5f Mon Sep 17 00:00:00 2001 From: cflmy Date: Sat, 21 Nov 2026 18:42:53 +0800 Subject: [PATCH] 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. --- crates/cli/src/main.rs | 26 ++++++++++++++++--- crates/marqdo-package/src/lib.rs | 8 +++--- crates/marqdo-sandbox/tests/security_linux.rs | 26 +++++++++++++++---- 3 files changed, 48 insertions(+), 12 deletions(-) diff --git a/crates/cli/src/main.rs b/crates/cli/src/main.rs index 8f5b63d..4a25c35 100644 --- a/crates/cli/src/main.rs +++ b/crates/cli/src/main.rs @@ -367,8 +367,29 @@ struct SyncArgs { } fn main() { + // The interpreter and the bundled pure stdlib recurse on the parse/execute + // path. Windows gives the main thread 1 MiB by default (Linux/macOS use + // 8 MiB), which overflowed on the regex self-test. Run the CLI on an + // explicit 8 MiB thread on every platform so behavior does not depend on + // the host's main-thread default. + const STACK_BYTES: usize = 8 * 1024 * 1024; + let code = match std::thread::Builder::new() + .name("marqdo-main".to_string()) + .stack_size(STACK_BYTES) + .spawn(dispatch) + { + Ok(handle) => handle.join().unwrap_or(101), + Err(error) => { + eprintln!("error: cannot start the marqdo main thread: {error}"); + 1 + } + }; + std::process::exit(code); +} + +fn dispatch() -> i32 { let cli = Cli::parse(); - let code = match cli.command { + match cli.command { Command::Init(args) => commands::init(args.dir.as_deref()), Command::Check(args) => commands::check( args.file.as_deref(), @@ -433,6 +454,5 @@ fn main() { Command::PluginWorker(args) => { marqdo_plugin_abi::worker::serve(&args.manifest, &args.base_dir) } - }; - std::process::exit(code); + } } diff --git a/crates/marqdo-package/src/lib.rs b/crates/marqdo-package/src/lib.rs index ccc5dc5..8620b98 100644 --- a/crates/marqdo-package/src/lib.rs +++ b/crates/marqdo-package/src/lib.rs @@ -1858,11 +1858,11 @@ capabilities: "project:\n name: p\n version: 0.1.0\n", ) .unwrap(); + // macOS temp_dir is `/var/folders/...` while canonicalize resolves the + // `/var -> /private/var` symlink; compare canonical forms on both sides. assert_eq!( - discover_root(&nested).unwrap(), - dir.path() - .canonicalize() - .unwrap_or_else(|_| dir.path().to_path_buf()) + discover_root(&nested).unwrap().canonicalize().unwrap(), + dir.path().canonicalize().unwrap() ); assert!(discover_root(Path::new("/")).is_none()); } diff --git a/crates/marqdo-sandbox/tests/security_linux.rs b/crates/marqdo-sandbox/tests/security_linux.rs index 067c1fa..18874f7 100644 --- a/crates/marqdo-sandbox/tests/security_linux.rs +++ b/crates/marqdo-sandbox/tests/security_linux.rs @@ -4,11 +4,11 @@ //! supervisor used by `marqdo run --mode strict`, then exercise direct //! syscalls for filesystem, network, process, privilege and resource escapes. //! -//! They require a host where [`marqdo_sandbox::probe`] succeeds (Bubblewrap -//! plus permitted user/mount/PID/net namespaces). On an incapable host they -//! are skipped **unless** `MARQDO_REQUIRE_STRICT_SECURITY=1` is set, which the -//! G-C security lane must set so a missing mechanism can never count as a -//! pass. +//! 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 @@ -32,6 +32,15 @@ fn required() -> bool { == 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 { @@ -65,6 +74,13 @@ fn helper() -> Option { } 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}");