Integrate independent signed Windows clocks with native Linux lease guards
Rust development slice / linux (push) Failing after 6s

This commit is contained in:
2026-11-15 10:26:24 +01:00
parent 6ddfc95fff
commit 09f7e5af84
13 changed files with 1093 additions and 37 deletions
+114 -10
View File
@@ -18,8 +18,8 @@
//! must be empty; recovery is empty/SC_ACTION_NONE with no command/reboot text.
//! These are read-only admission checks, never implicit configuration repairs.
use crate::{
clock::NativeClock,
helper_ipc::{self as ipc, Call, Operation, PeerPin, Pin, PinnedFile, Reply, ReplyBody},
signed_clock::{BoundClock, RuntimeClock},
};
use anyhow::{Context, Result, ensure};
use fs2::FileExt;
@@ -31,6 +31,7 @@ use rmm_agent_core::{
NoStartGuard,
},
ledger,
reconcile::SyncClock as _,
};
use rmm_domain::jobs::{Action, ExecutionPermitPayload, JobPayload, hash};
use rusqlite::{Connection, OptionalExtension};
@@ -836,7 +837,7 @@ pub struct SystemHelper {
files: Vec<PinnedFile>,
guard: LedgerGuard,
db: Connection,
clock: NativeClock,
clock: BoundClock,
boot: WindowsBoot,
sync: Option<HelperSync<DalekVerifier>>,
last_diagnostic: Option<Instant>,
@@ -849,7 +850,7 @@ impl SystemHelper {
let pin = settings.pin()?;
ipc::publish_self_query_rights(&settings.agent.service_sid, &settings.helper.service_sid)?;
let (guard, db) = LedgerGuard::acquire(&settings.helper.service_sid, &settings.binding)?;
let clock = NativeClock::new();
let clock = RuntimeClock::new(rmm_time_attestation::Role::SystemHelper).for_generation(0);
let boot = WindowsBoot::capture()?;
let sync = HelperSync::with_verifier(settings.binding.clone(), DalekVerifier, &clock)
.ok()
@@ -950,6 +951,11 @@ impl SystemHelper {
"SYSTEM_CALL_BINDING"
);
let response: Result<ReplyBody> = match &call.operation {
Operation::TimeBegin { .. }
| Operation::TimeComplete { .. }
| Operation::TimeClose { .. } => {
anyhow::bail!("SYSTEM_TIME_PIPE_REQUIRED")
}
Operation::Probe {} => {
let ready = self.settings.enable_effects
&& self
@@ -969,6 +975,7 @@ impl SystemHelper {
})
}
Operation::Snapshot { generation } => {
self.clock = self.clock.for_generation(*generation);
self.sync()?;
let snapshot = self.sync.as_mut().unwrap().snapshot(
&mut self.db,
@@ -983,6 +990,10 @@ impl SystemHelper {
response,
request_bytes,
} => {
let decision: rmm_domain::reconciliation::ReconcileDecisionPayload =
serde_json::from_slice(&response.decision_bytes)?;
self.clock
.require_generation(decision.connection_generation)?;
self.sync()?;
let value = self.sync.as_mut().unwrap().apply(
&mut self.db,
@@ -1094,6 +1105,7 @@ impl SystemHelper {
request: &Request,
peer: &mut ipc::PeerProof,
) -> Result<Outcome> {
self.clock.require_generation(generation)?;
// Historical signature validation can only return retained evidence. It
// never reopens a start window or authorizes an effect after expiry.
let parsed: ExecutionPermitPayload = serde_json::from_slice(&request.permit_bytes)?;
@@ -1167,12 +1179,19 @@ impl SystemHelper {
recorded_at,
)?;
self.sync.as_mut().unwrap().close();
let outcome = provider.execute(Duration::from_secs(job.max_runtime_seconds.into()), || {
self.recheck()?;
peer.check()?;
verified_window(&self.settings.binding, request, &self.clock)?;
Ok(())
});
let mut outcome =
provider.execute(Duration::from_secs(job.max_runtime_seconds.into()), || {
self.clock.require_generation(generation)?;
self.recheck()?;
peer.check()?;
verified_window(&self.settings.binding, request, &self.clock)?;
Ok(())
});
if outcome.state == "succeeded" && self.clock.reading().is_err() {
outcome.state = "unknown".into();
outcome.error_code = "SYSTEM_FINAL_CLOCK_UNTRUSTED".into();
outcome.evidence["postconditions_passed"] = false.into();
}
ledger::persist_outcome(&self.db, &permit, &outcome)?;
self.guard.check(&self.db)?;
ledger::finish(&self.db, &permit, &outcome)?;
@@ -1228,6 +1247,7 @@ impl SystemHelper {
|before_start| {
self.recheck()?;
peer.check()?;
self.clock.require_generation(generation)?;
self.clock.now()?;
ensure!(!STOP.load(Ordering::SeqCst), "SYSTEM_SCRIPT_CANCELLED");
crate::helper_runtime::intent::Store::require_not_denied(
@@ -1243,8 +1263,13 @@ impl SystemHelper {
Ok(())
},
);
let outcome =
let mut outcome =
result.unwrap_or_else(|_| Outcome::unknown("SYSTEM_SCRIPT_EFFECT_UNRESOLVED"));
if outcome.state == "succeeded" && self.clock.reading().is_err() {
outcome.state = "unknown".into();
outcome.error_code = "SYSTEM_FINAL_CLOCK_UNTRUSTED".into();
outcome.evidence["postconditions_passed"] = false.into();
}
ledger::persist_outcome(&self.db, permit, &outcome)?;
self.guard.check(&self.db)?;
ledger::finish(&self.db, permit, &outcome)?;
@@ -1528,6 +1553,12 @@ unsafe extern "system" fn service_main(_: u32, _: *mut *mut u16) {
let result = (|| -> Result<()> {
let mut helper = SystemHelper::open()?;
let server = ipc::Server::bind(helper.pin().clone())?;
let time_server = ipc::Server::bind_time(helper.pin().clone())?;
let time_pin = helper.pin().clone();
let time_clock = helper.clock.source();
let time_worker = std::thread::Builder::new()
.name("rmm-helper-time-control".into())
.spawn(move || time_control(time_server, time_pin, time_clock))?;
scm_status(SERVICE_RUNNING, 0);
while !STOP.load(Ordering::SeqCst) {
// A failed observation keeps the owned slot and its handles locked.
@@ -1558,10 +1589,83 @@ unsafe extern "system" fn service_main(_: u32, _: *mut *mut u16) {
}
}
}
// The time lane has no ledger/job operation and its receive wait is
// bounded. Shutdown closes its private evidence before service exit.
time_worker
.join()
.map_err(|_| anyhow::anyhow!("SYSTEM_TIME_WORKER_FAILED"))??;
Ok(())
})();
scm_status(SERVICE_STOPPED, if result.is_ok() { 0 } else { 1066 });
}
fn time_control(server: ipc::Server, pin: Pin, clock: RuntimeClock) -> Result<()> {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()?;
while !STOP.load(Ordering::SeqCst) {
let received = match server.receive() {
Ok(Some(value)) => value,
Ok(None) => continue,
Err(_) => {
clock.close()?;
server.disconnect();
continue;
}
};
let mut incoming = received;
let result = (|| -> Result<ReplyBody> {
incoming.peer.check()?;
let body = match &incoming.call.operation {
Operation::TimeBegin { generation } => {
if !clock.configured_for(*generation) {
runtime.block_on(clock.open_connection(*generation))?;
}
ReplyBody::TimeChallenge {
request: clock.begin(*generation)?,
}
}
Operation::TimeComplete {
generation,
response_bytes,
} => {
ensure!(response_bytes.len() <= 16384, "SYSTEM_TIME_RESPONSE_BOUND");
clock.complete(*generation, response_bytes)?;
ReplyBody::TimeCompleted {}
}
Operation::TimeClose { generation } => {
clock.close_generation(*generation)?;
ReplyBody::TimeClosed {}
}
_ => anyhow::bail!("SYSTEM_TIME_OPERATION_REQUIRED"),
};
incoming.peer.check()?;
Ok(body)
})();
let body = match result {
Ok(value) => value,
Err(_) => {
clock.close()?;
ReplyBody::Denied {
code: "SYSTEM_TIME_DENIED".into(),
}
}
};
let reply = Reply {
schema_version: 1,
challenge: incoming.call.challenge,
binding_sha256: ipc::binding_hash(&pin.binding)?,
policy_sha256: pin.policy_sha256.clone(),
helper_binary_sha256: pin.helper.binary_sha256.clone(),
body,
};
if server.reply(&reply, &mut incoming.peer).is_err() {
clock.close()?;
}
server.disconnect();
}
clock.close()
}
pub fn dispatch() -> Result<()> {
ensure!(
std::env::args().skip(1).collect::<Vec<_>>() == ["--service"],