Integrate independent signed Windows clocks with native Linux lease guards
Rust development slice / linux (push) Failing after 6s
Rust development slice / linux (push) Failing after 6s
This commit is contained in:
@@ -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"],
|
||||
|
||||
Reference in New Issue
Block a user