From 66e77ad83e21e79eb7dee693964f42eb00f4f912 Mon Sep 17 00:00:00 2001 From: Kevin Janssen Date: Sat, 14 Nov 2026 13:53:05 +0100 Subject: [PATCH] Implement bounded Windows MSI delegation with deny-only cancellation and retained installer ownership --- crates/agent-windows/Cargo.toml | 2 +- crates/agent-windows/src/helper_intent.rs | 175 +++++++++++- crates/agent-windows/src/helper_runtime.rs | 131 ++++++++- crates/agent-windows/src/helper_system.rs | 314 ++++++++++++++++++++- crates/agent-windows/src/lib.rs | 3 + crates/agent-windows/src/msi_cache.rs | 178 ++++++++++++ crates/agent-windows/src/package.rs | 33 ++- crates/agent-windows/src/runtime.rs | 87 +++++- docs/windows-msi-runtime.md | 89 ++++++ 9 files changed, 996 insertions(+), 16 deletions(-) create mode 100644 crates/agent-windows/src/msi_cache.rs create mode 100644 docs/windows-msi-runtime.md diff --git a/crates/agent-windows/Cargo.toml b/crates/agent-windows/Cargo.toml index 2e869ff..97f5e6c 100644 --- a/crates/agent-windows/Cargo.toml +++ b/crates/agent-windows/Cargo.toml @@ -39,4 +39,4 @@ rcgen = { version = "=0.14.10", default-features = false, features = ["crypto", cc = "=1.11.1" [target.'cfg(windows)'.dependencies] -windows-sys = { version = "0.61.2", features = ["Win32_Foundation", "Win32_Security", "Win32_Security_Authorization", "Win32_Storage_FileSystem", "Win32_System_IO", "Win32_System_EventLog", "Win32_System_Diagnostics_ToolHelp", "Win32_System_JobObjects", "Win32_System_Pipes", "Win32_System_SystemInformation", "Win32_System_Registry", "Win32_System_Memory", "Win32_System_Services", "Win32_System_Threading"] } +windows-sys = { version = "0.61.2", features = ["Win32_Foundation", "Win32_Security", "Win32_Security_Authorization", "Win32_Storage_FileSystem", "Win32_System_IO", "Win32_System_ApplicationInstallationAndServicing", "Win32_System_EventLog", "Win32_System_Diagnostics_ToolHelp", "Win32_System_JobObjects", "Win32_System_Pipes", "Win32_System_SystemInformation", "Win32_System_Registry", "Win32_System_Memory", "Win32_System_Services", "Win32_System_Threading"] } diff --git a/crates/agent-windows/src/helper_intent.rs b/crates/agent-windows/src/helper_intent.rs index 5e30e2e..2bd0a46 100644 --- a/crates/agent-windows/src/helper_intent.rs +++ b/crates/agent-windows/src/helper_intent.rs @@ -16,16 +16,67 @@ pub const ROOT: &str = r"C:\ProgramData\RustDiscoverySystem\agent-intents"; pub const DB: &str = r"C:\ProgramData\RustDiscoverySystem\agent-intents\system-intents.sqlite"; const ACTOR_RW: u32 = 0x0012_019f; const SCHEMA:&str="CREATE TABLE IF NOT EXISTS system_intent_meta(id INTEGER PRIMARY KEY CHECK(id=1),file_identity BLOB NOT NULL); -CREATE TABLE IF NOT EXISTS system_intents(id TEXT PRIMARY KEY,job TEXT NOT NULL,attempt TEXT NOT NULL,grant_id TEXT NOT NULL UNIQUE,body BLOB NOT NULL CHECK(length(body)<=196608),digest TEXT NOT NULL,phase TEXT NOT NULL CHECK(phase IN ('prepared','known_no_dispatch','may_have_dispatched')),UNIQUE(job,attempt)); +CREATE TABLE IF NOT EXISTS system_intents(id TEXT PRIMARY KEY,job TEXT NOT NULL,attempt TEXT NOT NULL,grant_id TEXT NOT NULL UNIQUE,body BLOB NOT NULL CHECK(length(body)<=196608),digest TEXT NOT NULL,phase TEXT NOT NULL CHECK(phase IN ('prepared','known_no_dispatch','may_have_dispatched')),cancel_requested INTEGER NOT NULL DEFAULT 0 CHECK(cancel_requested IN (0,1)),UNIQUE(job,attempt)); CREATE TABLE IF NOT EXISTS system_intent_mirrors(id TEXT PRIMARY KEY,outcome_sha256 TEXT NOT NULL,mirror_observed_at TEXT NOT NULL); CREATE TABLE IF NOT EXISTS system_intent_denial_resumes(id TEXT NOT NULL,agent_instance TEXT NOT NULL,observed_at TEXT NOT NULL,PRIMARY KEY(id,agent_instance)); CREATE TRIGGER IF NOT EXISTS system_intents_no_delete BEFORE DELETE ON system_intents BEGIN SELECT RAISE(ABORT,'SYSTEM_INTENT_IMMUTABLE');END; -CREATE TRIGGER IF NOT EXISTS system_intents_monotonic BEFORE UPDATE ON system_intents WHEN NEW.id!=OLD.id OR NEW.job!=OLD.job OR NEW.attempt!=OLD.attempt OR NEW.grant_id!=OLD.grant_id OR NEW.body!=OLD.body OR NEW.digest!=OLD.digest OR OLD.phase!='prepared' OR NEW.phase NOT IN ('known_no_dispatch','may_have_dispatched') BEGIN SELECT RAISE(ABORT,'SYSTEM_INTENT_IMMUTABLE');END; +CREATE TRIGGER IF NOT EXISTS system_intents_monotonic BEFORE UPDATE ON system_intents WHEN NEW.id!=OLD.id OR NEW.job!=OLD.job OR NEW.attempt!=OLD.attempt OR NEW.grant_id!=OLD.grant_id OR NEW.body!=OLD.body OR NEW.digest!=OLD.digest OR NOT ((NEW.phase=OLD.phase AND NEW.cancel_requested=1 AND OLD.cancel_requested IN (0,1)) OR (OLD.phase='prepared' AND NEW.phase IN ('known_no_dispatch','may_have_dispatched') AND NEW.cancel_requested=OLD.cancel_requested)) BEGIN SELECT RAISE(ABORT,'SYSTEM_INTENT_IMMUTABLE');END; CREATE TRIGGER IF NOT EXISTS system_mirrors_no_delete BEFORE DELETE ON system_intent_mirrors BEGIN SELECT RAISE(ABORT,'SYSTEM_MIRROR_IMMUTABLE');END; CREATE TRIGGER IF NOT EXISTS system_mirrors_no_update BEFORE UPDATE ON system_intent_mirrors BEGIN SELECT RAISE(ABORT,'SYSTEM_MIRROR_IMMUTABLE');END; CREATE TRIGGER IF NOT EXISTS system_denial_resumes_no_delete BEFORE DELETE ON system_intent_denial_resumes BEGIN SELECT RAISE(ABORT,'SYSTEM_DENIAL_RESUME_IMMUTABLE');END; CREATE TRIGGER IF NOT EXISTS system_denial_resumes_no_update BEFORE UPDATE ON system_intent_denial_resumes BEGIN SELECT RAISE(ABORT,'SYSTEM_DENIAL_RESUME_IMMUTABLE');END;"; +const LEGACY_INTENTS_TABLE: &str = "CREATE TABLE IF NOT EXISTS system_intents(id TEXT PRIMARY KEY,job TEXT NOT NULL,attempt TEXT NOT NULL,grant_id TEXT NOT NULL UNIQUE,body BLOB NOT NULL CHECK(length(body)<=196608),digest TEXT NOT NULL,phase TEXT NOT NULL CHECK(phase IN ('prepared','known_no_dispatch','may_have_dispatched')),UNIQUE(job,attempt));"; +const LEGACY_MONOTONIC: &str = "CREATE TRIGGER IF NOT EXISTS system_intents_monotonic BEFORE UPDATE ON system_intents WHEN NEW.id!=OLD.id OR NEW.job!=OLD.job OR NEW.attempt!=OLD.attempt OR NEW.grant_id!=OLD.grant_id OR NEW.body!=OLD.body OR NEW.digest!=OLD.digest OR OLD.phase!='prepared' OR NEW.phase NOT IN ('known_no_dispatch','may_have_dispatched') BEGIN SELECT RAISE(ABORT,'SYSTEM_INTENT_IMMUTABLE');END;"; const CLAIM_RESUME: &str = "INSERT OR IGNORE INTO system_intent_denial_resumes(id,agent_instance,observed_at) VALUES(?1,?2,?3)"; +fn initialize_schema(db: &mut Connection) -> Result<()> { + let exists: bool = db.query_row( + "SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type='table' AND name='system_intents')", + [], + |r| r.get(0), + )?; + if exists { + let columns = db + .prepare("PRAGMA table_info(system_intents)")? + .query_map([], |r| r.get::<_, String>(1))? + .collect::>>()?; + if !columns.iter().any(|name| name == "cancel_requested") { + ensure!( + columns + == [ + "id", "job", "attempt", "grant_id", "body", "digest", "phase" + ], + "SYSTEM_INTENT_LEGACY_SCHEMA" + ); + let old:String=db.query_row("SELECT sql FROM sqlite_master WHERE type='trigger' AND name='system_intents_monotonic'",[],|r|r.get(0))?; + let normalize = |s: &str| { + s.replace("IF NOT EXISTS ", "") + .trim_end_matches(';') + .split_whitespace() + .collect::>() + .join(" ") + }; + ensure!( + normalize(&old) == normalize(LEGACY_MONOTONIC), + "SYSTEM_INTENT_LEGACY_TRIGGER" + ); + let table: String = db.query_row( + "SELECT sql FROM sqlite_master WHERE type='table' AND name='system_intents'", + [], + |r| r.get(0), + )?; + ensure!( + normalize(&table) == normalize(LEGACY_INTENTS_TABLE), + "SYSTEM_INTENT_LEGACY_SCHEMA" + ); + let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?; + tx.execute_batch("ALTER TABLE system_intents ADD COLUMN cancel_requested INTEGER NOT NULL DEFAULT 0 CHECK(cancel_requested IN (0,1));DROP TRIGGER system_intents_monotonic;")?; + tx.execute_batch(SCHEMA)?; + tx.commit()?; + } + } + db.execute_batch(SCHEMA)?; + Ok(()) +} #[derive(Clone, Serialize, Deserialize)] #[serde(deny_unknown_fields)] pub struct Intent { @@ -148,14 +199,14 @@ impl Store { } else { OpenFlags::SQLITE_OPEN_READ_ONLY }; - let db = Connection::open_with_flags(DB, flags)?; + let mut db = Connection::open_with_flags(DB, flags)?; db.busy_timeout(Duration::from_millis(250))?; if write { rmm_agent_core::ledger::bounded_journal_capacity(&db)?; let mode: String = db.query_row("PRAGMA journal_mode=PERSIST", [], |r| r.get(0))?; ensure!(mode == "persist", "SYSTEM_INTENT_JOURNAL_MODE"); db.execute_batch("PRAGMA synchronous=FULL;PRAGMA temp_store=MEMORY;PRAGMA journal_size_limit=1048576;")?; - db.execute_batch(SCHEMA)?; + initialize_schema(&mut db)?; db.execute( "INSERT OR IGNORE INTO system_intent_meta VALUES(1,?1)", [serde_json::to_vec(&identity)?], @@ -241,10 +292,60 @@ impl Store { } pub fn cancel_before_dispatch(&mut self, id: Uuid) -> Result { self.check()?; + self.db.execute( + "UPDATE system_intents SET cancel_requested=1 WHERE id=?1", + [id.to_string()], + )?; let (_, phase) = advance(&mut self.db, id, Phase::KnownNoDispatch)?; self.check()?; Ok(phase) } + /// Denial only. Original phase/request/anchor never changes, even after IPC. + pub fn deny(&mut self, original: &Request, boot: Uuid) -> Result<()> { + self.check()?; + let permit: ExecutionPermitPayload = serde_json::from_slice(&original.permit_bytes)?; + let intent = self.by_grant(permit.grant_id)?; + ensure!( + serde_json::to_vec(&intent.request)? == serde_json::to_vec(original)? + && intent.original_boot_id == boot, + "SYSTEM_CANCEL_ORIGINAL_BINDING" + ); + self.db.execute( + "UPDATE system_intents SET cancel_requested=1 WHERE id=?1", + [intent.id.to_string()], + )?; + self.check() + } + /// Open a new ordinary RO connection for each observation. No long-lived + /// SQLite read transaction or immutable-mode shortcut may hide actor denial. + pub fn require_not_denied( + original: &Request, + boot: Uuid, + generation: u64, + policy: &str, + binary: &str, + ) -> Result<()> { + let mut store = Self::open(false)?; + let permit: ExecutionPermitPayload = serde_json::from_slice(&original.permit_bytes)?; + let intent = store.by_grant(permit.grant_id)?; + let (_, phase) = store.load(intent.id)?; + ensure!( + serde_json::to_vec(&intent.request)? == serde_json::to_vec(original)? + && intent.original_boot_id == boot + && intent.connection_generation == generation + && phase == Phase::MayHaveDispatched + && intent.policy_sha256 == policy + && intent.helper_binary_sha256 == binary, + "SYSTEM_CANCEL_ORIGINAL_BINDING" + ); + let denied: i64 = store.db.query_row( + "SELECT cancel_requested FROM system_intents WHERE id=?1", + [intent.id.to_string()], + |r| r.get(0), + )?; + ensure!(denied == 0, "SYSTEM_MSI_CANCELLED_OR_FENCED"); + store.check() + } pub fn pending(&self) -> Result> { let mut rows=self.db.prepare("SELECT i.id FROM system_intents i WHERE NOT EXISTS(SELECT 1 FROM system_intent_mirrors m WHERE m.id=i.id) ORDER BY i.rowid LIMIT 2")?; let ids = rows @@ -356,7 +457,7 @@ mod tests { let dispatched = Uuid::new_v4(); for id in [cancelled, dispatched] { db.execute( - "INSERT INTO system_intents VALUES(?1,?1,?1,?1,x'01','immutable','prepared')", + "INSERT INTO system_intents(id,job,attempt,grant_id,body,digest,phase) VALUES(?1,?1,?1,?1,x'01','immutable','prepared')", [id.to_string()], ) .unwrap(); @@ -377,6 +478,29 @@ mod tests { advance(&mut db, dispatched, Phase::KnownNoDispatch).unwrap(), (0, Phase::MayHaveDispatched) ); + for _ in 0..2 { + db.execute( + "UPDATE system_intents SET cancel_requested=1 WHERE id=?1", + [dispatched.to_string()], + ) + .unwrap(); + } + assert_eq!( + db.query_row( + "SELECT phase,cancel_requested FROM system_intents WHERE id=?1", + [dispatched.to_string()], + |r| Ok((r.get::<_, String>(0)?, r.get::<_, i64>(1)?)) + ) + .unwrap(), + ("may_have_dispatched".into(), 1) + ); + assert!( + db.execute( + "UPDATE system_intents SET cancel_requested=0 WHERE id=?1", + [dispatched.to_string()] + ) + .is_err() + ); assert!( db.execute( "UPDATE system_intents SET phase='prepared' WHERE id=?1", @@ -411,4 +535,45 @@ mod tests { assert_eq!(db.execute(CLAIM_RESUME, args).unwrap(), 1); assert_eq!(db.execute(CLAIM_RESUME, args).unwrap(), 0); } + #[test] + fn additive_denial_column_preserves_original_legacy_intents_and_rejects_unknown_trigger() { + let mut db = Connection::open_in_memory().unwrap(); + db.execute_batch(LEGACY_INTENTS_TABLE).unwrap(); + db.execute_batch(LEGACY_MONOTONIC).unwrap(); + db.execute("INSERT INTO system_intents VALUES('id','job','attempt','grant',x'0102','original','may_have_dispatched')",[]).unwrap(); + initialize_schema(&mut db).unwrap(); + initialize_schema(&mut db).unwrap(); + assert_eq!( + db.query_row( + "SELECT body,digest,phase,cancel_requested FROM system_intents", + [], + |r| Ok(( + r.get::<_, Vec>(0)?, + r.get::<_, String>(1)?, + r.get::<_, String>(2)?, + r.get::<_, i64>(3)? + )) + ) + .unwrap(), + ( + vec![1, 2], + "original".into(), + "may_have_dispatched".into(), + 0 + ) + ); + db.execute("UPDATE system_intents SET cancel_requested=1", []) + .unwrap(); + assert!( + db.execute("UPDATE system_intents SET body=x'03'", []) + .is_err() + ); + assert!( + db.execute("UPDATE system_intents SET cancel_requested=0", []) + .is_err() + ); + let mut foreign = Connection::open_in_memory().unwrap(); + foreign.execute_batch("CREATE TABLE system_intents(id,job,attempt,grant_id,body,digest,phase);CREATE TRIGGER system_intents_monotonic BEFORE UPDATE ON system_intents BEGIN SELECT 1;END;").unwrap(); + assert!(initialize_schema(&mut foreign).is_err()); + } } diff --git a/crates/agent-windows/src/helper_runtime.rs b/crates/agent-windows/src/helper_runtime.rs index 85e3837..9df4cd0 100644 --- a/crates/agent-windows/src/helper_runtime.rs +++ b/crates/agent-windows/src/helper_runtime.rs @@ -470,6 +470,13 @@ fn verified_mirror_row( Ok(outcome) } fn system_shape(job: &JobPayload) -> bool { + if job.action.windows_msi().is_some() { + return job.execution_identity == "system" + && job.action.validate() + && job + .action + .valid_job_limits(job.max_runtime_seconds, job.max_output_bytes); + } job.execution_identity == "system" && (1..=120).contains(&job.max_runtime_seconds) && (1..=65536).contains(&job.max_output_bytes) @@ -487,7 +494,7 @@ pub(super) fn checked_outcome(job: &JobPayload, outcome: &Outcome) -> Result<()> matches!( outcome.state.as_str(), "succeeded" | "failed" | "cancelled" | "expired" | "unknown" - ) && !outcome.reboot_required + ) && (job.action.windows_msi().is_some() || !outcome.reboot_required) && outcome .stdout .len() @@ -496,6 +503,47 @@ pub(super) fn checked_outcome(job: &JobPayload, outcome: &Outcome) -> Result<()> "SYSTEM_EXECUTE_OUTCOME_SCOPE" ); if outcome.state == "succeeded" { + if let Some(m) = job.action.windows_msi() { + let e = &outcome.evidence; + let after: crate::package::Snapshot = serde_json::from_value(e["after"].clone())?; + let noop = e["already_desired"] == true; + ensure!( + job.action.validate() + && e["provider"] == "windows.msi.fixture/1" + && e["recipe_sha256"] == m.recipe_sha256 + && e["artifact_sha256"] == m.recipe.artifact.sha256 + && e["postconditions_passed"] == true + && e["state"] == "succeeded" + && e["exit_code"] == serde_json::to_value(outcome.exit_code)? + && e["already_desired"].is_boolean() + && !outcome.output_truncated + && e["reboot_initiated"] == false + && e["automatic_retry"] == false + && after.desired(m), + "SYSTEM_MSI_POSTCONDITION_BINDING" + ); + if noop { + let before: crate::package::Snapshot = serde_json::from_value(e["before"].clone())?; + ensure!( + outcome.exit_code.is_none() + && !outcome.reboot_required + && e["installer_process_started"] == false + && e["transaction_started"] == false + && e["installer_reboot_required"].is_null() + && before.desired(m), + "SYSTEM_MSI_NOOP_BINDING" + ); + } else { + ensure!( + matches!(outcome.exit_code, Some(0 | 3010)) + && e["installer_process_started"] == true + && outcome.reboot_required == (outcome.exit_code == Some(3010)) + && e["installer_reboot_required"] == outcome.reboot_required, + "SYSTEM_MSI_EXIT_BINDING" + ); + } + return Ok(()); + } let Action::SetServiceState { unit, state } = &job.action else { anyhow::bail!("SYSTEM_TYPED_SERVICE_REQUIRED"); }; @@ -537,6 +585,43 @@ pub fn map_snapshot(s: &Snapshot) -> HelperSnapshot { .collect(), } } +#[cfg(test)] +pub(crate) fn msi_test_job() -> JobPayload { + use rmm_domain::windows_execution::*; + let recipe:WindowsMsiRecipe=serde_json::from_value(json!({"schema_version":1,"recipe_id":MSI_RECIPE_ID,"recipe_version":"1","platform":"windows","upgrade_code":MSI_UPGRADE_CODE,"architecture":"x64","context":"machine","command_profile":"fixture_quiet_no_reboot_v1","artifact":{"artifact_id":uuid::Uuid::from_u128(10),"sha256":"ab".repeat(32),"bytes":32768},"postcondition":{"product_code":MSI_PRODUCT_CODE,"product_version":MSI_VERSION,"payload_path":MSI_PAYLOAD,"payload_sha256":MSI_PAYLOAD_10_SHA256,"payload_bytes":33},"no_reboot":true})).unwrap(); + let manifest = ResolvedWindowsMsi { + recipe_sha256: recipe.sha256().unwrap(), + recipe, + }; + let now = chrono::Utc::now(); + let id = uuid::Uuid::from_u128(1); + 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::EnsurePackage { + provider: "msi".into(), + package: MSI_PACKAGE_ID.into(), + version: MSI_VERSION.into(), + architecture: "x64".into(), + recipe_version: "1".into(), + installation_context: "machine".into(), + recipe_id: Some(MSI_RECIPE_ID.into()), + apt_manifest: None, + windows_msi_manifest: Some(Box::new(manifest)), + }, + execution_identity: "system".into(), + not_before: now, + start_before: now + chrono::Duration::minutes(2), + max_runtime_seconds: 30, + max_output_bytes: 4096, + } +} fn write_current_probe(state: &Path, value: &serde_json::Value) -> Result<()> { native::private_path(state, true)?; let path = state.join(PROBE_FILE); @@ -574,6 +659,50 @@ fn write_current_probe(state: &Path, value: &serde_json::Value) -> Result<()> { mod tests { use super::*; #[test] + fn msi_scope_requires_bound_independent_postconditions_and_exact_noop_or_installer_exit() { + let job = msi_test_job(); + assert!(system_shape(&job)); + let m = job.action.windows_msi().unwrap(); + let p = &m.recipe.postcondition; + let snapshot = crate::package::Snapshot { + product_code: p.product_code.clone(), + related_products: vec![p.product_code.clone()], + product_state: Some("5".into()), + product_version: Some(p.product_version.clone()), + payload_sha256: Some(p.payload_sha256.clone()), + payload_bytes: Some(p.payload_bytes), + ..Default::default() + }; + let mut out = Outcome { + state: "succeeded".into(), + exit_code: Some(3010), + reboot_required: true, + evidence: json!({"provider":"windows.msi.fixture/1","recipe_sha256":m.recipe_sha256,"artifact_sha256":m.recipe.artifact.sha256,"postconditions_passed":true,"reboot_initiated":false,"automatic_retry":false,"already_desired":false,"state":"succeeded","exit_code":3010,"installer_process_started":true,"installer_reboot_required":true,"after":snapshot,"before":snapshot}), + ..Outcome::unknown("") + }; + assert!(checked_outcome(&job, &out).is_ok()); + out.reboot_required = false; + assert!(checked_outcome(&job, &out).is_err()); + out.reboot_required = true; + out.evidence["after"]["payload_sha256"] = "cd".repeat(32).into(); + assert!(checked_outcome(&job, &out).is_err()); + out.evidence["after"] = serde_json::to_value(&snapshot).unwrap(); + out.evidence["already_desired"] = true.into(); + out.evidence["exit_code"] = serde_json::Value::Null; + out.exit_code = None; + out.reboot_required = false; + out.evidence["installer_reboot_required"] = serde_json::Value::Null; + out.evidence["installer_process_started"] = false.into(); + out.evidence["transaction_started"] = false.into(); + assert!(checked_outcome(&job, &out).is_ok()); + out.exit_code = Some(0); + assert!(checked_outcome(&job, &out).is_err()); + out.state = "unknown".into(); + out.reboot_required = true; + out.exit_code = Some(1641); + assert!(checked_outcome(&job, &out).is_ok()); + } + #[test] fn system_route_binds_original_request_shape_budget_and_reply_scope() { let id = uuid::Uuid::new_v4(); let now = chrono::Utc::now(); diff --git a/crates/agent-windows/src/helper_system.rs b/crates/agent-windows/src/helper_system.rs index 12b71f6..42f3916 100644 --- a/crates/agent-windows/src/helper_system.rs +++ b/crates/agent-windows/src/helper_system.rs @@ -69,11 +69,49 @@ pub struct Settings { pub max_runtime_seconds: u32, pub enable_effects: bool, pub allow_reboot: bool, + #[serde( + default, + skip_serializing_if = "Option::is_none", + deserialize_with = "strict_recipe_hashes" + )] + pub allowed_msi_recipe_sha256: Option>, +} +fn strict_recipe_hashes<'de, D: serde::Deserializer<'de>>( + d: D, +) -> std::result::Result>, D::Error> { + Vec::::deserialize(d).map(Some) } impl Settings { + fn permits_msi(&self, job: &JobPayload) -> bool { + self.schema_version == 2 + && job.execution_identity == "system" + && job.action.validate() + && job + .action + .valid_job_limits(job.max_runtime_seconds, job.max_output_bytes) + && job.max_runtime_seconds <= self.max_runtime_seconds + && job.action.windows_msi().is_some_and(|m| { + self.allowed_msi_recipe_sha256 + .as_ref() + .is_some_and(|h| h.contains(&m.recipe_sha256)) + }) + } pub fn validate(&self) -> Result<()> { ensure!( - self.schema_version == 1 + matches!(self.schema_version, 1 | 2) + && (self.schema_version == 2 || self.allowed_msi_recipe_sha256.is_none()) + && self + .allowed_msi_recipe_sha256 + .as_ref() + .is_none_or(|hashes| { + hashes.len() <= 2 + && hashes.iter().all(|h| ipc::digest(h)) + && hashes + .iter() + .collect::>() + .len() + == hashes.len() + }) && !self.allow_reboot && (1..=120).contains(&self.max_runtime_seconds) && self.allowed_services.len() <= 16, @@ -763,6 +801,11 @@ fn verified_window( Ok((job, permit, now)) } +struct UnsettledMsi { + grant: Uuid, + request_sha256: String, + installer: Box, +} pub struct SystemHelper { settings: Settings, pin: Pin, @@ -773,6 +816,7 @@ pub struct SystemHelper { boot: WindowsBoot, sync: Option>, last_diagnostic: Option, + unsettled_msi: Option, } impl SystemHelper { pub fn open() -> Result { @@ -796,6 +840,7 @@ impl SystemHelper { boot, sync, last_diagnostic: None, + unsettled_msi: None, }) } pub fn pin(&self) -> &Pin { @@ -972,7 +1017,8 @@ impl SystemHelper { ensure!( job.execution_identity == "system" && job.max_runtime_seconds <= self.settings.max_runtime_seconds - && matches!(&job.action,Action::SetServiceState{unit,state} if matches!(state.as_str(),"running"|"stopped")&&self.settings.allowed_services.iter().any(|r|r.name==*unit)), + && (matches!(&job.action,Action::SetServiceState{unit,state} if matches!(state.as_str(),"running"|"stopped")&&self.settings.allowed_services.iter().any(|r|r.name==*unit)) + || self.settings.permits_msi(&job)), "SYSTEM_ABANDON_POLICY_DENIED" ); self.sync()?; @@ -1063,6 +1109,9 @@ impl SystemHelper { ), "SYSTEM_SIGNED_SYNC_REQUIRED" ); + if job.action.windows_msi().is_some() { + return self.execute_msi(generation, request, &job, &permit, peer); + } let mut provider = PreparedService::prepare(&self.settings, &job)?; self.recheck()?; peer.check()?; @@ -1101,6 +1150,211 @@ impl SystemHelper { ledger::finish(&self.db, &permit, &outcome)?; Ok(outcome) } + fn execute_msi( + &mut self, + generation: u64, + request: &Request, + job: &JobPayload, + permit: &ExecutionPermitPayload, + peer: &mut ipc::PeerProof, + ) -> Result { + use crate::package::{Prepared, Run}; + self.observe_unsettled_msi()?; + ensure!( + self.unsettled_msi.is_none(), + "SYSTEM_MSI_PREVIOUS_PROCESS_UNSETTLED" + ); + let began = Instant::now(); + let original_request_sha256 = hash(&serde_json::to_vec(request)?); + let timeout = Duration::from_secs(job.max_runtime_seconds.into()); + let m = job + .action + .windows_msi() + .context("SYSTEM_MSI_MANIFEST_REQUIRED")?; + ensure!( + self.settings.permits_msi(job), + "SYSTEM_MSI_RECIPE_NOT_ALLOWED" + ); + // No implicit bootstrap: reject absent/unprotected cache before consume. + let _cache = PinnedFile::open(Path::new(crate::msi_cache::CACHE), true, &[], &[], false) + .context("MSI_CACHE_NOT_CONFIGURED")?; + self.recheck()?; + peer.check()?; + ensure!( + self.sync.as_ref().unwrap().can_start( + &self.db, + &self.guard, + generation, + &self.clock, + &self.boot + ), + "SYSTEM_SIGNED_SYNC_REQUIRED" + ); + let (_, fresh, recorded_at) = + verified_window(&self.settings.binding, request, &self.clock)?; + ensure!( + &fresh == permit && !STOP.load(Ordering::SeqCst), + "SYSTEM_MSI_START_FENCED" + ); + ledger::begin_execution( + &mut self.db, + permit, + request, + self.boot.current_boot()?, + recorded_at, + )?; + self.sync.as_mut().unwrap().close(); + let result = (|| -> Result { + ensure!( + began.elapsed() < timeout, + "MSI_PREPARATION_TIMEOUT_NO_INSTALLER_START" + ); + crate::helper_runtime::intent::Store::require_not_denied( + request, + self.boot.current_boot()?, + generation, + &self.pin.policy_sha256, + &self.pin.helper.binary_sha256, + )?; + let _copied_archive = crate::msi_cache::import(m, permit.grant_id)?; + ensure!( + began.elapsed() < timeout, + "MSI_PREPARATION_TIMEOUT_NO_INSTALLER_START" + ); + let provider = Prepared::prepare(m, &m.recipe_sha256, began, timeout)?; + let run = provider.start(began, timeout, &STOP, || { + self.recheck()?; + peer.check()?; + ensure!( + !STOP.load(Ordering::SeqCst), + "SYSTEM_MSI_CANCELLED_BEFORE_START" + ); + verified_window(&self.settings.binding, request, &self.clock)?; + crate::helper_runtime::intent::Store::require_not_denied( + request, + self.boot.current_boot()?, + generation, + &self.pin.policy_sha256, + &self.pin.helper.binary_sha256, + )?; + Ok(()) + })?; + let observation = match run { + Run::Noop(value) => *value, // Noop variant can itself be Unknown. + Run::Installer(mut child) => loop { + // Continue observing this original transaction after start. + // A lost clock/peer/agent-denial observation cannot free the + // lane or retroactively produce success; never kill/retry. + let fenced = STOP.load(Ordering::SeqCst) + || self.clock.now().is_err() + || peer.check().is_err() + || self + .boot + .current_boot() + .and_then(|boot| { + crate::helper_runtime::intent::Store::require_not_denied( + request, + boot, + generation, + &self.pin.policy_sha256, + &self.pin.helper.binary_sha256, + ) + }) + .is_err(); + let cancelled = AtomicBool::new(fenced); + match child.poll(&cancelled) { + Ok(Some(mut value)) => { + if fenced { + value.state = "unknown"; + value.code = "MSI_RUNNING_OBSERVATION_FENCED"; + value.postconditions_passed = false; + } + if value.state == "unknown" { + self.unsettled_msi = Some(UnsettledMsi { + grant: permit.grant_id, + request_sha256: original_request_sha256.clone(), + installer: child, + }); + } + break value; + } + Ok(None) => std::thread::sleep(Duration::from_millis(50)), + Err(error) => { + let outcome = Outcome { + evidence: serde_json::json!({"provider":"windows.msi.fixture/1","recipe_sha256":m.recipe_sha256,"artifact_sha256":m.recipe.artifact.sha256,"postconditions_passed":false,"installer_process_started":true,"process_id":child.process_id(),"automatic_retry":false,"observer_error":safe_error(&error)}), + ..Outcome::unknown("MSI_OBSERVER_FAILED_EFFECT_UNRESOLVED") + }; + self.unsettled_msi = Some(UnsettledMsi { + grant: permit.grant_id, + request_sha256: original_request_sha256.clone(), + installer: child, + }); + return Ok(outcome); + } + } + }, + }; + let mut evidence = serde_json::to_value(&observation)?; + evidence["provider"] = "windows.msi.fixture/1".into(); + let mut outcome = Outcome { + state: observation.state.into(), + stdout: vec![], + stderr: vec![], + exit_code: observation.exit_code.map(|v| v as i32), + output_truncated: false, + reboot_required: observation.installer_reboot_required.unwrap_or(false), + error_code: if observation.state == "succeeded" { + String::new() + } else { + observation.code.into() + }, + evidence, + }; + if outcome.state == "succeeded" { + let fresh = self.clock.now().is_ok() && peer.check().is_ok(); + if !fresh || began.elapsed() >= timeout { + outcome.state = "unknown".into(); + outcome.error_code = "MSI_FINAL_OBSERVATION_FENCED".into(); + outcome.evidence["postconditions_passed"] = false.into(); + } + } + Ok(outcome) + })(); + let outcome = result.unwrap_or_else(|error| { + let code = safe_error(&error); + Outcome {state:if began.elapsed() >= timeout {"unknown"} else {"failed"}.into(), + evidence:serde_json::json!({"provider":"windows.msi.fixture/1","recipe_sha256":m.recipe_sha256,"artifact_sha256":m.recipe.artifact.sha256,"postconditions_passed":false,"installer_process_started":false,"transaction_started":false,"automatic_retry":false}), ..Outcome::unknown(&code)} + }); + ledger::persist_outcome(&self.db, permit, &outcome)?; + self.guard.check(&self.db)?; + ledger::finish(&self.db, permit, &outcome)?; + Ok(outcome) + } + fn observe_unsettled_msi(&mut self) -> Result<()> { + let Some(slot) = self.unsettled_msi.as_mut() else { + return Ok(()); + }; + self.guard.check(&self.db)?; + let (start, outcome): (Vec, Vec) = self.db.query_row( + "SELECT start,outcome FROM execution_evidence WHERE grant_id=?1", + [slot.grant.to_string()], + |r| Ok((r.get(0)?, r.get(1)?)), + )?; + let start: serde_json::Value = serde_json::from_slice(&start)?; + let original: Request = serde_json::from_value(start["request"].clone())?; + let saved: Outcome = serde_json::from_slice(&outcome)?; + ensure!( + hash(&serde_json::to_vec(&original)?) == slot.request_sha256 + && saved.state == "unknown", + "SYSTEM_MSI_UNSETTLED_ORIGINAL_BINDING" + ); + if slot.installer.process_exited()? { + self.unsettled_msi = None; + } + // No ledger/outcome update here. An observed late exit never revises + // the original deadline outcome or grants permission for another job. + Ok(()) + } } pub fn safe_error(error: &anyhow::Error) -> String { if error.chain().any(|cause| { @@ -1176,6 +1430,12 @@ unsafe extern "system" fn service_main(_: u32, _: *mut *mut u16) { let server = ipc::Server::bind(helper.pin().clone())?; scm_status(SERVICE_RUNNING, 0); while !STOP.load(Ordering::SeqCst) { + // A failed observation keeps the owned slot and its handles locked. + if helper.observe_unsettled_msi().is_err() + && let Some(sync) = &mut helper.sync + { + sync.close(); + } match server.receive() { Ok(Some(mut incoming)) => { let reply = helper.handle(&incoming.call, &mut incoming.peer); @@ -1230,6 +1490,56 @@ pub fn dispatch() -> Result<()> { mod tests { use super::*; #[test] + fn old_settings_omit_new_scope_and_only_v2_exact_recipe_hash_and_budget_allow_msi() { + let job = crate::helper_runtime::msi_test_job(); + let m = job.action.windows_msi().unwrap(); + let peer = PeerPin { + service_name: "synthetic".into(), + service_sid: "synthetic".into(), + user_sid: "synthetic".into(), + binary: PathBuf::from("synthetic"), + binary_sha256: "ab".repeat(32), + }; + let mut settings = Settings { + schema_version: 1, + binding: Binding { + tenant_id: job.tenant_id, + asset_id: job.asset_id, + agent_id: job.agent_id, + enrollment_generation: 1, + assignment_version: 1, + public_key_hex: "ab".repeat(32), + }, + agent: peer.clone(), + helper: peer, + allowed_services: vec![], + max_runtime_seconds: 30, + enable_effects: false, + allow_reboot: false, + allowed_msi_recipe_sha256: None, + }; + let legacy = serde_json::to_value(&settings).unwrap(); + assert!(legacy.get("allowed_msi_recipe_sha256").is_none()); + let mut null = legacy.clone(); + null["allowed_msi_recipe_sha256"] = serde_json::Value::Null; + assert!(serde_json::from_value::(null).is_err()); + assert!(!settings.permits_msi(&job)); + settings.allowed_msi_recipe_sha256 = Some(vec![m.recipe_sha256.clone()]); + assert!(!settings.permits_msi(&job)); + assert_eq!( + settings.validate().unwrap_err().to_string(), + "SYSTEM_POLICY_PROFILE" + ); + settings.schema_version = 2; + assert!(settings.permits_msi(&job)); + assert!(!settings.enable_effects); + settings.max_runtime_seconds = 29; + assert!(!settings.permits_msi(&job)); + settings.max_runtime_seconds = 30; + settings.allowed_msi_recipe_sha256 = Some(vec!["cd".repeat(32)]); + assert!(!settings.permits_msi(&job)); + } + #[test] fn service_adapter_exposes_only_implemented_states() { assert_eq!(desired_state("running").unwrap(), SERVICE_RUNNING); assert_eq!(desired_state("stopped").unwrap(), SERVICE_STOPPED); diff --git a/crates/agent-windows/src/lib.rs b/crates/agent-windows/src/lib.rs index 9a13216..2658da5 100644 --- a/crates/agent-windows/src/lib.rs +++ b/crates/agent-windows/src/lib.rs @@ -18,6 +18,9 @@ pub mod inventory; #[cfg(windows)] pub mod job_binding; pub mod journal; +pub mod package; +#[cfg(all(windows, feature = "system-helper"))] +pub mod msi_cache; #[cfg(windows)] pub mod native; #[cfg(windows)] diff --git a/crates/agent-windows/src/msi_cache.rs b/crates/agent-windows/src/msi_cache.rs new file mode 100644 index 0000000..f2baa59 --- /dev/null +++ b/crates/agent-windows/src/msi_cache.rs @@ -0,0 +1,178 @@ +//! Fixed public-byte staging and independent SYSTEM cache import. No IPC path, +//! URL or byte-array authority. Directories must be provisioned separately; +//! this module never installs/repairs an ACL, directory, policy or service. +use crate::helper_ipc::{self as ipc, PinnedFile}; +use anyhow::{Context, Result, ensure}; +use rmm_domain::windows_execution::ResolvedWindowsMsi; +use sha2::{Digest, Sha256}; +use std::{ + fs::{File, OpenOptions}, + io::{Read, Write}, + mem::zeroed, + os::windows::{ + fs::OpenOptionsExt, + io::{AsRawHandle, FromRawHandle}, + }, + path::{Path, PathBuf}, + ptr, +}; +use uuid::Uuid; +use windows_sys::Win32::{Foundation::*, Storage::FileSystem::*}; + +pub const AGENT_STATE: &str = r"C:\ProgramData\RustDiscovery\state"; +pub const STAGE: &str = r"C:\ProgramData\RustDiscovery\state\msi-stage"; +pub const CACHE: &str = r"C:\ProgramData\RustDiscoverySystem\cache"; +fn name(m: &ResolvedWindowsMsi) -> Result { + ensure!(m.validate(), "MSI_CACHE_MANIFEST"); + Ok(format!("{}.msi", m.recipe.artifact.sha256)) +} +fn regular(file: &File, directory: bool) -> Result<()> { + let mut i: BY_HANDLE_FILE_INFORMATION = unsafe { zeroed() }; + ensure!( + unsafe { GetFileInformationByHandle(file.as_raw_handle(), &mut i) } != 0 + && i.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT == 0 + && (i.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY != 0) == directory + && (directory || i.nNumberOfLinks == 1), + "MSI_CACHE_NONREGULAR" + ); + Ok(()) +} +/// Keep every actual parent open without DELETE sharing throughout the copy. +/// Source data/ACL is untrusted; only the original signed digest authorizes bytes. +fn parents(path: &Path) -> Result> { + let mut held = Vec::new(); + for p in path.ancestors().skip(1) { + let raw = unsafe { + CreateFileW( + ipc::wide(p).as_ptr(), + FILE_READ_ATTRIBUTES, + FILE_SHARE_READ | FILE_SHARE_WRITE, + ptr::null(), + OPEN_EXISTING, + FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, + ptr::null_mut(), + ) + }; + ensure!( + raw != INVALID_HANDLE_VALUE, + "MSI_CACHE_PARENT_NOT_CONFIGURED" + ); + let file = unsafe { File::from_raw_handle(raw) }; + regular(&file, true)?; + held.push(file); + } + Ok(held) +} +fn checked_bytes(path: &Path, m: &ResolvedWindowsMsi) -> Result> { + let _parents = parents(path)?; + let mut file = OpenOptions::new() + .read(true) + .share_mode(FILE_SHARE_READ) + .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT) + .open(path) + .context("MSI_STAGE_NOT_CONFIGURED")?; + regular(&file, false)?; + let id = ipc::file_identity(&file)?; + ensure!( + file.metadata()?.len() == m.recipe.artifact.bytes && m.recipe.artifact.bytes <= 262144, + "MSI_CACHE_LENGTH" + ); + let mut bytes = Vec::new(); + (&mut file).take(262145).read_to_end(&mut bytes)?; + ensure!( + bytes.len() as u64 == m.recipe.artifact.bytes + && format!("{:x}", Sha256::digest(&bytes)) == m.recipe.artifact.sha256, + "MSI_CACHE_DIGEST" + ); + let again = OpenOptions::new() + .read(true) + .share_mode(FILE_SHARE_READ) + .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT) + .open(path)?; + regular(&again, false)?; + ensure!(ipc::file_identity(&again)? == id, "MSI_CACHE_FILE_REPLACED"); + Ok(bytes) +} +pub fn stage_configured() -> bool { + crate::native::private_path(Path::new(STAGE), true).is_ok() +} +/// Called by LocalService only for the already approved original job/attempt. +pub fn stage(m: &ResolvedWindowsMsi, bytes: &[u8]) -> Result<()> { + crate::native::require_local_service()?; + let path = Path::new(STAGE).join(name(m)?); + let _parents = parents(&path)?; + crate::native::private_path(Path::new(STAGE), true)?; + ensure!( + bytes.len() as u64 == m.recipe.artifact.bytes + && format!("{:x}", Sha256::digest(bytes)) == m.recipe.artifact.sha256, + "MSI_DOWNLOAD_DIGEST" + ); + if path.try_exists()? { + ensure!(checked_bytes(&path, m)? == bytes, "MSI_STAGE_CONFLICT"); + return Ok(()); + } + let mut file = OpenOptions::new() + .read(true) + .write(true) + .create_new(true) + .share_mode(FILE_SHARE_READ) + .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT) + .open(&path)?; + regular(&file, false)?; + let id = ipc::file_identity(&file)?; + file.write_all(bytes)?; + file.sync_all()?; + ensure!(ipc::file_identity(&file)? == id, "MSI_STAGE_FILE_CHANGED"); + drop(file); + crate::native::private_path(&path, false)?; + ensure!(checked_bytes(&path, m)? == bytes, "MSI_STAGE_CONFLICT"); + Ok(()) +} +/// Called ONLY after full independent helper authorization and durable consume. +/// Publish to the fixed SYS/Admin cache without replacing any existing entry. +/// Returned guards pin the copied archive until the provider holds its own. +pub fn import(m: &ResolvedWindowsMsi, grant: Uuid) -> Result> { + let file_name = name(m)?; + ensure!(!grant.is_nil(), "MSI_CACHE_GRANT"); + let destination = Path::new(CACHE).join(file_name); + let _parents = parents(&destination)?; + let root = PinnedFile::open(Path::new(CACHE), true, &[], &[], false) + .context("MSI_CACHE_NOT_CONFIGURED")?; + if destination.try_exists()? { + let archive = PinnedFile::open(&destination, false, &[], &[], false)?; + checked_bytes(&destination, m)?; + return Ok(vec![root, archive]); + } + let source: PathBuf = Path::new(STAGE).join(name(m)?); + let bytes = checked_bytes(&source, m)?; // Never trust actor ownership/data. + let pending = Path::new(CACHE).join(format!("{}.{}.pending", m.recipe.artifact.sha256, grant)); + let mut file = OpenOptions::new() + .read(true) + .write(true) + .create_new(true) + .share_mode(FILE_SHARE_READ) + .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT) + .open(&pending)?; + regular(&file, false)?; + file.write_all(&bytes)?; + file.sync_all()?; + drop(file); + // Cache directory was already independently validated SYS/Admin-only. New + // SYSTEM-created files inherit that boundary; no ACL repair is performed. + let copied = PinnedFile::open(&pending, false, &[], &[], false)?; + checked_bytes(&pending, m)?; + drop(copied); + ensure!( + unsafe { + MoveFileExW( + ipc::wide(&pending).as_ptr(), + ipc::wide(&destination).as_ptr(), + 0, + ) + } != 0, + "MSI_CACHE_CREATE_ONLY_PUBLICATION" + ); + let archive = PinnedFile::open(&destination, false, &[], &[], false)?; + checked_bytes(&destination, m)?; + Ok(vec![root, archive]) +} diff --git a/crates/agent-windows/src/package.rs b/crates/agent-windows/src/package.rs index 22ceeab..6f0b0cd 100644 --- a/crates/agent-windows/src/package.rs +++ b/crates/agent-windows/src/package.rs @@ -17,9 +17,10 @@ use anyhow::{Result, ensure}; #[cfg(any(windows, test))] use rmm_domain::windows_execution::{ResolvedWindowsMsi, valid_package_code}; -use serde::Serialize; +use serde::{Deserialize, Serialize}; -#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize)] +#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] pub struct Snapshot { pub product_code: String, pub package_code: Option, @@ -34,7 +35,7 @@ pub struct Snapshot { } impl Snapshot { #[cfg(any(windows, test))] - fn desired(&self, r: &ResolvedWindowsMsi) -> bool { + pub(crate) fn desired(&self, r: &ResolvedWindowsMsi) -> bool { let p = &r.recipe.postcondition; self.product_code == p.product_code && self.related_products == [p.product_code.clone()] @@ -854,8 +855,17 @@ mod windows { system_root: PathBuf, } impl Prepared { - pub fn prepare(r: &ResolvedWindowsMsi, allowed_recipe_sha256: &str) -> Result { + pub fn prepare( + r: &ResolvedWindowsMsi, + allowed_recipe_sha256: &str, + began: Instant, + timeout: Duration, + ) -> Result { validate(r, allowed_recipe_sha256)?; + ensure!( + within_budget(began, timeout), + "MSI_PREPARATION_TIMEOUT_NO_INSTALLER_START" + ); let mut roots = Vec::new(); for path in [CACHE, FIXTURES] { let file = OpenOptions::new() @@ -872,9 +882,17 @@ mod windows { false, )?; inspect_archive(&mut archive, r)?; + ensure!( + within_budget(began, timeout), + "MSI_PREPARATION_TIMEOUT_NO_INSTALLER_START" + ); let system_root = system_root()?; let msiexec = Held::open(&system_root.join("System32").join("msiexec.exe"), true)?; let before = snapshot_for(r)?; + ensure!( + within_budget(began, timeout), + "MSI_PREPARATION_TIMEOUT_NO_INSTALLER_START" + ); ensure!( before.baseline_allowed(r), "MSI_EXISTING_PRODUCT_OR_PAYLOAD_CONFLICT" @@ -911,6 +929,7 @@ mod windows { /// config, privilege, policy, clock, reboot or foreign process occurs. pub fn start( mut self, + began: Instant, timeout: Duration, cancelled: &AtomicBool, check_effect_fence: impl FnOnce() -> Result<()>, @@ -923,7 +942,6 @@ mod windows { ); // One original budget includes all synchronous verification and // the eventual installer. A late Noop is not retroactive success. - let began = Instant::now(); let archive = inspect_archive(&mut self.archive, &self.recipe); if !within_budget(began, timeout) { return Ok(self.verification_timeout(None)); @@ -1010,6 +1028,11 @@ mod windows { timeout: Duration, } impl Installer { + /// Observe only this retained process handle. Never adopt a PID, kill, + /// restart, or revise an already persisted timeout outcome. + pub fn process_exited(&mut self) -> Result { + Ok(self.child.try_wait()?.is_some()) + } pub fn process_id(&self) -> u32 { self.child.id() } diff --git a/crates/agent-windows/src/runtime.rs b/crates/agent-windows/src/runtime.rs index 90c5b80..7b358cb 100644 --- a/crates/agent-windows/src/runtime.rs +++ b/crates/agent-windows/src/runtime.rs @@ -367,6 +367,25 @@ struct Agent { impl Agent { fn close_gate(&mut self) { self.fence.close(); + #[cfg(feature = "system-helper")] + if let Some(running) = &self.running + && running.grant.execution_identity == "system" + { + running.cancel.store(true, Ordering::SeqCst); + let denied = (|| -> Result<()> { + let mut store = rmm_agent_windows::helper_runtime::intent::Store::open(true)?; + let intent = store.by_grant(running.grant.grant_id)?; + ensure!( + intent.permit()? == running.grant, + "SYSTEM_CANCEL_GRANT_BINDING" + ); + store.deny(&intent.request, Uuid::parse_str(&self.boot)?) + })(); + if denied.is_err() { + self.helper_refused = true; + eprintln!("SYSTEM_CANCEL_PERSISTENCE_FAILED"); + } + } if let Some(sync) = &mut self.sync { sync.close(); } @@ -566,7 +585,11 @@ impl Agent { } #[cfg(feature = "system-helper")] { - Path::new(rmm_agent_windows::helper_runtime::intent::DB).is_file() + (job.action.windows_msi().is_none() + || (self.config.state_directory + == Path::new(rmm_agent_windows::msi_cache::AGENT_STATE) + && rmm_agent_windows::msi_cache::stage_configured())) + && Path::new(rmm_agent_windows::helper_runtime::intent::DB).is_file() && self .helper .as_ref() @@ -983,9 +1006,69 @@ impl Agent { let completed = self.completed_tx.clone(); let work_offer = offer.clone(); let work_grant = grant.clone(); + let msi = job.action.windows_msi().cloned(); + let address = self.config.connect_address; + let ca = self.ca.clone(); + let state = self.config.state_directory.clone(); + let request_for_stage = request.clone(); + let binding_for_stage = binding.clone(); let worker = tokio::spawn(async move { + let staged = if let Some(m) = msi { + let result = async { + ensure!( + !worker_cancel.load(Ordering::SeqCst) + && fence.allows_identity(generation, true, &clock), + "MSI_DOWNLOAD_FENCED" + ); + verified_window(&binding_for_stage, &request_for_stage, &clock)?; + let cert = protected_read(&state.join("device.pem"), 32768)?; + let key = protected_read(&state.join("device.key"), 16384)?; + let tls = crate::https_channel::mtls_client(address, &ca, &cert, &key)?; + let response = tls + .get(format!( + "https://{}:{}/agent/v1/artifacts/{}?job_id={}&attempt_id={}", + crate::https_channel::server_name()?, + address.port(), + m.recipe.artifact.artifact_id, + work_grant.job_id, + work_grant.attempt_id + )) + .send() + .await?; + ensure!( + response + .headers() + .get("x-artifact-sha256") + .and_then(|v| v.to_str().ok()) + == Some(m.recipe.artifact.sha256.as_str()), + "MSI_DOWNLOAD_METADATA" + ); + let bytes = crate::https_channel::bounded_body( + response, + m.recipe.artifact.bytes as usize, + "application/octet-stream", + ) + .await?; + ensure!( + !worker_cancel.load(Ordering::SeqCst) + && fence.allows_identity(generation, true, &clock), + "MSI_DOWNLOAD_FENCED" + ); + verified_window(&binding_for_stage, &request_for_stage, &clock)?; + tokio::task::spawn_blocking(move || { + rmm_agent_windows::msi_cache::stage(&m, &bytes) + }) + .await??; + Ok::<_, anyhow::Error>(()) + } + .await; + result.is_ok() + } else { + true + }; let _result = helper .delegate(intent, move || { + ensure!(staged, "MSI_DOWNLOAD_NOT_READY"); ensure!( !worker_cancel.load(Ordering::SeqCst), "CANCELLED_BEFORE_DISPATCH" @@ -1298,7 +1381,7 @@ impl Agent { #[cfg(feature="system-helper")] if Path::new(rmm_agent_windows::helper_runtime::intent::DB).is_file() { let mut store=rmm_agent_windows::helper_runtime::intent::Store::open(true)?; - if let Some(intent)=store.pending()?.first() && intent.permit()?.job_id.to_string()==cancel.job_id && intent.permit()?.attempt_id.to_string()==cancel.attempt_id {store.cancel_before_dispatch(intent.id)?;} + if let Some(intent)=store.pending()?.first() && intent.permit()?.job_id.to_string()==cancel.job_id && intent.permit()?.attempt_id.to_string()==cancel.attempt_id {store.deny(&intent.request,Uuid::parse_str(&self.boot)?)?;store.cancel_before_dispatch(intent.id)?;} } if state=="accepted" {self.record(generation,&JobOffer::decode(bytes.as_slice())?,&grant,jobs::no_start("cancelled","CANCELLED_BEFORE_START"))?;needs_sync=true;} } diff --git a/docs/windows-msi-runtime.md b/docs/windows-msi-runtime.md new file mode 100644 index 0000000..4b6607c --- /dev/null +++ b/docs/windows-msi-runtime.md @@ -0,0 +1,89 @@ +# Windows MSI runtime: implementierter, noch nicht nativ abgenommener Schnitt + +Stand 2026-11-14, isolierter Zweig `codex/windows-msi-runtime`, Basis `66c1855`. +Dies ist ein Quellen-/Lokalnachweis. Es wurde damit kein Windows-Installer, +RMM-Job, Dienstwechsel oder Bootstrap am Ziel ausgeführt. Die nativen +Domain-/Backend-Nachweise des vorhergehenden M4-Schritts ersetzen die folgenden +noch offenen Runtime-Nachweise nicht. + +## Implementierte Grenze + +Der Network-Agent lädt ausschließlich das im genehmigten Originaljob gebundene +MSI-Artefakt über den bestehenden mTLS-Client und den festen Agent-Endpunkt. +Es gibt keine Installer-URL, Weiterleitung, Bearer-Abkürzung oder abgeschaltete +TLS-Prüfung. Länge und SHA-256 sind auf das Manifest und höchstens 256 KiB +begrenzt. Das Staging liegt unter dem festen Agentzustandsverzeichnis. + +Der SYSTEM-Helper nimmt weiterhin nur die originale signierte Request an, +keinen Callerpfad und keine Installerbytes. Settings-Schema 1 bleibt SCM-only; +Schema 2 kann höchstens zwei genaue Recipe-SHA-256 freigeben. Fehlende neue +Settings-Felder werden beim Serialisieren ausgelassen; vorhandenes `null` ist +kein erlaubter Recipe-Allowlistwert. Die lokale Allowlist begrenzt ausschließlich +und ersetzt weder Plan, Startgrant, Clock noch signierten Sync. + +Vor einer SYSTEM-Cachekopie persistiert der Helper den atomaren Originalstart +mit Verbrauch. Die Kopie verwendet den manifestabgeleiteten SHA-Pfad, prüft +Nicht-Reparse, Elternhandles, File-ID, Länge, Hash und die SYS/Admin-Cachegrenze. +Neue Cacheeinträge werden ohne Ersetzen bestehender Dateien veröffentlicht. +Cache/Staging müssen vorher eingerichtet sein; der Runtimecode repariert weder +ACLs noch Verzeichnisse. Der Provider hält eigene Archiv-/Prozesshandles. + +Ein originales monotones Laufzeitbudget umfasst SYSTEM-Cacheaufbereitung, +MSI-Metadaten, unabhängige Bestandsprüfung, Noopentscheidung und Installerlauf. +Die festen Argumente und MSI-Tabellenprüfungen bleiben erhalten. Erfolg benötigt +unabhängige Product-/Family-/PackageCode-/Payload-Nachbedingungen; `3010` bleibt +als Rebootbedarf sichtbar, `1641` unklar, `1618` ein fehlgeschlagener eigener +Start. Noop hat keinen Installerexitcode. Weder automatischer Reboot noch +allgemeines `msiexec`-Kill oder automatischer Wiederholungsstart sind enthalten. + +Die vorhandene Intentzeile besitzt zusätzlich eine dauerhafte, ausschließlich +verweigernde Abbruchmarkierung. Sie ist nur von 0 nach 1 änderbar; Originalbytes, +Grant und `may_have_dispatched` werden dabei nicht zurückgesetzt. Eine eng +geprüfte additive Migration akzeptiert nur die bisherige genaue Tabellen- und +Triggerdefinition. Der Helper liest die vollständige Originalbindung über eine +jeweils frische gewöhnliche Read-only-Verbindung vor Noop/Start und während der +Beobachtung. Fehlende, fehlerhafte oder gesperrte Beobachtung verweigert. Dies ist +keine zusätzliche Ausführungsautorität. Zwischen letzter Prüfung und OS-Start +bleibt das übliche kleine Rennen; es gibt kein behauptetes Rückgängigmachen. + +Nach unklarem Timeout oder Beobachtungsfehler hält der Helper den eigenen Child, +Archivhandles und Originalgrant-/Requestbindung in einem ungeklärten Slot. +Weitere MSI-Starts werden bis zur Beobachtung desselben Prozessendes verweigert. +Ein späterer Exit ändert das bereits persistierte `unknown` nicht. Nach einem +Helperabsturz bleibt die ursprüngliche Ledger-Sperre bestehen. Intent, Abandon, +RawMirror und signierter Core-Sync behalten ihre strengen Originalbindungen; +keine Missing-row-Regel wurde gelockert. + +## Tatsächlich lokale Prüfung + +Der private Fall `qualified-ee6681c7-8d9d-4af9-8947-5325e1ea2e0f` unter +`devstate/windows-msi-runtime/` bindet 82 Compiler-/Manifestquellen vor und nach +allen qualifizierten Prüfungen identisch. Qualification-SHA-256: +`17f3eb2258773a22be26afd9681d271f69136cfb52dbda31aac2a0ef577b3816`. + +- Linux-Container: 10 Bibliothekstests ausgeführt, 10 bestanden, 0 ignoriert. +- Windows-GNU: Default- und SYSTEM-Feature-Alltargets-Clippy mit `-D warnings` + bestanden. +- Windows-GNU: Lib-/Agent-Bin-Unittests gelinkt, nicht ausgeführt. +- Windows-GNU: beide Releasebinaries gelinkt; AMD64-PE geprüft. Originale und + mit `--strip-all` bearbeitete Auslieferungsdateien sind getrennt erhalten. +- `git diff --check` bestanden. Keine Domain-/Core-/Server-/Web- oder + Root-Cargo-/Lockänderung. + +Release-Auslieferung Agent: +`7d9b1221ccb3587437d0866296472330947a16445c4e40069981fc4197242d83`. +Release-Auslieferung Helper: +`96589d53d366a0ccbd60c301fd3d1f03cd4d9f93d85bdcb3ce9b7f4647afc273`. +Die Zwischenbelege vor der ergänzten laufenden Abbruchbeobachtung bleiben +historisch erhalten und sind nicht die finale Qualification. + +## Noch offen + +Die Windows-Unitbinaries, Cache-/Staging-ACLs und gehaltenen Handles, tatsächliche +PERSIST-Migration mit konkurrierender Deny-Lesung, Installer 1.0, MajorUpgrade +1.1, beide Noops und die Abbruch-/Unklarheitsfälle müssen auf der Windows-VM +nachgewiesen werden. Installerjobs benötigen jeweils die reale WebUI-Grenze. +Capabilityliste bleibt passiv, Clock-Gate unqualifiziert, Job-/Effektdefaults +bleiben geschlossen. Diese Implementierung behauptet weder native MSI-Abnahme +noch Windows-MVP-Abschluss. EXE, WinGet, allgemeine Installerargumente oder eine +neue Rebootstrecke gehören nicht zu diesem Schnitt.