Implement bounded Windows MSI delegation with deny-only cancellation and retained installer ownership
Rust development slice / linux (push) Failing after 7s

This commit is contained in:
2026-11-14 13:53:05 +01:00
parent 66c1855056
commit 66e77ad83e
9 changed files with 996 additions and 16 deletions
+312 -2
View File
@@ -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<Vec<String>>,
}
fn strict_recipe_hashes<'de, D: serde::Deserializer<'de>>(
d: D,
) -> std::result::Result<Option<Vec<String>>, D::Error> {
Vec::<String>::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::<std::collections::BTreeSet<_>>()
.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<crate::package::Installer>,
}
pub struct SystemHelper {
settings: Settings,
pin: Pin,
@@ -773,6 +816,7 @@ pub struct SystemHelper {
boot: WindowsBoot,
sync: Option<HelperSync<DalekVerifier>>,
last_diagnostic: Option<Instant>,
unsettled_msi: Option<UnsettledMsi>,
}
impl SystemHelper {
pub fn open() -> Result<Self> {
@@ -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<Outcome> {
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<Outcome> {
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<u8>, Vec<u8>) = 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::<Settings>(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);