Implement bounded Windows MSI delegation with deny-only cancellation and retained installer ownership
Rust development slice / linux (push) Failing after 7s
Rust development slice / linux (push) Failing after 7s
This commit is contained in:
@@ -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);
|
||||
|
||||
Reference in New Issue
Block a user