diff --git a/crates/cli/src/commands/run.rs b/crates/cli/src/commands/run.rs index 437a492..53fa40b 100644 --- a/crates/cli/src/commands/run.rs +++ b/crates/cli/src/commands/run.rs @@ -4,6 +4,7 @@ //! runtime helpers, but keeps the run session out of the command table. use super::*; +use marqdo_sandbox::StrictChildState; pub fn execute( file: Option<&Path>, @@ -64,31 +65,34 @@ pub fn execute( } return 2; } - if marqdo_sandbox::marker_present() { - // We were re-executed by the supervisor: validate the marker set - // before running any project code. - if let Err(reason) = marqdo_sandbox::verify_active() { + match marqdo_sandbox::inspect_strict_child() { + // A verified supervisor child may run project code. + Ok(StrictChildState::VerifiedChild) => {} + // Not a child: enforce capability and launch under the supervisor. + Ok(StrictChildState::NotChild) => { + let platform = PlatformCapabilities::detect(); + if let Err(error) = marqdo_sandbox::enforce(mode, &platform) { + if json { + output::print_json(&json!({"success": false, "error": error.to_string()})); + } else { + eprintln!("error: {error}"); + } + return 1; + } + return launch_strict_process(&project.root, file, settings); + } + // A marker without a verified identity is never trusted, and the + // platform-neutral inspection keeps Linux-only symbols out of this + // module so macOS/Windows builds compile. + Err(reason) => { + let message = format!("strict isolation verification failed: {reason}"); if json { - output::print_json(&json!({ - "success": false, - "error": format!("strict isolation verification failed: {reason}"), - })); + output::print_json(&json!({"success": false, "error": message})); } else { - eprintln!("error: strict isolation verification failed: {reason}"); + eprintln!("error: {message}"); } return 1; } - } else { - let platform = PlatformCapabilities::detect(); - if let Err(error) = marqdo_sandbox::enforce(mode, &platform) { - if json { - output::print_json(&json!({"success": false, "error": error.to_string()})); - } else { - eprintln!("error: {error}"); - } - return 1; - } - return launch_strict_process(&project.root, file, settings); } } let platform = PlatformCapabilities::detect(); diff --git a/crates/marqdo-sandbox/src/lib.rs b/crates/marqdo-sandbox/src/lib.rs index d56d497..9708fc8 100644 --- a/crates/marqdo-sandbox/src/lib.rs +++ b/crates/marqdo-sandbox/src/lib.rs @@ -13,7 +13,12 @@ use serde::{Deserialize, Serialize}; #[cfg(target_os = "linux")] mod linux; #[cfg(target_os = "linux")] -pub use linux::{marker_present, probe, verify_active, StrictOutcome}; +pub use linux::{probe, StrictOutcome}; + +/// Environment variable set by the strict supervisor for its re-executed +/// child. The marker alone never authorizes strict execution; [`inspect_strict_child`] +/// verifies the child identity before anything is trusted. +pub const STRICT_ACTIVE_ENV: &str = "MARQDO_STRICT_ACTIVE"; /// Execution mode requested on the command line. #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] @@ -160,6 +165,46 @@ fn detect_strict() -> StrictIsolation { } } +/// Whether the current process is a verified strict child. +/// +/// This is the **only** supported platform boundary for strict-child +/// detection. Linux performs the full identity verification; every other +/// platform refuses even a forged marker instead of treating it as a child. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum StrictChildState { + /// The process was not launched by the strict supervisor. + NotChild, + /// The process is the verified strict child and may run project code. + VerifiedChild, +} + +/// Inspect whether this process is the strict supervisor's verified child. +/// +/// Linux requires the marker **and** the full namespace/privilege identity +/// check in [`linux::verify_active`]. Non-Linux builds reject any marker: +/// without a verified OS isolation adapter there is no legitimate strict +/// child, so a forged `MARQDO_STRICT_ACTIVE` must fail closed. +pub fn inspect_strict_child() -> Result { + #[cfg(target_os = "linux")] + { + if !linux::marker_present() { + return Ok(StrictChildState::NotChild); + } + linux::verify_active().map(|()| StrictChildState::VerifiedChild) + } + #[cfg(not(target_os = "linux"))] + { + if std::env::var_os(STRICT_ACTIVE_ENV).is_some() { + return Err( + "strict active marker is unsupported on this platform; refusing to treat this process as a verified strict child" + .to_string(), + ); + } + Ok(StrictChildState::NotChild) + } +} + /// Failure to apply the requested sandbox mode. #[derive(Debug, Clone, PartialEq, Eq)] pub enum SandboxError { @@ -196,7 +241,7 @@ pub fn enforce(mode: SandboxMode, platform: &PlatformCapabilities) -> Result<(), match mode { SandboxMode::Strict => { #[cfg(target_os = "linux")] - if verify_active().is_ok() { + if linux::verify_active().is_ok() { return Ok(()); } if platform.strict.is_available() { @@ -270,6 +315,27 @@ mod tests { assert_eq!(SandboxMode::parse("nope"), None); } + #[cfg(target_os = "linux")] + #[test] + fn ordinary_process_is_not_a_strict_child() { + if std::env::var_os(STRICT_ACTIVE_ENV).is_none() { + assert_eq!( + inspect_strict_child().expect("inspection must not fail without a marker"), + StrictChildState::NotChild + ); + } + } + + #[cfg(not(target_os = "linux"))] + #[test] + fn forged_marker_is_rejected_on_non_linux() { + std::env::set_var(STRICT_ACTIVE_ENV, "1"); + let result = inspect_strict_child(); + std::env::remove_var(STRICT_ACTIVE_ENV); + let error = result.expect_err("a forged marker must never authorize strict execution"); + assert!(error.contains("unsupported"), "unexpected error: {error}"); + } + #[test] fn strict_refuses_when_isolation_is_unavailable() { let platform = PlatformCapabilities { diff --git a/crates/marqdo-sandbox/src/linux.rs b/crates/marqdo-sandbox/src/linux.rs index 18ff082..4185abd 100644 --- a/crates/marqdo-sandbox/src/linux.rs +++ b/crates/marqdo-sandbox/src/linux.rs @@ -30,9 +30,6 @@ use std::time::{Duration, Instant}; use crate::{SandboxError, StrictHostCommand}; -/// Environment variable that marks a re-executed strict child. -pub const ACTIVE_ENV: &str = "MARQDO_STRICT_ACTIVE"; - /// Path of the program inside the sandbox. const SANDBOX_PROGRAM: &str = "/run/marqdo-program"; @@ -158,7 +155,7 @@ fn common_args() -> Vec { /// Verify that this process really is the strict child created by [`launch`]. pub fn verify_active() -> Result<(), String> { - if std::env::var(ACTIVE_ENV).ok().as_deref() != Some("1") { + if std::env::var(crate::STRICT_ACTIVE_ENV).ok().as_deref() != Some("1") { return Err("strict active marker is absent".to_string()); } // `--as-pid-1` makes the supervised program PID 1 in its own PID namespace. @@ -204,7 +201,7 @@ pub fn verify_active() -> Result<(), String> { /// Whether the current process claims to be a strict child. The marker alone /// is not trusted; callers must use [`verify_active`]. pub fn marker_present() -> bool { - std::env::var(ACTIVE_ENV).ok().as_deref() == Some("1") + std::env::var(crate::STRICT_ACTIVE_ENV).ok().as_deref() == Some("1") } /// Result of one supervised strict execution. @@ -335,7 +332,7 @@ fn run_with( command.program.as_os_str().to_os_string(), OsString::from(SANDBOX_PROGRAM), OsString::from("--setenv"), - OsString::from(ACTIVE_ENV), + OsString::from(crate::STRICT_ACTIVE_ENV), OsString::from("1"), OsString::from("--chdir"), OsString::from("/project"),