From abea4eb4d971233b0d17bde3424eb897aaa36350 Mon Sep 17 00:00:00 2001 From: Kevin Janssen Date: Sat, 14 Nov 2026 10:06:10 +0100 Subject: [PATCH] Bind approved Windows PowerShell process policy and prove Linux-first contracts --- crates/agent-core/tests/contracts.rs | 31 ++ crates/agent-core/tests/helper_reconcile.rs | 1 + crates/agent-core/tests/reconcile.rs | 1 + crates/agent-windows/src/actions.rs | 156 ++++++- crates/agent-windows/src/runtime.rs | 2 + crates/agent/src/apt.rs | 1 + crates/agent/src/runtime_tests.rs | 1 + crates/agent/tests/reconcile.rs | 1 + crates/domain/src/jobs.rs | 135 +++++- crates/privileged-helper/src/apt/tests.rs | 1 + crates/privileged-helper/src/lib.rs | 1 + crates/privileged-helper/src/main.rs | 1 + crates/privileged-helper/src/tests.rs | 1 + crates/privileged-helper/tests/reconcile.rs | 1 + crates/server/src/dev_delivery_faults.rs | 1 + crates/server/src/job_gateway.rs | 69 +++ crates/server/src/jobs.rs | 155 ++++++- crates/server/src/root_policy.rs | 1 + crates/server/src/windows_policy.rs | 1 + deploy/windows_profile_acceptance.py | 485 ++++++++++++++++++++ docs/windows-powershell-policy.md | 11 +- docs/windows-profile-acceptance.md | 62 +++ web/src/api.test.ts | 11 + web/src/api.ts | 10 + web/src/json-view.test.tsx | 18 + web/src/main.tsx | 20 +- web/src/safety.test.tsx | 37 +- web/src/safety.ts | 92 +++- 28 files changed, 1275 insertions(+), 32 deletions(-) create mode 100644 deploy/windows_profile_acceptance.py create mode 100644 docs/windows-profile-acceptance.md diff --git a/crates/agent-core/tests/contracts.rs b/crates/agent-core/tests/contracts.rs index 806c8b3..1d80ab5 100644 --- a/crates/agent-core/tests/contracts.rs +++ b/crates/agent-core/tests/contracts.rs @@ -40,6 +40,7 @@ fn fixture() -> (Binding, Request, ExecutionPermitPayload, DateTime) { script_utf8: "printf 'Hello\\n'\n".into(), arguments: vec![], expected_stdout: Some("Hello\n".into()), + windows_execution_profile: None, }, execution_identity: "agent_service".into(), not_before: now - Duration::minutes(1), @@ -170,6 +171,36 @@ fn exact_permit_bytes_time_and_all_identity_hash_bindings_are_required() { let mut changed = request; changed.signature.truncate(63); assert!(binding.verify(&changed, now).is_err()); + // Changing only the process policy is a payload mutation, even with the + // same script/attempt and a still valid original signature. + let (_, mut request, mut permit, _) = fixture(); + let mut job: JobPayload = serde_json::from_slice(&request.job_bytes).unwrap(); + job.action = Action::RunScript { + interpreter: "powershell".into(), + script_utf8: "Write-Output 'Hello'\r\n".into(), + arguments: vec![], + expected_stdout: Some("Hello\r\n".into()), + windows_execution_profile: None, + }; + request.job_bytes = encode(&job).unwrap(); + permit.job_payload_hash = hash(&request.job_bytes); + request.permit_bytes = encode(&permit).unwrap(); + request.signature = key.sign(&request.permit_bytes).to_bytes().to_vec(); + binding.verify(&request, now).unwrap(); + if let Action::RunScript { + windows_execution_profile, + .. + } = &mut job.action + { + *windows_execution_profile = + Some(rmm_domain::jobs::WindowsExecutionProfile::PowerShell51RemoteSigned); + } + request.job_bytes = encode(&job).unwrap(); + assert!(binding.verify(&request, now).is_err()); + permit.job_payload_hash = hash(&request.job_bytes); + request.permit_bytes = encode(&permit).unwrap(); + request.signature = key.sign(&request.permit_bytes).to_bytes().to_vec(); + binding.verify(&request, now).unwrap(); } #[cfg(unix)] diff --git a/crates/agent-core/tests/helper_reconcile.rs b/crates/agent-core/tests/helper_reconcile.rs index dcd0943..89e6639 100644 --- a/crates/agent-core/tests/helper_reconcile.rs +++ b/crates/agent-core/tests/helper_reconcile.rs @@ -867,6 +867,7 @@ fn script() -> Action { script_utf8: "printf hello".into(), arguments: vec![], expected_stdout: Some("hello".into()), + windows_execution_profile: None, } } fn success() -> ReconciledOutcome { diff --git a/crates/agent-core/tests/reconcile.rs b/crates/agent-core/tests/reconcile.rs index 2747938..6916b4a 100644 --- a/crates/agent-core/tests/reconcile.rs +++ b/crates/agent-core/tests/reconcile.rs @@ -605,6 +605,7 @@ fn script() -> Action { script_utf8: "printf hello".into(), arguments: vec![], expected_stdout: Some("hello".into()), + windows_execution_profile: None, } } fn success() -> ReconciledOutcome { diff --git a/crates/agent-windows/src/actions.rs b/crates/agent-windows/src/actions.rs index 5734572..dfc5c9d 100644 --- a/crates/agent-windows/src/actions.rs +++ b/crates/agent-windows/src/actions.rs @@ -2,7 +2,7 @@ //! consumption are supplied by the shared core and the runtime, never bypassed. use anyhow::{Result, ensure}; use rmm_agent_core::auth::Outcome; -use rmm_domain::jobs::{Action, JobPayload, hash}; +use rmm_domain::jobs::{Action, JobPayload, WindowsExecutionProfile, hash}; use std::{ ffi::OsString, fs::{File, OpenOptions}, @@ -11,6 +11,41 @@ use std::{ path::{Path, PathBuf}, sync::atomic::AtomicBool, }; +/// Implemented contract name only. Runtime publication still requires its own +/// native clock/boot/job qualification; this constant grants no capability. +pub const REMOTE_SIGNED_PROFILE_CAPABILITY: &str = "script.powershell.process_remote_signed/1"; + +fn script_arguments(job: &JobPayload, path: &Path) -> Result> { + let Action::RunScript { + interpreter, + arguments, + windows_execution_profile, + .. + } = &job.action + else { + anyhow::bail!("SCRIPT_REQUIRED") + }; + ensure!( + job.execution_identity == "agent_service" + && interpreter == "powershell" + && job.action.validate(), + "WINDOWS_SCRIPT_PROFILE_BINDING" + ); + let mut args: Vec = ["-NoLogo", "-NoProfile", "-NonInteractive"] + .into_iter() + .map(OsString::from) + .collect(); + if let Some(WindowsExecutionProfile::PowerShell51RemoteSigned) = windows_execution_profile { + args.extend([ + OsString::from("-ExecutionPolicy"), + OsString::from("RemoteSigned"), + ]); + } + args.push(OsString::from("-File")); + args.push(path.as_os_str().into()); + args.extend(arguments.iter().map(OsString::from)); + Ok(args) +} use windows_sys::Win32::{ Storage::FileSystem::{ FILE_ATTRIBUTE_REPARSE_POINT, FILE_FLAG_OPEN_REPARSE_POINT, FILE_SHARE_READ, @@ -47,6 +82,7 @@ pub struct Script { _file: File, cwd: PathBuf, arguments: Vec, + profile: Option, } impl Script { /// Preparation creates only a protected copy of approved bytes, no child. @@ -56,7 +92,7 @@ impl Script { let Action::RunScript { interpreter, script_utf8, - arguments, + windows_execution_profile, .. } = &job.action else { @@ -95,18 +131,14 @@ impl Script { hash(&std::fs::read(&path)?) == hash(script_utf8.as_bytes()), "SCRIPT_BYTES_CHANGED" ); - let mut args: Vec = ["-NoLogo", "-NoProfile", "-NonInteractive", "-File"] - .into_iter() - .map(OsString::from) - .collect(); - args.push(path.clone().into_os_string()); - args.extend(arguments.iter().map(OsString::from)); + let args = script_arguments(job, &path)?; Ok(Self { executable: powershell()?, path, _file: file, cwd: directory.to_path_buf(), arguments: args, + profile: *windows_execution_profile, }) } pub fn run(self, job: &JobPayload, cancel: &AtomicBool) -> Result { @@ -115,6 +147,7 @@ impl Script { let Action::RunScript { script_utf8, expected_stdout, + windows_execution_profile, .. } = &job.action else { @@ -124,6 +157,11 @@ impl Script { std::fs::read(&self.path)? == script_utf8.as_bytes(), "SCRIPT_BYTES_CHANGED" ); + ensure!( + self.profile == *windows_execution_profile + && self.arguments == script_arguments(job, &self.path)?, + "WINDOWS_SCRIPT_PROFILE_CHANGED" + ); let output = crate::process::run( &self.executable, &self.arguments, @@ -159,6 +197,17 @@ impl Script { } else { "" }; + let mut evidence = serde_json::json!({"postconditions_passed":success,"interpreter":"powershell", + "script_sha256":hash(script_utf8.as_bytes()),"execution_sid":"S-1-5-19", + "output_encoding":"raw_native_bytes","comparison":"exact_utf8_bytes", + "execution_policy":"inherited","process_tree_bounded":true, + "cancel_requested":output.cancelled,"termination_does_not_prove_absence_of_effects":output.interrupted}); + if self.profile.is_some() { + evidence["windows_execution_profile"] = serde_json::to_value(self.profile)?; + evidence["execution_policy"] = serde_json::json!("process_remote_signed_requested"); + evidence["execution_policy_requested"] = serde_json::json!("RemoteSigned"); + evidence["execution_policy_scope"] = serde_json::json!("process"); + } Ok(Outcome { state: state.into(), stdout: output.stdout, @@ -167,11 +216,7 @@ impl Script { output_truncated: output.truncated, reboot_required: false, error_code: code.into(), - evidence: serde_json::json!({"postconditions_passed":success,"interpreter":"powershell", - "script_sha256":hash(script_utf8.as_bytes()),"execution_sid":"S-1-5-19", - "output_encoding":"raw_native_bytes","comparison":"exact_utf8_bytes", - "execution_policy":"inherited","process_tree_bounded":true, - "cancel_requested":output.cancelled,"termination_does_not_prove_absence_of_effects":output.interrupted}), + evidence, }) } } @@ -200,3 +245,88 @@ pub fn inventory(job: &JobPayload) -> Result { "observed_at":chrono::Utc::now(),"completeness":"partial","execution_sid":"S-1-5-19"}), }) } + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn powershell_policy_is_an_exact_job_profile_before_file_not_a_mutable_default() { + let id = uuid::Uuid::new_v4(); + let now = chrono::Utc::now(); + let mut job = JobPayload { + schema_version: 1, + tenant_id: id, + asset_id: id, + agent_id: id, + enrollment_generation: 1, + assignment_version: 1, + job_id: id, + attempt_id: id, + action: Action::RunScript { + interpreter: "powershell".into(), + script_utf8: "Write-Output 'fixed'\r\n".into(), + arguments: vec!["-ExecutionPolicy".into(), "Bypass".into()], + expected_stdout: None, + windows_execution_profile: None, + }, + execution_identity: "agent_service".into(), + not_before: now, + start_before: now + chrono::Duration::seconds(60), + max_runtime_seconds: 30, + max_output_bytes: 4096, + }; + let path = Path::new(r"C:\fixed state\approved.ps1"); + let inherited = script_arguments(&job, path).unwrap(); + assert_eq!( + inherited, + vec![ + "-NoLogo", + "-NoProfile", + "-NonInteractive", + "-File", + r"C:\fixed state\approved.ps1", + "-ExecutionPolicy", + "Bypass" + ] + .into_iter() + .map(OsString::from) + .collect::>() + ); + if let Action::RunScript { + windows_execution_profile, + .. + } = &mut job.action + { + *windows_execution_profile = Some(WindowsExecutionProfile::PowerShell51RemoteSigned); + } + let args = script_arguments(&job, path).unwrap(); + assert_eq!( + args[..6], + [ + "-NoLogo", + "-NoProfile", + "-NonInteractive", + "-ExecutionPolicy", + "RemoteSigned", + "-File" + ] + .map(OsString::from) + ); + assert_eq!(args[6], path.as_os_str()); // approved arguments remain AFTER -File + assert_ne!(inherited, args); + let mut unknown = serde_json::to_value(&job.action).unwrap(); + unknown["windows_execution_profile"] = serde_json::json!("Bypass"); + assert!(serde_json::from_value::(unknown).is_err()); + for identity in ["root", "system"] { + job.execution_identity = identity.into(); + assert!(script_arguments(&job, path).is_err()); + } + job.execution_identity = "agent_service".into(); + for other in ["posix_sh", "bash", "pwsh"] { + if let Action::RunScript { interpreter, .. } = &mut job.action { + *interpreter = other.into(); + } + assert!(script_arguments(&job, path).is_err()); + } + } +} diff --git a/crates/agent-windows/src/runtime.rs b/crates/agent-windows/src/runtime.rs index bf8e85a..6900463 100644 --- a/crates/agent-windows/src/runtime.rs +++ b/crates/agent-windows/src/runtime.rs @@ -684,6 +684,8 @@ impl Agent { { caps.extend(["rmm.sync.v1", "refresh_inventory"].map(str::to_string)); if rmm_agent_windows::actions::powershell().is_ok() { + // The process_remote_signed profile is implemented but remains + // unpublished until its separate native qualification passes. caps.extend(["run_script", "script.powershell/1"].map(str::to_string)); } } diff --git a/crates/agent/src/apt.rs b/crates/agent/src/apt.rs index 82c5a6c..59d1688 100644 --- a/crates/agent/src/apt.rs +++ b/crates/agent/src/apt.rs @@ -353,6 +353,7 @@ mod tests { script_utf8: "true".into(), arguments: vec![], expected_stdout: None, + windows_execution_profile: None, }, execution_identity: "root".into(), not_before: now, diff --git a/crates/agent/src/runtime_tests.rs b/crates/agent/src/runtime_tests.rs index 6287f43..86d89ef 100644 --- a/crates/agent/src/runtime_tests.rs +++ b/crates/agent/src/runtime_tests.rs @@ -50,6 +50,7 @@ fn new_process_persists_interruption_before_helper_io_without_unlock_or_repeat() script_utf8: "printf 'fixture only; never executed\\n'".into(), arguments: vec![], expected_stdout: Some("fixture only; never executed\n".into()), + windows_execution_profile: None, }, execution_identity: "root".into(), not_before: now, diff --git a/crates/agent/tests/reconcile.rs b/crates/agent/tests/reconcile.rs index b9c59c0..f04400e 100644 --- a/crates/agent/tests/reconcile.rs +++ b/crates/agent/tests/reconcile.rs @@ -594,6 +594,7 @@ fn script() -> Action { script_utf8: "printf hello".into(), arguments: vec![], expected_stdout: Some("hello".into()), + windows_execution_profile: None, } } fn success() -> ReconciledOutcome { diff --git a/crates/domain/src/jobs.rs b/crates/domain/src/jobs.rs index 4d6b217..547675d 100644 --- a/crates/domain/src/jobs.rs +++ b/crates/domain/src/jobs.rs @@ -1,5 +1,6 @@ //! Version 1 codec: UTF-8 compact serde JSON of these structs, declaration field -//! order, explicit null options, ordered vectors, UTC RFC3339 timestamps. Hash the +//! order, explicit null legacy options (new opt-in fields omit None), ordered vectors, +//! UTC RFC3339 timestamps. Hash the //! stored bytes, never a reconstructed API view. No floating point/map payloads. use chrono::{DateTime, Utc}; use serde::{Deserialize, Serialize}; @@ -13,6 +14,33 @@ pub fn encode(value: &T) -> Result, serde_json::Error> { serde_json::to_vec(value) } +/// Fixed per-job Windows PowerShell 5.1 option, never a machine/GPO policy. +#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, schemars::JsonSchema)] +pub enum WindowsExecutionProfile { + #[serde(rename = "powershell_51_remote_signed")] + PowerShell51RemoteSigned, +} + +/// A missing field uses serde's default None. A present field must be the exact +/// string: null and serde's externally-tagged enum object form are not profiles. +pub fn deserialize_windows_execution_profile<'de, D>( + deserializer: D, +) -> Result, D::Error> +where + D: serde::Deserializer<'de>, +{ + let value = String::deserialize(deserializer)?; + match value.as_str() { + "powershell_51_remote_signed" => { + Ok(Some(WindowsExecutionProfile::PowerShell51RemoteSigned)) + } + _ => Err(serde::de::Error::unknown_variant( + &value, + &["powershell_51_remote_signed"], + )), + } +} + #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, schemars::JsonSchema)] #[serde(tag = "action", rename_all = "snake_case", deny_unknown_fields)] pub enum Action { @@ -21,6 +49,12 @@ pub enum Action { script_utf8: String, arguments: Vec, expected_stdout: Option, + #[serde( + default, + deserialize_with = "deserialize_windows_execution_profile", + skip_serializing_if = "Option::is_none" + )] + windows_execution_profile: Option, }, RefreshInventory { scope: String, @@ -99,8 +133,10 @@ impl Action { script_utf8, arguments, expected_stdout, + windows_execution_profile, } => { matches!(interpreter.as_str(), "posix_sh" | "bash" | "powershell") + && (windows_execution_profile.is_none() || interpreter == "powershell") && (interpreter != "powershell" || script_utf8.is_ascii() || script_utf8.starts_with('\u{feff}')) @@ -219,15 +255,25 @@ impl Action { return false; } match self { - Self::RunScript { interpreter, .. } if interpreter == "powershell" => { + Self::RunScript { + interpreter, + windows_execution_profile, + .. + } if interpreter == "powershell" => { identity == "agent_service" && has("windows.base/1") && !has("linux.base/1") && has("rmm.sync.v1") && has("script.powershell/1") + && (windows_execution_profile.is_none() + || has("script.powershell.process_remote_signed/1")) } - Self::RunScript { .. } => { - self.script_platform() == Some("linux") + Self::RunScript { + windows_execution_profile, + .. + } => { + windows_execution_profile.is_none() + && self.script_platform() == Some("linux") && has("linux.base/1") && !has("windows.base/1") } @@ -496,6 +542,7 @@ mod tests { script_utf8: "Write-Output 'hi'\r\n".into(), arguments: vec![], expected_stdout: None, + windows_execution_profile: None, }; let mut all = caps; all.extend(["run_script".into(), "script.powershell/1".into()]); @@ -505,6 +552,7 @@ mod tests { script_utf8: "printf hi\n".into(), arguments: vec![], expected_stdout: None, + windows_execution_profile: None, }; let reboot = Action::Reboot { reason: "fixed test".into(), @@ -526,6 +574,7 @@ mod tests { script_utf8: "Write-Output 'Hello'\r\n".into(), arguments: vec![], expected_stdout: Some("Hello\r\n".into()), + windows_execution_profile: None, }; let caps: Vec = [ "windows.base/1", @@ -601,6 +650,7 @@ mod tests { script_utf8: "echo hi\n".into(), arguments: vec![], expected_stdout: None, + windows_execution_profile: None, }; assert_eq!( String::from_utf8(encode(&a).unwrap()).unwrap(), @@ -613,6 +663,83 @@ mod tests { ); } #[test] + fn windows_remote_signed_profile_is_optional_exact_and_capability_bound() { + let legacy = br#"{"action":"run_script","interpreter":"powershell","script_utf8":"Write-Output 'hi'\r\n","arguments":[],"expected_stdout":null}"#; + let mut action: Action = serde_json::from_slice(legacy).unwrap(); + assert_eq!(encode(&action).unwrap(), legacy); + let inherited_hash = hash(legacy); + if let Action::RunScript { + windows_execution_profile, + .. + } = &mut action + { + *windows_execution_profile = Some(WindowsExecutionProfile::PowerShell51RemoteSigned); + } + let encoded = encode(&action).unwrap(); + assert_eq!( + String::from_utf8(encoded.clone()).unwrap(), + String::from_utf8(legacy[..legacy.len() - 1].to_vec()).unwrap() + + r#","windows_execution_profile":"powershell_51_remote_signed"}"# + ); + assert_ne!(hash(&encoded), inherited_hash); + assert_eq!(serde_json::from_slice::(&encoded).unwrap(), action); + let caps: Vec = [ + "windows.base/1", + "rmm.sync.v1", + "run_script", + "script.powershell/1", + "script.powershell.process_remote_signed/1", + ] + .into_iter() + .map(str::to_string) + .collect(); + assert!(action.validate()); + assert!(action.available_for("agent_service", &caps)); + for missing in 0..caps.len() { + let mut short = caps.clone(); + short.remove(missing); + assert!(!action.available_for("agent_service", &short)); + } + for identity in ["root", "system", "SYSTEM"] { + assert!(!action.available_for(identity, &caps)); + } + let mut mixed = caps.clone(); + mixed.push("linux.base/1".into()); + assert!(!action.available_for("agent_service", &mixed)); + for interpreter in ["posix_sh", "bash", "pwsh"] { + let mut invalid = action.clone(); + if let Action::RunScript { interpreter: i, .. } = &mut invalid { + *i = interpreter.into(); + } + assert!(!invalid.validate()); + assert!(!invalid.available_for("agent_service", &caps)); + assert!(!invalid.available_for("root", &["linux.base/1".into(), "run_script".into()])); + } + for profile in [ + serde_json::Value::Null, + serde_json::json!(false), + serde_json::json!(1), + serde_json::json!([]), + serde_json::json!({}), + serde_json::json!({"powershell_51_remote_signed": null}), + serde_json::json!("bypass"), + serde_json::json!("RemoteSigned"), + serde_json::json!("powershell_7_remote_signed"), + ] { + let mut bad = serde_json::to_value(&action).unwrap(); + bad["windows_execution_profile"] = profile.clone(); + assert!(serde_json::from_value::(bad).is_err(), "{profile}"); + // An opt-in profile is also never metadata on another action. + assert!( + serde_json::from_value::(serde_json::json!({ + "action":"refresh_inventory", "scope":"windows.base", + "windows_execution_profile":profile + })) + .is_err() + ); + } + } + #[test] fn no_terminal_replay_or_unknown_restart() { assert!(!JobState::Succeeded.allows(JobState::Running)); assert!(!JobState::Unknown.allows(JobState::Running)); diff --git a/crates/privileged-helper/src/apt/tests.rs b/crates/privileged-helper/src/apt/tests.rs index ca31c1c..85439cd 100644 --- a/crates/privileged-helper/src/apt/tests.rs +++ b/crates/privileged-helper/src/apt/tests.rs @@ -481,6 +481,7 @@ fn signed_request() -> ( script_utf8: "true".into(), arguments: vec![], expected_stdout: None, + windows_execution_profile: None, }, execution_identity: "root".into(), not_before: now - chrono::Duration::seconds(1), diff --git a/crates/privileged-helper/src/lib.rs b/crates/privileged-helper/src/lib.rs index 0f90fec..7040dfb 100644 --- a/crates/privileged-helper/src/lib.rs +++ b/crates/privileged-helper/src/lib.rs @@ -130,6 +130,7 @@ pub fn script(job: &JobPayload) -> Result { script_utf8, arguments, expected_stdout, + windows_execution_profile: None, } = &job.action else { anyhow::bail!("NOT_SCRIPT") diff --git a/crates/privileged-helper/src/main.rs b/crates/privileged-helper/src/main.rs index 8aa7e9c..1878ead 100644 --- a/crates/privileged-helper/src/main.rs +++ b/crates/privileged-helper/src/main.rs @@ -750,6 +750,7 @@ mod tests { script_utf8: "true".into(), arguments: vec![], expected_stdout: None, + windows_execution_profile: None, }, execution_identity: "agent_service".into(), not_before: now, diff --git a/crates/privileged-helper/src/tests.rs b/crates/privileged-helper/src/tests.rs index 51061e3..cba4456 100644 --- a/crates/privileged-helper/src/tests.rs +++ b/crates/privileged-helper/src/tests.rs @@ -33,6 +33,7 @@ fn fixture() -> ( script_utf8: "printf 'Hello World\\n'".into(), arguments: vec![], expected_stdout: Some("Hello World\n".into()), + windows_execution_profile: None, }, execution_identity: "agent_service".into(), not_before: now - chrono::Duration::seconds(60), diff --git a/crates/privileged-helper/tests/reconcile.rs b/crates/privileged-helper/tests/reconcile.rs index 1b3bc0b..c7fc746 100644 --- a/crates/privileged-helper/tests/reconcile.rs +++ b/crates/privileged-helper/tests/reconcile.rs @@ -432,6 +432,7 @@ fn script() -> Action { script_utf8: "printf hello".into(), arguments: vec![], expected_stdout: Some("hello".into()), + windows_execution_profile: None, } } fn success() -> ReconciledOutcome { diff --git a/crates/server/src/dev_delivery_faults.rs b/crates/server/src/dev_delivery_faults.rs index 63ed1e6..7057230 100644 --- a/crates/server/src/dev_delivery_faults.rs +++ b/crates/server/src/dev_delivery_faults.rs @@ -518,6 +518,7 @@ mod tests { script_utf8: "printf hello\\n".into(), arguments: vec![], expected_stdout: None, + windows_execution_profile: None, }, execution_identity: "agent_service".into(), not_before: c.issued_at, diff --git a/crates/server/src/job_gateway.rs b/crates/server/src/job_gateway.rs index e59c3ae..e73499d 100644 --- a/crates/server/src/job_gateway.rs +++ b/crates/server/src/job_gateway.rs @@ -191,6 +191,7 @@ pub async fn event( ensure!(r.stdout == expected.as_bytes(), "expected output mismatch"); } } + script_profile_evidence(&payload.action, &evidence)?; if matches!(payload.action, Action::Reboot { .. }) { crate::synchronization::verify_reboot_success( tx, tenant, agent, e, &payload, r, &evidence, @@ -224,6 +225,74 @@ pub async fn event( .await?; Ok(()) } +// The profile records the requested process option, never an effective GPO policy. +fn script_profile_evidence(action: &Action, evidence: &Value) -> Result<()> { + if let Action::RunScript { + script_utf8, + windows_execution_profile: Some(WindowsExecutionProfile::PowerShell51RemoteSigned), + .. + } = action + { + ensure!( + evidence.get("windows_execution_profile") + == Some(&json!("powershell_51_remote_signed")) + && evidence.get("execution_policy") + == Some(&json!("process_remote_signed_requested")) + && evidence.get("execution_policy_requested") == Some(&json!("RemoteSigned")) + && evidence.get("execution_policy_scope") == Some(&json!("process")) + && evidence.get("script_sha256") == Some(&json!(hash(script_utf8.as_bytes()))), + "requested Windows process profile evidence mismatch" + ); + } + Ok(()) +} + +#[cfg(test)] +mod script_profile_tests { + use super::*; + #[test] + fn requested_profile_success_evidence_is_exact_without_effective_policy_claim() { + let mut action = Action::RunScript { + interpreter: "powershell".into(), + script_utf8: "Write-Output 'hi'\r\n".into(), + arguments: vec![], + expected_stdout: None, + windows_execution_profile: Some(WindowsExecutionProfile::PowerShell51RemoteSigned), + }; + let evidence = json!({"windows_execution_profile":"powershell_51_remote_signed", + "execution_policy":"process_remote_signed_requested", "execution_policy_requested":"RemoteSigned", + "execution_policy_scope":"process", "script_sha256":hash(b"Write-Output 'hi'\r\n")}); + script_profile_evidence(&action, &evidence).unwrap(); + for field in [ + "windows_execution_profile", + "execution_policy", + "execution_policy_requested", + "execution_policy_scope", + "script_sha256", + ] { + let mut changed = evidence.clone(); + changed.as_object_mut().unwrap().remove(field); + assert!( + script_profile_evidence(&action, &changed).is_err(), + "{field}" + ); + changed[field] = json!("different"); + assert!( + script_profile_evidence(&action, &changed).is_err(), + "{field}" + ); + } + if let Action::RunScript { + windows_execution_profile, + .. + } = &mut action + { + *windows_execution_profile = None; + } + script_profile_evidence(&action, &json!({})).unwrap(); + } +} + async fn locked_job( tx: &mut Transaction<'_, Postgres>, agent: Uuid, diff --git a/crates/server/src/jobs.rs b/crates/server/src/jobs.rs index 16bec52..aa21401 100644 --- a/crates/server/src/jobs.rs +++ b/crates/server/src/jobs.rs @@ -151,6 +151,12 @@ pub struct Variant { interpreter: String, encoding: String, script_utf8: String, + #[serde( + default, + deserialize_with = "rmm_domain::jobs::deserialize_windows_execution_profile", + skip_serializing_if = "Option::is_none" + )] + windows_execution_profile: Option, } #[derive(Clone, Deserialize, Serialize, schemars::JsonSchema)] #[serde(deny_unknown_fields)] @@ -213,6 +219,7 @@ impl PlanRequest { script_utf8: v.script_utf8.clone(), arguments: p.arguments.clone().unwrap_or_default(), expected_stdout: p.expected_stdout.clone(), + windows_execution_profile: v.windows_execution_profile, } } "refresh_inventory" => Action::RefreshInventory { @@ -310,6 +317,7 @@ fn validate_variants(variants: &[Variant]) -> Result<()> { script_utf8: v.script_utf8.clone(), arguments: vec![], expected_stdout: None, + windows_execution_profile: v.windows_execution_profile, }; if v.encoding != "utf-8" || action.script_platform() != Some(v.os_family.as_str()) @@ -336,12 +344,21 @@ fn target_action(input: &PlanInput, caps: &[String]) -> Result { script_utf8, arguments, expected_stdout, + windows_execution_profile, } = &input.action else { return Err(fail("VALIDATION_ERROR")); }; let first = &input.script_variants[0]; - if interpreter != &first.interpreter || script_utf8 != &first.script_utf8 { + if interpreter != &first.interpreter + || script_utf8 != &first.script_utf8 + || windows_execution_profile != &first.windows_execution_profile + || (input.execution_identity != "agent_service" + && input + .script_variants + .iter() + .any(|v| v.windows_execution_profile.is_some())) + { return Err(fail("VALIDATION_ERROR")); } let platform = match ( @@ -362,6 +379,7 @@ fn target_action(input: &PlanInput, caps: &[String]) -> Result { script_utf8: v.script_utf8.clone(), arguments: arguments.clone(), expected_stdout: expected_stdout.clone(), + windows_execution_profile: v.windows_execution_profile, }) } async fn policy(tx: &mut Transaction<'_, Postgres>) -> Result<()> { @@ -1035,6 +1053,72 @@ mod windows_contract_tests { i.script_variants.remove(1); assert!(target_action(&i, &["windows.base/1".into()]).is_err()); } + #[test] + fn remote_signed_fixed_variants_bind_profile_without_linux_inheritance() { + let mut i = input(); + let legacy_linux = encode(&i.action).unwrap(); + i.script_variants[1].windows_execution_profile = + Some(WindowsExecutionProfile::PowerShell51RemoteSigned); + assert_eq!( + encode(&target_action(&i, &["linux.base/1".into()]).unwrap()).unwrap(), + legacy_linux + ); + let windows = target_action(&i, &["windows.base/1".into()]).unwrap(); + assert!(matches!( + windows, + Action::RunScript { + windows_execution_profile: Some(WindowsExecutionProfile::PowerShell51RemoteSigned), + .. + } + )); + assert!(!windows.available_for( + "agent_service", + &[ + "windows.base/1".into(), + "rmm.sync.v1".into(), + "run_script".into(), + "script.powershell/1".into() + ] + )); + for identity in ["root", "system"] { + i.execution_identity = identity.into(); + assert!(target_action(&i, &["linux.base/1".into()]).is_err()); + } + i.execution_identity = "agent_service".into(); + // Even the first Action must match the optional profile byte-for-byte. + i.script_variants.reverse(); + i.action = windows; + assert!(target_action(&i, &["windows.base/1".into()]).is_ok()); + if let Action::RunScript { + windows_execution_profile, + .. + } = &mut i.action + { + *windows_execution_profile = None; + } + assert!(target_action(&i, &["windows.base/1".into()]).is_err()); + i.script_variants[1].windows_execution_profile = + Some(WindowsExecutionProfile::PowerShell51RemoteSigned); + assert!(validate_variants(&i.script_variants).is_err()); + let legacy = json!({"os_family":"windows", "interpreter":"powershell", "encoding":"utf-8", "script_utf8":"hi"}); + let inherited: Variant = serde_json::from_value(legacy.clone()).unwrap(); + assert!(inherited.windows_execution_profile.is_none()); + assert_eq!(serde_json::to_value(inherited).unwrap(), legacy); + for profile in [ + Value::Null, + json!(false), + json!(1), + json!([]), + json!({}), + json!({"powershell_51_remote_signed":null}), + json!("bypass"), + json!("powershell_7_remote_signed"), + ] { + assert!(serde_json::from_value::(json!({"os_family":"windows", "interpreter":"powershell", "encoding":"utf-8", "script_utf8":"hi", "windows_execution_profile":profile})).is_err()); + assert!(serde_json::from_value::(json!({"execution_identity":"agent_service", "timeout_seconds":60, "max_output_bytes":4096, "windows_execution_profile":profile})).is_err()); + } + assert!(serde_json::from_value::(json!({"execution_identity":"agent_service", "timeout_seconds":60, "max_output_bytes":4096, "windows_execution_profile":"powershell_51_remote_signed"})).is_err()); + } #[tokio::test] #[ignore = "requires dedicated isolated PostgreSQL; tests/windows_plan_database.py"] async fn windows_plan_caps_persisted_database() { @@ -1175,6 +1259,75 @@ mod windows_contract_tests { "PLAN_HASH_MISMATCH" ); tx.rollback().await.unwrap(); + // A process-profile plan needs the additional current capability. Its + // presence is rechecked at submit/approval just like interpreter support. + let mut profiled = request.clone(); + profiled.script_variants[1].windows_execution_profile = + Some(WindowsExecutionProfile::PowerShell51RemoteSigned); + assert_eq!( + plan(&state, &principal, tenant, profiled.clone()) + .await + .unwrap_err() + .1, + "UNSUPPORTED_CAPABILITY" + ); + let mut profile_caps = windows_caps.as_array().unwrap().clone(); + profile_caps.push(json!("script.powershell.process_remote_signed/1")); + sqlx::query("UPDATE agent_installations SET capabilities=$2 WHERE agent_id=$1") + .bind(agents[1]) + .bind(json!(profile_caps)) + .execute(&admin) + .await + .unwrap(); + let view = plan(&state, &principal, tenant, profiled).await.unwrap(); + let profile_id = Uuid::parse_str(view["plan_id"].as_str().unwrap()).unwrap(); + let bytes: Vec = + sqlx::query_scalar("SELECT payload FROM operation_plans WHERE plan_id=$1") + .bind(profile_id) + .fetch_one(&admin) + .await + .unwrap(); + let profile_bound: PlanPayload = serde_json::from_slice(&bytes).unwrap(); + let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant) + .await + .unwrap(); + recheck(&mut tx, &profile_bound).await.unwrap(); + tx.rollback().await.unwrap(); + let mut changed = profile_bound.clone(); + let windows_job = changed + .jobs + .iter_mut() + .find(|j| j.payload.asset_id == assets[1]) + .unwrap(); + if let Action::RunScript { + windows_execution_profile, + .. + } = &mut windows_job.payload.action + { + *windows_execution_profile = None; + } + let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant) + .await + .unwrap(); + assert_eq!( + recheck(&mut tx, &changed).await.unwrap_err().1, + "PLAN_HASH_MISMATCH" + ); + tx.rollback().await.unwrap(); + sqlx::query("UPDATE agent_installations SET capabilities=$2 WHERE agent_id=$1") + .bind(agents[1]) + .bind(&windows_caps) + .execute(&admin) + .await + .unwrap(); + let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant) + .await + .unwrap(); + assert_eq!( + recheck(&mut tx, &profile_bound).await.unwrap_err().1, + "UNSUPPORTED_CAPABILITY" + ); + tx.rollback().await.unwrap(); request.script_variants.clear(); assert_eq!( plan(&state, &principal, tenant, request.clone()) diff --git a/crates/server/src/root_policy.rs b/crates/server/src/root_policy.rs index 7c467b3..2edb61d 100644 --- a/crates/server/src/root_policy.rs +++ b/crates/server/src/root_policy.rs @@ -356,6 +356,7 @@ mod tests { script_utf8: "true\n".into(), arguments: vec![], expected_stdout: None, + windows_execution_profile: None, }, execution_identity: "root".into(), not_before: now, diff --git a/crates/server/src/windows_policy.rs b/crates/server/src/windows_policy.rs index 6cef667..dcf8e6d 100644 --- a/crates/server/src/windows_policy.rs +++ b/crates/server/src/windows_policy.rs @@ -393,6 +393,7 @@ mod tests { script_utf8: "Write-Output 'hello'".into(), arguments: vec![], expected_stdout: None, + windows_execution_profile: None, }; assert!(!policy.permits("selected", &job, &caps, now)); job.action = Action::SetServiceState { diff --git a/deploy/windows_profile_acceptance.py b/deploy/windows_profile_acceptance.py new file mode 100644 index 0000000..767bf79 --- /dev/null +++ b/deploy/windows_profile_acceptance.py @@ -0,0 +1,485 @@ +#!/usr/bin/env python3 +"""Package24 pure profile contracts: Linux VM FIRST, then Windows VM. + +Only two fixed test executables run in separate bootstrap scratch directories. +No RMM job, daemon, live database, PKI, policy, enrollment or capability change. +Native execution is explicit; any lost reply permits same-case readback only. +""" +import argparse +import base64 +import datetime as dt +import hashlib +import inspect +import json +import os +from pathlib import Path +import re +import shlex +import shutil +import stat +import subprocess +import uuid + +import vm_access_check as access + +ROOT = Path(__file__).resolve().parents[1] +STATE = ROOT / 'devstate/windows-profile' +IMAGE = 'rust-discovery-durable-final-build:local' +PROFILE = 'windows-process-profile-v1' +LINUX_REMOTE = '/var/lib/rmm-windows-profile-units' +KINDS = ('domain', 'contracts') +COUNTS = {'linux': {'domain': 16, 'contracts': 7}, 'windows': {'domain': 16, 'contracts': 6}} +DOMAIN_NAMES = sorted(('apt_transaction::tests::closure_bytes_archives_and_code_are_bound', + 'apt_transaction::tests::helper_schema_two_roundtrip_and_strict_action_binding', + 'inventory_document::tests::additive_metadata_and_bounds', + 'inventory_document::tests::exact_linux_recovery_scope_does_not_admit_other_hyphens_or_windows', + 'inventory_document::tests::windows_scope_does_not_weaken_linux_or_accept_platform_spoofing', + 'jobs::tests::additive_recipe_refs_preserve_legacy_plan_bytes', 'jobs::tests::codec_golden_and_exact_script_bytes', + 'jobs::tests::no_terminal_replay_or_unknown_restart', 'jobs::tests::permit_codec_golden_all_bindings', + 'jobs::tests::updates_require_exact_versions_and_never_implicit_reboot', + 'jobs::tests::windows_interpreter_and_capability_contract', + 'jobs::tests::windows_remote_signed_profile_is_optional_exact_and_capability_bound', + 'jobs::tests::windows_system_scm_is_explicit_and_preserves_linux_service_bytes', + 'reconciliation::tests::outcome_codec_keeps_raw_output_and_sorts_evidence', + 'reconciliation::tests::reconciliation_cannot_be_a_permit_or_unbounded_ticket', + 'tests::production_never_accepts_development_auth')) +CONTRACT_NAMES = sorted(('atomic_begin_execution_rolls_back_both_rows_on_missing_witness_or_start_insert_failure', + 'completion_cas_preserves_original_bytes_and_recovers_only_verified_bound_evidence', + 'consumed_attempt_and_unknown_lock_survive_reopen_without_reexecution', + 'exact_permit_bytes_time_and_all_identity_hash_bindings_are_required', + 'historical_request_and_binding_codecs_keep_field_order_arrays_and_strictness', + 'openssl_and_portable_ed25519_agree_on_current_keys_bytes_and_tampering', + 'portable_acceptance_requires_platform_capability_and_exact_redelivery')) +UNIX_ONLY = 'openssl_and_portable_ed25519_agree_on_current_keys_bytes_and_tampering' +EXPECTED = {'linux': {'domain': DOMAIN_NAMES, 'contracts': CONTRACT_NAMES}, + 'windows': {'domain': DOMAIN_NAMES, 'contracts': [x for x in CONTRACT_NAMES if x != UNIX_ONLY]}} + + +def require(value, code): + if not value: + raise RuntimeError(code) + + +def sha(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def object_pairs(items): + value = {} + for key, item in items: + require(key not in value, 'duplicate JSON field') + value[key] = item + return value + + +def private(path, directory=False): + item = Path(path).lstat() + require(not stat.S_ISLNK(item.st_mode) and item.st_uid == os.getuid() + and stat.S_IMODE(item.st_mode) == (0o700 if directory else 0o600) + and (stat.S_ISDIR(item.st_mode) if directory else stat.S_ISREG(item.st_mode) and item.st_nlink == 1), + 'private owned regular path') + + +def load(path): + private(path) + require(Path(path).stat().st_size <= 2 * 1024 * 1024, 'bounded private JSON') + return json.loads(Path(path).read_bytes(), object_pairs_hook=object_pairs) + + +def save(path, value): + private(Path(path).parent, True) + fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW | os.O_WRONLY, 0o600) + with os.fdopen(fd, 'w') as stream: + json.dump(value, stream, indent=2); stream.write('\n'); stream.flush(); os.fsync(stream.fileno()) + + +def setup_state(): + os.umask(0o077) + STATE.parent.mkdir(mode=0o700, exist_ok=True) + metadata = STATE.parent.lstat() + require(stat.S_ISDIR(metadata.st_mode) and metadata.st_uid == os.getuid() and not metadata.st_mode & 0o002, + 'owned non-world-writable devstate parent') + STATE.mkdir(mode=0o700, exist_ok=True) + private(STATE, True) + + +def source_files(): + paths = [ROOT / p for p in ('Cargo.toml', 'Cargo.lock', 'rust-toolchain.toml', + 'deploy/windows_profile_acceptance.py', 'deploy/remote_client_bootstrap.py', + 'deploy/vm_access_check.py', 'deploy/vm_mvp_acceptance.py', 'deploy/windows/client_bootstrap.py')] + paths += list((ROOT / 'crates').rglob('Cargo.toml')) + for name in ('domain', 'agent-core', 'protocol'): + paths += [p for p in (ROOT / 'crates' / name).rglob('*') if p.is_file()] + paths += [p for p in (ROOT / 'proto').rglob('*') if p.is_file()] + for path in paths: + require(not path.is_symlink() and path.is_file(), 'regular source inputs only') + return {str(p.relative_to(ROOT)): sha(p) for p in sorted(set(paths))} + + +def names(raw): + return sorted(re.findall(r'^([A-Za-z0-9_:]+): test\r?$', raw, re.M)) + + +def check_list(raw, expected): + require(names(raw) == expected and len(set(expected)) == len(expected), 'all exact test names before execution') + require(all(not line.strip() or re.fullmatch(r'[A-Za-z0-9_:]+: test', line) for line in raw.splitlines()), + 'terse list contains only exact tests, no benchmarks or extra entries') + + +def check_output(raw, count): + require(re.search(rb'^test result: ok\. ' + str(count).encode() + + rb' passed; 0 failed; 0 ignored; 0 measured; 0 filtered out;[^\r\n]*\r?$', raw, re.M), + 'all tests passed without skipped or filtered tests') + + +def command(args, folder, timeout=300): + index = len(list(folder.glob('command-*.json'))) + try: + done = subprocess.run(args, capture_output=True, timeout=timeout) + save(folder / ('command-%03d.json' % index), dict(returncode=done.returncode, + stdout_b64=base64.b64encode(done.stdout).decode(), stderr_b64=base64.b64encode(done.stderr).decode())) + require(done.returncode == 0, 'local qualification command failed; private output retained') + return done.stdout + except subprocess.TimeoutExpired as error: + save(folder / ('command-%03d.json' % index), dict(timed_out=True, + stdout_b64=base64.b64encode(error.stdout or b'').decode(), stderr_b64=base64.b64encode(error.stderr or b'').decode())) + raise RuntimeError('local qualification timed out; no automatic retry') from None + + +def scripts(): + return {'linux_case_sha256': hashlib.sha256(inspect.getsource(linux_case).encode()).hexdigest(), + 'windows_script_sha256': hashlib.sha256(WINDOWS.encode()).hexdigest()} + + +def build(): + setup_state() + folder = STATE / ('build-' + str(uuid.uuid4())); folder.mkdir(mode=0o700) + before = source_files(); save(folder / 'source-before.json', before) + image = command(['docker', 'image', 'inspect', '--format', '{{.Id}}', IMAGE], folder).decode().strip() + require(re.fullmatch(r'sha256:[a-f0-9]{64}', image), 'immutable local build image') + target = STATE / 'target'; target.mkdir(mode=0o700, exist_ok=True); private(target, True) + common = ['docker', 'run', '--rm', '--network', 'none', '--read-only', '--tmpfs', '/tmp:rw,size=512m', + '-v', str(ROOT) + ':/src:ro', '-v', str(target) + ':/target', '-e', 'CARGO_TARGET_DIR=/target', '--entrypoint', 'cargo', image] + artifacts = {'linux': {}, 'windows': {}} + for platform, triple in [('linux', 'x86_64-unknown-linux-gnu'), ('windows', 'x86_64-pc-windows-gnu')]: + for kind in KINDS: + package, selection = ('rmm-domain', ['--lib']) if kind == 'domain' else ('rmm-agent-core', ['--test', 'contracts']) + options = ['--manifest-path', '/src/Cargo.toml', '--locked', '--offline', '--target', triple, '-p', package] + command(common + ['clippy'] + options + selection + ['--', '-D', 'warnings'], folder) + raw = command(common + ['test'] + options + selection + ['--release', '--no-run', '--message-format=json'], folder) + linked = [] + for line in raw.splitlines(): + try: item = json.loads(line) + except ValueError: continue + expected_name = 'rmm_domain' if kind == 'domain' else 'contracts' + if item.get('reason') == 'compiler-artifact' and item.get('executable') and item.get('profile', {}).get('test') and item['target']['name'] == expected_name: + linked.append(target / Path(item['executable']).relative_to('/target')) + require(len(linked) == 1, 'exact selected unit executable') + destination = folder / platform; destination.mkdir(mode=0o700, exist_ok=True) + original = destination / (kind + '.linked') + delivery = destination / (kind + ('.exe' if platform == 'windows' else '')) + for path in (original, delivery): shutil.copyfile(linked[0], path); path.chmod(0o600) + linked_sha = sha(original) + tool = 'x86_64-w64-mingw32-strip' if platform == 'windows' else 'strip' + command(['docker', 'run', '--rm', '--network', 'none', '--read-only', '-v', str(destination) + ':/artifacts', + '--entrypoint', tool, image, '--strip-debug', '/artifacts/' + delivery.name], folder) + require(sha(linked[0]) == sha(original) == linked_sha, 'unstripped original link preserved') + data = delivery.read_bytes() + if platform == 'linux': + require(data[:6] == b'\x7fELF\x02\x01' and data[18:20] == b'\x3e\0', 'Linux x64 ELF') + else: + offset = int.from_bytes(data[60:64], 'little') + require(data[:2] == b'MZ' and data[offset:offset + 6] == b'PE\0\0\x64\x86', 'Windows x64 PE') + artifacts[platform][kind] = dict(path=str(delivery.resolve()), sha256=sha(delivery), bytes=len(data), + original_link_path=str(original.resolve()), original_link_sha256=linked_sha, debug_stripped_delivery=True) + # Run exactly the deliverable Linux bytes in an offline disposable container. + for kind, item in artifacts['linux'].items(): + invoke = ['docker', 'run', '--rm', '--network', 'none', '--read-only', '--tmpfs', '/tmp:rw,exec,size=128m', + '-v', item['path'] + ':/unit:ro', '--entrypoint', 'python3', image, '-c'] + for mode in ('list', 'run'): + args = ['--list', '--format', 'terse'] if mode == 'list' else ['--test-threads=1'] + script = 'import shutil,os,subprocess;shutil.copyfile("/unit","/tmp/unit");os.chmod("/tmp/unit",0o500);subprocess.run(["/tmp/unit"]+' + repr(args) + ',check=True,cwd="/tmp",env={"PATH":"/usr/bin:/bin","LANG":"C.UTF-8","TMPDIR":"/tmp","RUST_BACKTRACE":"0"})' + raw = command(invoke + [script], folder) + save(folder / ('local-linux-' + kind + '-' + mode + '.json'), dict(stdout_b64=base64.b64encode(raw).decode())) + if mode == 'list': check_list(raw.decode(), EXPECTED['linux'][kind]) + else: check_output(raw, COUNTS['linux'][kind]) + dynamic = command(['docker', 'run', '--rm', '--network', 'none', '--read-only', '-v', item['path'] + ':/unit:ro', + '--entrypoint', 'readelf', image, '-d', '/unit'], folder).decode() + versions = command(['docker', 'run', '--rm', '--network', 'none', '--read-only', '-v', item['path'] + ':/unit:ro', + '--entrypoint', 'readelf', image, '--version-info', '/unit'], folder).decode() + glibc = sorted(set(re.findall(r'GLIBC_(\d+\.\d+)', versions)), key=lambda x: tuple(map(int, x.split('.')))) + require(glibc and tuple(map(int, glibc[-1].split('.'))) <= (2, 39), 'VM-compatible glibc requirement') + item['glibc_max'] = glibc[-1]; item['needed'] = sorted(re.findall(r'Shared library: \[([^\]]+)\]', dynamic)) + require(source_files() == before, 'source and runner unchanged through qualification') + manifest = dict(schema_version=1, profile=PROFILE, source_files=before, source_before_after_equal=True, + runner_sha256=sha(__file__), scripts=scripts(), test_names=EXPECTED, test_counts=COUNTS, artifacts=artifacts, + build_image_id=image, both_targets_clippy_D_warnings=True, linux_lists_actual=True, + windows_lists_expected_until_native=True, local_linux_tests_passed=23, native_linux_executed=False, + native_windows_executed=False, product_state_writes=False, rmm_jobs=False) + save(folder / 'manifest.json', manifest) + print(json.dumps(dict(manifest=str((folder / 'manifest.json').resolve()), manifest_sha256=sha(folder / 'manifest.json'), + linux_tests=23, windows_tests_expected=22, native_executed=False))) + + +def verified(path, new_run): + path = path.absolute(); private(path.parent, True) + require(path.name == 'manifest.json' and path.parent.parent == STATE and re.fullmatch(r'build-[0-9a-f-]{36}', path.parent.name), 'fixed build manifest path') + value = load(path) + require(value['schema_version'] == 1 and value['profile'] == PROFILE and value['runner_sha256'] == sha(__file__) + and value['scripts'] == scripts() and value['test_names'] == EXPECTED and value['test_counts'] == COUNTS + and value['source_before_after_equal'] is True and value['both_targets_clippy_D_warnings'] is True, + 'original manifest/runner/remote scripts/profile binding') + if new_run: require(value['source_files'] == source_files(), 'new execution requires same current qualified source') + for platform in COUNTS: + require(set(value['artifacts'][platform]) == set(KINDS), 'exact two artifacts') + for kind, item in value['artifacts'][platform].items(): + suffix = '.exe' if platform == 'windows' else '' + require(Path(item['path']) == path.parent / platform / (kind + suffix) + and Path(item['original_link_path']) == path.parent / platform / (kind + '.linked'), 'fixed private artifact paths') + for field, digest in [('path', item['sha256']), ('original_link_path', item['original_link_sha256'])]: + private(item[field]); require(sha(item[field]) == digest, 'immutable original/delivery bytes') + require(Path(item['path']).stat().st_size == item['bytes'], 'artifact size unchanged') + return value + + +def access_settings(root, platform): + """Read strictly parsed existing access only when the parent executes native.""" + require(root is not None and not root.is_symlink(), 'explicit real access-root required') + root = root.absolute(); require(root.is_dir() and root.resolve() == root, 'canonical access-root') + if platform == 'linux': + cfg = access.load_config(root / 'credentials/linux-vm.conf') + require(cfg['address'] == '116.203.20.85' and cfg['username'] == 'root' and cfg.get('port', '22') == '22' + and cfg.get('ssh_key_path'), 'fixed Cloud Linux bootstrap target') + prefix = ['ssh', '-F', '/dev/null', '-T', '-p', '22', '-o', 'StrictHostKeyChecking=yes', '-o', 'BatchMode=yes', + '-o', 'IdentitiesOnly=yes', '-o', 'ForwardAgent=no', '-o', 'ConnectTimeout=10', '-i', str(Path(cfg['ssh_key_path']).expanduser()), 'root@116.203.20.85'] + else: + cfg = access.load_config(root / 'credentials/server.conf') + require(cfg['address'] == '88.99.80.202' and cfg['username'] == 'root' and cfg.get('port', '22') == '22' + and cfg.get('ssh_key_path'), 'fixed server reverse-jump only') + credentials = root / 'credentials'; private(credentials, True) + record = load(credentials / 'windows-dev-access.json') + require(set(record) == {'ssh_prefix', 'expires_at'}, 'known Windows access schema') + expires = dt.datetime.fromisoformat(record['expires_at']) + require(expires.utcoffset() is not None and dt.datetime.now(dt.timezone.utc) < expires, 'existing dev access still valid') + key = str(Path(cfg['ssh_key_path']).expanduser()) + jump = ['ssh', '-F', '/dev/null', '-T', '-p', '22', '-i', key, '-o', 'StrictHostKeyChecking=yes', '-o', 'BatchMode=yes', + '-o', 'ForwardAgent=no', '-o', 'IdentitiesOnly=yes', '-W', '127.0.0.1:22240', 'root@88.99.80.202'] + prefix = ['ssh', '-F', '/dev/null', '-T', '-i', key, '-o', 'ProxyCommand=' + shlex.join(jump), + '-o', 'HostKeyAlias=rmm-windows-dev', '-o', 'UserKnownHostsFile=' + str(credentials / 'windows-dev.known_hosts'), + '-o', 'GlobalKnownHostsFile=/dev/null', '-o', 'StrictHostKeyChecking=yes', '-o', 'BatchMode=yes', + '-o', 'IdentitiesOnly=yes', '-o', 'ForwardAgent=no', '-o', 'ConnectTimeout=10', 'rmm-dev@127.0.0.1'] + require(record['ssh_prefix'] == prefix, 'exact registered pinned reverse SSH prefix') + private(credentials / 'windows-dev.known_hosts') + return prefix + + +def transport(prefix, command_text, data, folder, timeout=60): + """No stdout/stderr escapes the private case directory on transport failure.""" + try: + result = subprocess.run(prefix + [command_text], input=data, capture_output=True, timeout=timeout) + save(folder / ('transport-' + str(uuid.uuid4()) + '.json'), dict(returncode=result.returncode, + stdout_b64=base64.b64encode(result.stdout).decode(), stderr_b64=base64.b64encode(result.stderr).decode())) + require(result.returncode == 0, 'native transport incomplete; same-case readback only') + value = json.loads(result.stdout.decode('utf-8-sig'), object_pairs_hook=object_pairs) + require(isinstance(value, dict) and 'bootstrap_error' not in value, 'native bootstrap incomplete; private receipt retained') + return value + except subprocess.TimeoutExpired as error: + save(folder / ('transport-timeout-' + str(uuid.uuid4()) + '.json'), dict(timed_out=True, + stdout_b64=base64.b64encode(error.stdout or b'').decode(), stderr_b64=base64.b64encode(error.stderr or b'').decode())) + raise RuntimeError('native reply lost; read original case only') from None + + +def linux_rpc(prefix, payload, folder): + code = 'import os,json,subprocess,base64,hashlib,uuid\nfrom pathlib import Path\n' + inspect.getsource(require) + '\n' + inspect.getsource(linux_case) + code += '\ntry:\n print(json.dumps(linux_case(' + repr(payload) + ')))\nexcept Exception as e:\n print(json.dumps(dict(bootstrap_error=True,error_class=type(e).__name__)))\n' + return transport(prefix, 'python3 -', code.encode(), folder) + + +def windows_rpc(prefix, payload, folder): + script = 'try {\n' + WINDOWS + '\n} catch {[pscustomobject]@{bootstrap_error=$true;error_id=$_.FullyQualifiedErrorId;line=$_.InvocationInfo.ScriptLineNumber}|ConvertTo-Json -Compress;exit 1}' + command_text = 'powershell.exe -NoLogo -NoProfile -NonInteractive -EncodedCommand ' + base64.b64encode(script.encode('utf-16le')).decode() + return transport(prefix, command_text, (json.dumps(payload) + '\n').encode(), folder) + + +def upload(prefix, item, destination, folder, kind): + args = ['sftp'] + [part for part in prefix[1:-1] if part != '-T'] + ['-b', '-', prefix[-1]] + # Linux sftp uses uppercase -P; Windows prefix has no -p option. + if '-p' in args: args[args.index('-p')] = '-P' + batch = ('put ' + json.dumps(item['path']) + ' ' + json.dumps(destination) + '\n').encode() + save(folder / ('transfer-' + kind + '-intent.json'), dict(sha256=item['sha256'], bytes=item['bytes'])) + try: + result = subprocess.run(args, input=batch, capture_output=True, timeout=60) + save(folder / ('transfer-' + kind + '-result.json'), dict(returncode=result.returncode, + stdout_b64=base64.b64encode(result.stdout).decode(), stderr_b64=base64.b64encode(result.stderr).decode())) + require(result.returncode == 0, 'fixed artifact transfer failed; no retry') + except subprocess.TimeoutExpired as error: + save(folder / ('transfer-' + kind + '-timeout.json'), dict(timed_out=True, + stderr_b64=base64.b64encode(error.stderr or b'').decode())) + raise RuntimeError('artifact transfer incomplete; no retry') from None + + +def linux_case(p): + import resource + import stat + ident = str(uuid.UUID(p['id'])) + require(ident == p['id'] and p['action'] in ('prepare', 'run', 'read') and p['profile'] == 'windows-process-profile-v1', 'fixed unit case') + require(os.geteuid() == 0 and os.uname().machine == 'x86_64' and set(p['artifacts']) == {'domain', 'contracts'}, 'fixed Linux root qualification') + root = Path('/var/lib/rmm-windows-profile-units') + def safe(path, directory): + s = path.lstat() + require(s.st_uid == 0 and stat.S_IMODE(s.st_mode) == (0o700 if directory else 0o600) + and (stat.S_ISDIR(s.st_mode) if directory else stat.S_ISREG(s.st_mode) and s.st_nlink == 1), 'private fixed unit path') + def write(path, value): + fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_NOFOLLOW, 0o600) + with os.fdopen(fd, 'w') as out: json.dump(value, out); out.flush(); os.fsync(out.fileno()) + os.umask(0o077) + case = root / ident + if p['action'] == 'read' and not case.exists(): return dict(id=ident, status='remote_case_absent') + if p['action'] == 'prepare': + if not root.exists(): root.mkdir(mode=0o700) + safe(root, True); case.mkdir(mode=0o700); write(case / 'intent.json', p) + return dict(id=ident, prepared=True) + safe(root, True); safe(case, True); safe(case / 'intent.json', False) + original = json.loads((case / 'intent.json').read_bytes()) + require({k: v for k, v in p.items() if k != 'action'} == {k: v for k, v in original.items() if k != 'action'}, 'original complete unit intent') + if p['action'] == 'read': + if not (case / 'result.json').exists(): return dict(id=ident, status='started_without_result' if (case / 'started.json').exists() else 'prepared_without_start') + safe(case / 'result.json', False); return json.loads((case / 'result.json').read_bytes()) + write(case / 'started.json', dict(manifest_sha256=p['manifest_sha256'], execute_once=True)) + temp = case / 'tmp'; temp.mkdir(mode=0o700) + env = {'PATH': '/usr/bin:/bin', 'LANG': 'C.UTF-8', 'LC_ALL': 'C.UTF-8', 'TMPDIR': str(temp), 'RUST_BACKTRACE': '0'} + def limits(): + resource.setrlimit(resource.RLIMIT_CORE, (0, 0)); resource.setrlimit(resource.RLIMIT_CPU, (15, 15)); resource.setrlimit(resource.RLIMIT_FSIZE, (1048576, 1048576)) + require(subprocess.run(['/usr/bin/unshare', '--net', '--', '/usr/bin/true'], env=env, capture_output=True, timeout=3).returncode == 0, 'network namespace required') + listings = {} + for kind in ('domain', 'contracts'): + binary = case / kind; safe(binary, False) + require(hashlib.sha256(binary.read_bytes()).hexdigest() == p['artifacts'][kind]['sha256'], 'exact Linux delivery') + binary.chmod(0o500) + listed = subprocess.run(['/usr/bin/unshare', '--net', '--', str(binary), '--list', '--format', 'terse'], cwd=case, env=env, capture_output=True, timeout=5, preexec_fn=limits) + require(listed.returncode == 0 and len(listed.stdout) <= 65536 and len(listed.stderr) <= 65536, 'bounded actual listing') + actual = sorted(line[:-6] for line in listed.stdout.decode().splitlines() if line.endswith(': test')) + require(all(not line.strip() or __import__('re').fullmatch(r'[A-Za-z0-9_:]+: test', line) for line in listed.stdout.decode().splitlines()) + and actual == p['names'][kind] and len(actual) == {'domain': 16, 'contracts': 7}[kind], 'exact native test names before ANY test execution') + listings[kind] = actual + reports = {} + for kind in ('domain', 'contracts'): + with (case / (kind + '-stdout.bin')).open('xb') as out, (case / (kind + '-stderr.bin')).open('xb') as err: + timed = False + try: code = subprocess.run(['/usr/bin/unshare', '--net', '--', str(case / kind), '--test-threads=1'], cwd=case, env=env, + stdin=subprocess.DEVNULL, stdout=out, stderr=err, timeout=18, preexec_fn=limits).returncode + except subprocess.TimeoutExpired: timed = True; code = None + out.flush(); err.flush(); os.fsync(out.fileno()); os.fsync(err.fileno()) + raw, errors = [(case / (kind + '-' + stream + '.bin')).read_bytes() for stream in ('stdout', 'stderr')] + require(len(raw) <= 1048576 and len(errors) <= 1048576, 'bounded native output') + reports[kind] = dict(sha256=p['artifacts'][kind]['sha256'], names=listings[kind], exit_code=code, timed_out=timed, + stdout_b64=base64.b64encode(raw).decode(), stderr_b64=base64.b64encode(errors).decode()) + write(case / (kind + '-result.json'), reports[kind]) + value = dict(id=ident, platform='linux', profile=p['profile'], manifest_sha256=p['manifest_sha256'], runner_sha256=p['runner_sha256'], + scripts=p['scripts'], reports=reports, network_namespace=True, environment_cleared=True, product_state_writes=False, rmm_jobs=False) + write(case / 'result.json', value); return value + + +WINDOWS = r''' +$ErrorActionPreference='Stop';$p=([Console]::In.ReadLine()|ConvertFrom-Json) +if([string]([guid]$p.id)-cne$p.id-or$p.action-notin@('prepare','run','read')-or$p.profile-cne'windows-process-profile-v1'-or$p.manifest_sha256-notmatch'^[a-f0-9]{64}$'-or$p.linux_proof_sha256-notmatch'^[a-f0-9]{64}$'){throw 'Fixed Linux-first profile case'} +$root='C:\ProgramData\RustDiscoveryBootstrap';$case=Join-Path $root ('windows-profile-'+$p.id) +function Safe($path,$dir){$i=Get-Item -LiteralPath $path -Force;if($i.PSIsContainer-ne$dir-or($i.Attributes-band[IO.FileAttributes]::ReparsePoint)){throw 'Unit path type'};$a=Get-Acl -LiteralPath $path;if($a.GetOwner([Security.Principal.SecurityIdentifier]).Value-notin@('S-1-5-18','S-1-5-32-544')){throw 'Private unit owner'};$rules=@($a.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier]));if(!$rules.Count){throw 'Empty private ACL'};foreach($e in $rules){if($e.AccessControlType-ne'Allow'-or$e.IdentityReference.Value-notin@('S-1-5-18','S-1-5-32-544')-or($e.PropagationFlags-band[Security.AccessControl.PropagationFlags]::InheritOnly)){throw 'Broad private unit ACL'}}} +function WriteNew($path,$value){$f=[IO.File]::Open($path,[IO.FileMode]::CreateNew,[IO.FileAccess]::Write,[IO.FileShare]::Read);try{$b=[Text.Encoding]::UTF8.GetBytes(($value|ConvertTo-Json -Depth 16 -Compress));$f.Write($b,0,$b.Length);$f.Flush($true)}finally{$f.Dispose()}} +function MatchIntent($old){if($old.id-cne$p.id-or$old.profile-cne$p.profile-or$old.manifest_sha256-cne$p.manifest_sha256-or$old.runner_sha256-cne$p.runner_sha256-or$old.linux_proof_sha256-cne$p.linux_proof_sha256-or$old.scripts.linux_case_sha256-cne$p.scripts.linux_case_sha256-or$old.scripts.windows_script_sha256-cne$p.scripts.windows_script_sha256){throw 'Original profile intent'};foreach($kind in @('domain','contracts')){if($old.artifacts.$kind.sha256-cne$p.artifacts.$kind.sha256-or$old.artifacts.$kind.bytes-ne$p.artifacts.$kind.bytes-or(@($old.names.$kind)-join"`n")-cne(@($p.names.$kind)-join"`n")){throw 'Original artifact/test tuple'}}} +if($p.action-eq'read'-and!(Test-Path -LiteralPath $case)){@{id=$p.id;status='remote_case_absent'}|ConvertTo-Json -Compress;exit 0} +Safe $root $true +if($p.action-eq'prepare'){if(Test-Path -LiteralPath $case){throw 'Existing case retained'};New-Item -ItemType Directory -Path $case|Out-Null;Safe $case $true;WriteNew (Join-Path $case 'intent.json') $p;@{id=$p.id;prepared=$true}|ConvertTo-Json -Compress;exit 0} +Safe $case $true;$intent=Join-Path $case 'intent.json';Safe $intent $false;MatchIntent (Get-Content -LiteralPath $intent -Raw|ConvertFrom-Json) +if($p.action-eq'read'){$result=Join-Path $case 'result.json';if(!(Test-Path -LiteralPath $result)){$status=if(Test-Path -LiteralPath (Join-Path $case 'started.json')){'started_without_result'}else{'prepared_without_start'};@{id=$p.id;status=$status}|ConvertTo-Json -Compress;exit 0};Safe $result $false;Get-Content -LiteralPath $result -Raw;exit 0} +function RunUnit($exe,[string]$arguments){$s=New-Object Diagnostics.ProcessStartInfo;$s.FileName=$exe;$s.Arguments=$arguments;$s.UseShellExecute=$false;$s.CreateNoWindow=$true;$s.WorkingDirectory=$case;$s.RedirectStandardOutput=$true;$s.RedirectStandardError=$true;$systemRoot=$env:WINDIR;$s.EnvironmentVariables.Clear();$s.EnvironmentVariables['SystemRoot']=$systemRoot;$s.EnvironmentVariables['WINDIR']=$systemRoot;$s.EnvironmentVariables['PATH']=$systemRoot+'\System32';$s.EnvironmentVariables['TEMP']=$script:temp;$s.EnvironmentVariables['TMP']=$script:temp;$s.EnvironmentVariables['RUST_BACKTRACE']='0';$c=New-Object Diagnostics.Process;$c.StartInfo=$s;if(!$c.Start()){throw 'Unit start'};try{$o=$c.StandardOutput.ReadToEndAsync();$e=$c.StandardError.ReadToEndAsync();$timed=$false;if(!$c.WaitForExit(18000)){$timed=$true;$c.Kill();if(!$c.WaitForExit(2000)){throw 'Own unit process did not exit'}};if(!$o.Wait(2000)-or!$e.Wait(2000)-or$o.Result.Length-gt1048576-or$e.Result.Length-gt1048576){throw 'Bounded unit output'};return @{exit_code=$c.ExitCode;timed_out=$timed;stdout_b64=[Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($o.Result));stderr_b64=[Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($e.Result))}}finally{$c.Dispose()}} +WriteNew (Join-Path $case 'started.json') @{execute_once=$true;manifest_sha256=$p.manifest_sha256};$script:temp=Join-Path $case 'tmp';New-Item -ItemType Directory -Path $script:temp|Out-Null;Safe $script:temp $true +$lists=@{};$executables=@{} +foreach($kind in @('domain','contracts')){$item=$p.artifacts.$kind;if($item.sha256-notmatch'^[a-f0-9]{64}$'){throw 'Fixed unit hash'};$exe=Join-Path $case ($kind+'.exe');Safe $exe $false;if((Get-FileHash -LiteralPath $exe -Algorithm SHA256).Hash.ToLowerInvariant()-cne$item.sha256-or(Get-Item -LiteralPath $exe).Length-ne$item.bytes){throw 'Exact unit bytes'};$list=RunUnit $exe '--list --format terse';if($list.exit_code-ne0-or$list.timed_out){throw 'Actual Windows listing'};$text=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($list.stdout_b64));$unexpected=@($text-split'\r?\n'|Where-Object{$_.Trim()-and$_-notmatch'^[A-Za-z0-9_:]+: test$'});if($unexpected.Count){throw 'Only exact terse test entries'};$actual=@($text-split'\r?\n'|Where-Object{$_-match': test$'}|ForEach-Object{$_-replace': test$',''}|Sort-Object);$count=if($kind-eq'domain'){16}else{6};if($actual.Count-ne$count-or($actual-join"`n")-cne(@($p.names.$kind)-join"`n")){throw 'All exact names BEFORE any tests'};$lists[$kind]=$actual;$executables[$kind]=$exe} +$reports=@{};foreach($kind in @('domain','contracts')){$value=RunUnit $executables[$kind] '--test-threads=1';$value.sha256=$p.artifacts.$kind.sha256;$value.names=$lists[$kind];WriteNew (Join-Path $case ($kind+'-result.json')) $value;$reports[$kind]=$value} +$value=@{id=$p.id;platform='windows';profile=$p.profile;manifest_sha256=$p.manifest_sha256;runner_sha256=$p.runner_sha256;scripts=$p.scripts;linux_proof_sha256=$p.linux_proof_sha256;reports=$reports;bootstrap_administrator_units=$true;local_service_proof=$false;environment_cleared=$true;product_state_writes=$false;rmm_jobs=$false};WriteNew (Join-Path $case 'result.json') $value;$value|ConvertTo-Json -Depth 16 -Compress +''' + + +def check_result(manifest, platform, value, payload): + require(value.get('id') == payload['id'] and value.get('platform') == platform and value.get('profile') == PROFILE + and value.get('manifest_sha256') == payload['manifest_sha256'] and value.get('runner_sha256') == manifest['runner_sha256'] + and value.get('scripts') == manifest['scripts'] and value.get('product_state_writes') is False and value.get('rmm_jobs') is False + and value.get('environment_cleared') is True and set(value['reports']) == set(KINDS), 'complete native original binding') + if platform == 'linux': require(value.get('network_namespace') is True, 'actual Linux netns proof') + else: require(value.get('linux_proof_sha256') == payload['linux_proof_sha256'] and value.get('local_service_proof') is False, 'original Linux proof and honest account scope') + for kind, item in value['reports'].items(): + require(item['names'] == EXPECTED[platform][kind] and item['sha256'] == manifest['artifacts'][platform][kind]['sha256'] + and item['exit_code'] == 0 and item['timed_out'] is False, 'all native exact test names/artifacts/exits') + raw = base64.b64decode(item['stdout_b64'], validate=True); errors = base64.b64decode(item['stderr_b64'], validate=True) + require(len(raw) <= 1048576 and len(errors) <= 1048576, 'bounded native outputs') + check_output(raw, COUNTS[platform][kind]) + + +def execute(path, platform, access_root, case_id=None): + setup_state(); path = path.absolute(); manifest = verified(path, new_run=case_id is None) + prefix = access_settings(access_root, platform) + if case_id is None: + case_id = str(uuid.uuid4()); folder = STATE / case_id; folder.mkdir(mode=0o700) + payload = dict(id=case_id, profile=PROFILE, manifest_sha256=sha(path), runner_sha256=manifest['runner_sha256'], scripts=manifest['scripts'], + artifacts={kind: {k: manifest['artifacts'][platform][kind][k] for k in ('sha256', 'bytes')} for kind in KINDS}, names=EXPECTED[platform]) + if platform == 'windows': + proof_path = path.parent / 'linux-passed.json'; proof = load(proof_path) + require(proof['verified'] is True and proof['manifest_sha256'] == sha(path), 'same-manifest real Linux proof FIRST') + linux_payload = dict(payload, id=proof['case_id'], artifacts={kind: {k: manifest['artifacts']['linux'][kind][k] for k in ('sha256', 'bytes')} for kind in KINDS}, names=EXPECTED['linux']) + check_result(manifest, 'linux', proof['native'], linux_payload) + payload['linux_proof_sha256'] = sha(proof_path) + intent = dict(id=case_id, platform=platform, manifest_path=str(path), manifest_sha256=sha(path), runner_sha256=sha(__file__), + scripts=scripts(), access_root_sha256=hashlib.sha256(str(access_root.absolute()).encode()).hexdigest(), payload=payload) + save(folder / 'intent.json', intent) + save(folder / 'started-local.json', dict(create_once=True, no_retry=True)) + run_read = False + else: + require(str(uuid.UUID(case_id)) == case_id, 'original canonical case id') + folder = STATE / case_id; private(folder, True); intent = load(folder / 'intent.json'); load(folder / 'started-local.json') + require(intent['id'] == case_id and intent['platform'] == platform and intent['manifest_path'] == str(path) + and intent['manifest_sha256'] == sha(path) and intent['runner_sha256'] == sha(__file__) and intent['scripts'] == scripts() + and intent['access_root_sha256'] == hashlib.sha256(str(access_root.absolute()).encode()).hexdigest(), 'immutable same-case readback') + payload = intent['payload']; run_read = True + rpc = linux_rpc if platform == 'linux' else windows_rpc + if not run_read: + result = rpc(prefix, dict(payload, action='prepare'), folder) + save(folder / 'prepared-remote.json', result); require(result == dict(id=case_id, prepared=True), 'fresh fixed case prepared') + for kind in KINDS: + destination = LINUX_REMOTE + '/' + case_id + '/' + kind if platform == 'linux' else '/C:/ProgramData/RustDiscoveryBootstrap/windows-profile-' + case_id + '/' + kind + '.exe' + upload(prefix, manifest['artifacts'][platform][kind], destination, folder, kind) + result = rpc(prefix, dict(payload, action='read' if run_read else 'run'), folder) + save(folder / ('readback-' + str(uuid.uuid4()) + '.json'), result) + if result.get('status'): + require(run_read and result.get('id') == case_id and result['status'] in ('remote_case_absent', 'prepared_without_start', 'started_without_result'), 'fixed read-only incomplete status') + print(json.dumps(dict(verified=False, platform=platform, case_id=case_id, status=result['status'], retry_allowed=False))); return + check_result(manifest, platform, result, payload) + proof = dict(verified=True, case_id=case_id, platform=platform, manifest_sha256=sha(path), runner_sha256=manifest['runner_sha256'], native=result) + destination = path.parent / (platform + '-passed.json') + if destination.exists(): require(load(destination) == proof, 'preserve identical native proof') + else: save(destination, proof) + save(folder / 'verified.json', dict(verified=True, proof_sha256=sha(destination))) if not (folder / 'verified.json').exists() else require(load(folder / 'verified.json') == dict(verified=True, proof_sha256=sha(destination)), 'same verified receipt') + print(json.dumps(dict(verified=True, platform=platform, case_id=case_id, tests=sum(COUNTS[platform].values()), + manifest_sha256=sha(path), proof_sha256=sha(destination)))) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('action', choices=('build-local', 'linux', 'windows', 'readback-linux', 'readback-windows')) + parser.add_argument('--manifest', type=Path); parser.add_argument('--case'); parser.add_argument('--access-root', type=Path) + parser.add_argument('--execute-native-tests', action='store_true'); args = parser.parse_args() + if args.action == 'build-local': + require(not (args.manifest or args.case or args.access_root or args.execute_native_tests), 'local build only'); build() + elif args.action.startswith('readback-'): + require(args.manifest and args.case and args.access_root and not args.execute_native_tests, 'original case readback only') + execute(args.manifest, args.action.removeprefix('readback-'), args.access_root, args.case) + else: + require(args.manifest and args.access_root and args.execute_native_tests and not args.case, 'explicit new native platform run') + execute(args.manifest, args.action, args.access_root) + + +if __name__ == '__main__': + try: main() + except Exception as error: + print(json.dumps(dict(error='WINDOWS_PROFILE_QUALIFICATION_INCOMPLETE', error_class=type(error).__name__, details_suppressed=True))) + raise SystemExit(2) from None diff --git a/docs/windows-powershell-policy.md b/docs/windows-powershell-policy.md index 9c0b8e0..e869b61 100644 --- a/docs/windows-powershell-policy.md +++ b/docs/windows-powershell-policy.md @@ -1,10 +1,11 @@ # Windows PowerShell5.1: feste prozessbezogene RemoteSigned-Option -Stand2026-11-14, Spezifikation1.18. **Userentscheidung dokumentiert, -Implementierungsentwurf noch nicht umgesetzt und nicht nativ abgenommen.** -Diese Arbeit liest Produktquellen und ändert ausschließlich Dokumentation. -Laufende Rust-/Artefaktbindungen bleiben unverändert. Keine VM-/Server-/Gitaktion -oder Capability-/Clock-/Jobkonfigurationsänderung gehört zu diesem Schritt. +Stand2026-11-14, Spezifikation1.18. **Userentscheidung als Sourcekandidat im +isolierten Profilbranch umgesetzt und nativ Linux-first vertraglich geprüft.** +Die23 Domain-/Coreverträge bestanden auf der Cloud-Linux-VM; Windows22 und die +tatsächliche genehmigte PowerShellwirkung bleiben offen. Keine Capability-, +Clock- oder Jobkonfiguration aktiviert, kein Deployment. Hauptcheckout und +laufende Windowsartefakte bleiben unverändert. [Tatsächlicher Nachweis](windows-profile-acceptance.md). ## Autorisierter Umfang diff --git a/docs/windows-profile-acceptance.md b/docs/windows-profile-acceptance.md new file mode 100644 index 0000000..b528a9b --- /dev/null +++ b/docs/windows-profile-acceptance.md @@ -0,0 +1,62 @@ +# Native Prüfung des optionalen Windows-Prozessprofils + +Stand2026-11-14: implementierter und unabhängig geprüfter Profilvertrag im +isolierten Branch `codex/windows-powershell-profile`. Domain-/Server-/Original- +Grantprüfungen, isolierter PostgreSQL-Fall, beide Windows-Cross-Clippy-Profile, +35Webtests, Typecheck und Webbuild lokal bestanden. Zwei UI-Aliasbefunde und +die zunächst akzeptierte Null-/Objekt-Profilform sind eng korrigiert. + +Anschließend bestanden auf der tatsächlichen Cloud-Linux-VM alle23 Vertrags- +prüfungen ohne Skips, Fall `f463acc9-ab77-4b70-bcfb-a016f40c9410`. +Gemeinsamer Build `005b26fd-8269-40dd-8a35-798fabb024a5`, Manifest-SHA256 +`26247a3a9c187e8ce315250ab3bb3a8b5c1fe681028b15143fb9f193e4af9c80`, +Linuxproof-SHA256 `7ecabd9a3ca8fac20aaa7a185b6e128735ea77f143988f058829ae642ad32d25`. +Die22 Windows-Vertragstests sind weiterhin **erwartet, nicht nativ ausgeführt**. +Kein Deployment oder tatsächlicher PowerShell-Job; neue Profilcapability nicht +veröffentlicht. Der Hauptcheckout und seine zuvor qualifizierten Artefakte +bleiben für die ausstehende Komponentenwartung unverändert. + +`deploy/windows_profile_acceptance.py` ist ein eigener Bootstrap-Nachweisrunner, +kein RMM-Executor. Er verwendet ausschließlich zwei feste Unitprogramme: +Domain-Lib16 und Core-Contracts7 auf der Cloud-Linux-VM, danach Domain-Lib16 und +Core-Contracts6 auf der Windows-VM. Nur der Unix-OpenSSL-Paritätstest entfällt +unter Windows. Es werden keine Dienste, Produktjournale, PKI, Policies, +Capabilities oder RMM-Jobs verändert. SQLite-Fixturen entstehen ausschließlich +im eigenen temporären Testverzeichnis. Die Windows-Tests laufen als +Bootstrapadministrator; sie beweisen keinen LocalService- oder SYSTEM-Job. + +Der lokale Build erhält Original-Linkdateien neben den gestrippten Lieferkopien, +prüft beide Clippy-Ziele und führt die tatsächlich lieferbaren Linuxbytes lokal +mit `--list` und ungefiltert aus. Alle Workspace-Cargomanifeste, Lock/Toolchain, +Domain/Core/Protocol/Proto sowie Runner und Bootstraptransport werden vorher und +nachher gehasht. Windows-Testnamen sind bis zur nativen Ausgabe nur erwartet. +Der lokale Linuxlauf ersetzt keinen Linux-VM-Nachweis. + +**Aufrufschema; Windowsphase weiterhin geplant, nicht ausgeführt:** + +```sh +python3 deploy/windows_profile_acceptance.py build-local +python3 deploy/windows_profile_acceptance.py linux --manifest devstate/windows-profile/build-UUID/manifest.json --access-root /ABSOLUTER/PFAD/ZUM/HAUPTREPO --execute-native-tests +python3 deploy/windows_profile_acceptance.py windows --manifest devstate/windows-profile/build-UUID/manifest.json --access-root /ABSOLUTER/PFAD/ZUM/HAUPTREPO --execute-native-tests +``` + +`--access-root` dient ausschließlich dem streng geparsten bestehenden +SSH-Zugang: Cloud-Linux `116.203.20.85` bzw. der unveränderten gepinnten +Windows-Reverse-SSH-Kette über Cloud-Loopback22240. Keine Credentialkopien, +Symlinks oder Hostkeyänderung. Alle Artefakte und lokalen Belege bleiben im +isolierten Profilworktree. Linux läuft mit geleerter Umgebung und eigener +Netzwerknamespace. Beide nativen Phasen prüfen vor dem ersten Teststart sämtliche +Testnamen beider Programme. Windows bindet den bereits verifizierten tatsächlichen +Linux-Beleg desselben Manifests über dessen SHA256. + +Jeder Fall hat eigene Create-once-Intents und Startbelege. Eine verlorene Antwort +erlaubt ausschließlich beispielsweise `readback-linux --manifest … --case UUID +--access-root …` bzw. `readback-windows`. Dieser Pfad lädt nichts hoch und startet +keinen Prozess erneut. Er kann `remote_case_absent`, `prepared_without_start` oder +`started_without_result` als unvollständigen Stand berichten. Ein neuer Fall ist +keine automatische Fehlerwiederholung. Originale Readbacks bleiben an das feste +Manifest, Intents und Runner-/Remotescripthashes gebunden; spätere Änderungen an +Produktquellen erzwingen keine neue native Ausführung und verhindern ihren +Readback nicht. Neue Starts benötigen weiterhin die exakt qualifizierten +aktuellen Quellen. Vollständige Ausgaben/Transportfehler bleiben privat, +Standardausgabe enthält nur Status, Fallkennung und Nachweishashes. diff --git a/web/src/api.test.ts b/web/src/api.test.ts index f87eded..8f2177e 100644 --- a/web/src/api.test.ts +++ b/web/src/api.test.ts @@ -65,6 +65,17 @@ describe('JSON contract boundary', () => { expect(() => validateInput({ ...input, parameters: { ...input.parameters, execution_identity: 'root' } })).toThrow('agent_service'); validateInput({ ...input, parameters: { ...input.parameters, variants: [{ ...windows, script_utf8: "\ufeffWrite-Output 'é'\r\n" }] } }); }); + it('accepts only the fixed Windows process profile without changing inherited variants', () => { + const windows = { os_family: 'windows', interpreter: 'powershell', encoding: 'utf-8', script_utf8: "Write-Output 'fixed'\r\n" }; + const base: PlanInput = { tenant_id: 't', action: 'run_script', targets: { asset_ids: ['a'] }, parameters: { variants: [windows], execution_identity: 'agent_service', timeout_seconds: 30, max_output_bytes: 4096 }, schedule: { not_before: new Date().toISOString(), start_before: new Date(Date.now() + 60000).toISOString(), offline_policy: 'wait_until_deadline' }, rollout: { max_parallel: 1, halt_after_failures: 1 }, reason: 'fixed profile fixture' }; + const original = JSON.stringify(base); validateInput(base); expect(JSON.stringify(base)).toBe(original); + const profiled = { ...windows, windows_execution_profile: 'powershell_51_remote_signed' }; + validateInput({ ...base, parameters: { ...base.parameters, variants: [profiled] } }); + expect(() => validateInput({ ...base, parameters: { ...base.parameters, windows_execution_profile: 'powershell_51_remote_signed' } })).toThrow('Skriptvariante'); + for (const windows_execution_profile of ['Bypass', 'Unrestricted', 'RemoteSigned', 'inherited', null, {}]) expect(() => validateInput({ ...base, parameters: { ...base.parameters, variants: [{ ...windows, windows_execution_profile }] } })).toThrow('Windows-Ausführungsprofil'); + for (const variant of [{ ...profiled, os_family: 'linux' }, { ...profiled, interpreter: 'bash' }, { ...profiled, interpreter: 'pwsh' }]) expect(() => validateInput({ ...base, parameters: { ...base.parameters, variants: [variant] } })).toThrow(); + for (const execution_identity of ['root', 'system']) expect(() => validateInput({ ...base, parameters: { ...base.parameters, execution_identity, variants: [profiled] } })).toThrow('agent_service'); + }); it('allows SYSTEM only for exact bounded fixture SCM parameters without changing Linux restart', () => { const input: PlanInput = { tenant_id: 't', action: 'set_service_state', targets: { asset_ids: ['asset'] }, parameters: { execution_identity: 'system', unit: 'RmmDiscoveryFixtureService', state: 'running', timeout_seconds: 30, max_output_bytes: 4096 }, schedule: { not_before: new Date().toISOString(), start_before: new Date(Date.now() + 60000).toISOString(), offline_policy: 'wait_until_deadline' }, rollout: { max_parallel: 1, halt_after_failures: 1 }, reason: 'fixed SCM plan' }; const before = JSON.stringify(input); validateInput(input); expect(JSON.stringify(input)).toBe(before); diff --git a/web/src/api.ts b/web/src/api.ts index 276712e..0a7f7ee 100644 --- a/web/src/api.ts +++ b/web/src/api.ts @@ -59,6 +59,14 @@ export const pretty = (v: unknown) => JSON.stringify(v, null, 2); export const actions = ['run_script', 'refresh_inventory', 'query_logs', 'set_service_state', 'ensure_package', 'apply_updates', 'reboot', 'apt_native_acceptance'] as const; export type Action = typeof actions[number]; +export const windowsPowerShellRemoteSignedProfile = 'powershell_51_remote_signed' as const; +/** A missing field is inherited policy; a present field is never silently coerced. */ +export function windowsScriptProfile(value: RecordValue): 'inherited' | typeof windowsPowerShellRemoteSignedProfile { + if (!Object.prototype.hasOwnProperty.call(value, 'windows_execution_profile')) return 'inherited'; + if (value.windows_execution_profile !== windowsPowerShellRemoteSignedProfile || value.interpreter !== 'powershell' + || (value.os_family !== undefined && value.os_family !== 'windows')) throw new Error('Windows-Ausführungsprofil nur powershell_51_remote_signed für Windows PowerShell5.1'); + return windowsPowerShellRemoteSignedProfile; +} export interface PlanInput { tenant_id: string; action: Action; targets: { asset_ids: string[] }; parameters: RecordValue; artifact_ids?: string[]; schedule: { not_before: string; start_before: string; offline_policy: 'wait_until_deadline' }; rollout: { max_parallel: number; halt_after_failures: number }; reason: string } /** Decode explicit escaped CRLF before planning; never alter approved output bytes. */ export function expectedStdout(value: string, format: string): string | null { @@ -68,6 +76,7 @@ export function expectedStdout(value: string, format: string): string | null { return output; } export function validateInput(input: PlanInput): void { + if (Object.prototype.hasOwnProperty.call(input.parameters, 'windows_execution_profile')) throw new Error('Windows-Ausführungsprofil muss an der festen Windows-Skriptvariante stehen'); if (!input.targets.asset_ids.length || new Set(input.targets.asset_ids).size !== input.targets.asset_ids.length) throw new Error('Feste eindeutige Ziele erforderlich'); if (!input.reason.trim()) throw new Error('Begründung erforderlich'); const start = Date.parse(input.schedule.not_before), end = Date.parse(input.schedule.start_before); @@ -77,6 +86,7 @@ export function validateInput(input: PlanInput): void { const variants = input.parameters.variants; if (!Array.isArray(variants) || !variants.length || variants.length > 2 || !variants.every(v => { const variant = record(v), script = typeof variant.script_utf8 === 'string' ? variant.script_utf8 : ''; + windowsScriptProfile(variant); const bytes = new TextEncoder().encode(script).length; const platform = variant.os_family === 'linux' && ['posix_sh', 'bash'].includes(String(variant.interpreter)) || variant.os_family === 'windows' && variant.interpreter === 'powershell'; diff --git a/web/src/json-view.test.tsx b/web/src/json-view.test.tsx index 8c0ec18..d134bbc 100644 --- a/web/src/json-view.test.tsx +++ b/web/src/json-view.test.tsx @@ -1,9 +1,27 @@ import { expect, it, vi } from 'vitest'; import { renderToStaticMarkup } from 'react-dom/server'; +import { sha256, verifyPlanIntegrity } from './safety'; // Import the actual renderer without mounting the application's network effects. vi.mock('react-dom/client', () => ({ createRoot: () => ({ render: vi.fn() }) })); +it('shows the verified PowerShell process profile before approval without issuing requests', async () => { + const fetch = vi.fn(); vi.stubGlobal('fetch', fetch); vi.stubGlobal('document', { getElementById: () => ({}) }); + try { + const { PowerShellPlanNotice } = await import('./main'); + const payload = { jobs: [{ payload: { asset_id: 'fixed-windows', execution_identity: 'agent_service', action: { action: 'run_script', interpreter: 'powershell', script_utf8: 'Write-Output 1\r\n', arguments: [], expected_stdout: '1\r\n', windows_execution_profile: 'powershell_51_remote_signed' } } }] }; + const raw = new TextEncoder().encode(JSON.stringify(payload)), plan = { plan_payload_bytes: Array.from(raw), plan_hash: await sha256(raw), plan_payload: payload }; + expect(renderToStaticMarkup()).toContain('role="alert"'); + await verifyPlanIntegrity(plan); + const html = renderToStaticMarkup(); + for (const expected of ['fixed-windows', 'Windows PowerShell5.1', 'RemoteSigned', 'nur Jobprozess', 'angeforderte Option']) expect(html).toContain(expected); + expect(html).not.toMatch(/<(button|input|form)\b/); + plan.plan_payload_bytes[0] = 0; + expect(renderToStaticMarkup()).toContain('role="alert"'); + expect(fetch).not.toHaveBeenCalled(); + } finally { vi.unstubAllGlobals(); } +}); + it('renders hostile log content only as text, without executable nodes, approval controls or requests', async () => { const fetch = vi.fn(); vi.stubGlobal('fetch', fetch); diff --git a/web/src/main.tsx b/web/src/main.tsx index e160aa5..751d1c0 100644 --- a/web/src/main.tsx +++ b/web/src/main.tsx @@ -1,9 +1,9 @@ import React, { useEffect, useState } from 'react'; import { createRoot } from 'react-dom/client'; -import { actions, Action, ApiError, authConfig, approvalBlockers, expectedStdout, objectId, page, Page, PlanInput, pretty, record, RecordValue, request, session, Session, stringField, tenant, tenantPath, validateInput } from './api'; +import { actions, Action, ApiError, authConfig, approvalBlockers, expectedStdout, objectId, page, Page, PlanInput, pretty, record, RecordValue, request, session, Session, stringField, tenant, tenantPath, validateInput, windowsPowerShellRemoteSignedProfile } from './api'; import './style.css'; import { AdminControl, Catalog, TenantControls } from './management'; -import { allowed, availableActions, parseStrictJson, rootWarning, systemWarning, systemPlanJobs, validateSensitiveInput, verifyPlanIntegrity } from './safety'; +import { allowed, availableActions, parseStrictJson, powerShellApprovalBlockers, powerShellPlanJobs, rootWarning, systemWarning, systemPlanJobs, validateSensitiveInput, verifyPlanIntegrity } from './safety'; import { Login } from './login'; const errorText = (error: unknown) => error instanceof Error ? error.message : 'Unbekannter Fehler'; @@ -15,6 +15,13 @@ export function SystemPlanNotice({ plan }: { plan: RecordValue }) { if (!jobs.length) return null; return ; } +export function PowerShellPlanNotice({ plan }: { plan: RecordValue }) { + try { + const jobs = powerShellPlanJobs(plan); + if (!jobs.length) return null; + return ; + } catch { return ; } +} function ErrorBox({ error }: { error: string | null }) { return error ?
{error}
: null; } function useResource(load: (signal: AbortSignal) => Promise, deps: React.DependencyList, poll = false) { const [data, setData] = useState(null), [error, setError] = useState(null), [revision, setRevision] = useState(0); @@ -50,14 +57,14 @@ function Planner({ tenantId, auth, selected, showPlan }: { tenantId: string; aut return

Neuen unveränderlichen Plan vorbereiten

Nur fest ausgewählte Asset-IDs. Keine Ausführung durch Planung oder Antrag; jede Aktion einschließlich Live-Inventar benötigt Genehmigung.

{ e.preventDefault(); setBusy(true); setError(null); const f = new FormData(e.currentTarget); try { const common = { execution_identity: String(f.get('identity')), timeout_seconds: Number(f.get('timeout')), max_output_bytes: Number(f.get('output')) }; - const params = action === 'run_script' ? { ...common, variants: scriptPlatform === 'mixed' ? parseStrictJson(mixedVariants) : [{ os_family: scriptPlatform, interpreter: String(f.get('interpreter')), encoding: 'utf-8', script_utf8: String(f.get('script')) }], arguments: [], expected_stdout: expectedStdout(String(f.get('expected')), String(f.get('expected_format'))) } : { ...record(parseStrictJson(parameters)), ...common }; + const params = action === 'run_script' ? { ...common, variants: scriptPlatform === 'mixed' ? parseStrictJson(mixedVariants) : [{ os_family: scriptPlatform, interpreter: String(f.get('interpreter')), encoding: 'utf-8', script_utf8: String(f.get('script')), ...(scriptPlatform === 'windows' ? { windows_execution_profile: windowsPowerShellRemoteSignedProfile } : {}) }], arguments: [], expected_stdout: expectedStdout(String(f.get('expected')), String(f.get('expected_format'))) } : { ...record(parseStrictJson(parameters)), ...common }; const input: PlanInput = { tenant_id: tenantId, action, targets: { asset_ids: [...selected] }, parameters: params, schedule: { not_before: new Date(String(f.get('not_before'))).toISOString(), start_before: new Date(String(f.get('expires'))).toISOString(), offline_policy: 'wait_until_deadline' }, rollout: { max_parallel: Number(f.get('parallel')), halt_after_failures: Number(f.get('failures')) }, reason: String(f.get('reason')) }; const ids = String(f.get('artifact_ids') ?? '').split(/[\s,]+/).filter(Boolean); if (ids.length) { if (ids.length > 16 || new Set(ids).size !== ids.length || ids.some(id => !/^[0-9a-f-]{36}$/i.test(id))) throw new Error('Maximal 16 eindeutige feste Artefakt-UUIDs'); input.artifact_ids = ids; } validateInput(input); await validateSensitiveInput(input, auth); const plan = record(await request(tenantPath(tenantId, '/operation-plans'), { body: input, csrf: auth.csrf_token })); showPlan(objectId(plan, 'plan')); } catch (e) { setError(errorText(e)); } finally { setBusy(false); } }}> {action === 'apt_native_acceptance' &&

NUR SIMULIERTE DEV/TEST-NATIVABNAHME. In Vorbereitung; Backend/Helper/Scope müssen diese eigene Aktion unterstützen. Nur rmm-apt-fixture-install-1.0 oder rmm-apt-fixture-update-1.1, Rezeptversion 1, vollständiges Schema-2-Manifest. null/Platzhalter sind nicht konfiguriert, keine Produktionsaktion, keine automatische Ausführung.

} - {action === 'run_script' ? <>{scriptPlatform === 'mixed' ?