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
+223 -14
View File
@@ -35,7 +35,7 @@ struct Config {
transport: String,
#[serde(default)]
job_binding_file: Option<PathBuf>,
// False until the independent LocalService clock qualification is complete.
// Explicit protected opt-in only; this flag never qualifies a clock or pins.
#[serde(default)]
enable_jobs: bool,
}
@@ -123,14 +123,95 @@ async fn enrollment(config: &Config, ca: &[u8]) -> Result<EnrollmentResponse> {
}
#[derive(Clone)]
struct JobClock {
native: Arc<rmm_agent_windows::clock::NativeClock>,
#[cfg(feature = "system-helper")]
native: rmm_agent_windows::signed_clock::BoundClock,
enabled: bool,
}
impl JobClock {
fn new(enabled: bool) -> Self {
Self {
#[cfg(feature = "system-helper")]
native: rmm_agent_windows::signed_clock::RuntimeClock::new(
rmm_time_attestation::Role::Agent,
)
.for_generation(0),
enabled,
}
}
fn for_generation(&self, generation: u64) -> Self {
#[cfg(feature = "system-helper")]
{
Self {
native: self.native.for_generation(generation),
enabled: self.enabled,
}
}
#[cfg(not(feature = "system-helper"))]
{
let _ = generation;
self.clone()
}
}
}
impl SyncClock for JobClock {
fn now(&self) -> Result<chrono::DateTime<Utc>> {
ensure!(self.enabled, "WINDOWS_JOBS_NOT_ENABLED");
self.native.now()
Ok(self.reading()?.own_wall)
}
fn reading(&self) -> Result<reconcile::ClockReading> {
ensure!(self.enabled, "WINDOWS_JOBS_NOT_ENABLED");
#[cfg(feature = "system-helper")]
{
self.native.reading()
}
#[cfg(not(feature = "system-helper"))]
{
anyhow::bail!("WINDOWS_SIGNED_TIME_NOT_CONFIGURED")
}
}
}
#[cfg(feature = "system-helper")]
struct TimeRefresh {
generation: u64,
stop: Arc<AtomicBool>,
clock: rmm_agent_windows::signed_clock::RuntimeClock,
helper: Option<rmm_agent_windows::helper_runtime::Client>,
tasks: Vec<tokio::task::JoinHandle<()>>,
}
#[cfg(feature = "system-helper")]
impl Drop for TimeRefresh {
fn drop(&mut self) {
self.stop.store(true, Ordering::SeqCst);
let _ = self.clock.close_generation(self.generation);
for task in &self.tasks {
task.abort();
}
}
}
#[cfg(feature = "system-helper")]
async fn time_response(
client: &reqwest::Client,
address: std::net::SocketAddr,
request: &rmm_time_attestation::Request,
) -> Result<Vec<u8>> {
request.validate()?;
ensure!(
crate::https_channel::server_name()? == "discovery.ease-technologies.de",
"TIME_FIXED_SERVER"
);
tokio::time::timeout(Duration::from_millis(650), async {
let response = client
.post(format!(
"https://discovery.ease-technologies.de:{}/agent/v1/time-attestation",
address.port()
))
.timeout(Duration::from_millis(650))
.json(request)
.send()
.await?;
crate::https_channel::bounded_body(response, 16384, "application/json").await
})
.await
.context("TIME_HTTP_DEADLINE")?
}
#[derive(Default)]
struct EffectFence {
@@ -150,9 +231,9 @@ impl EffectFence {
(!helper || self.helper_generation.load(Ordering::SeqCst) == generation)
&& self.generation.load(Ordering::SeqCst) == generation
&& generation > 0
&& clock.now().is_ok_and(|now| {
(now + chrono::Duration::seconds(2)).timestamp_millis()
< self.deadline.load(Ordering::SeqCst)
&& clock.reading().is_ok_and(|reading| {
reading.own_wall.timestamp_millis() < self.deadline.load(Ordering::SeqCst)
&& reading.upper.timestamp_millis() < self.deadline.load(Ordering::SeqCst)
})
}
}
@@ -337,6 +418,8 @@ struct Agent {
ledger: Option<Connection>,
_ledger_file: Option<fs::File>,
clock: JobClock,
#[cfg(feature = "system-helper")]
time_refresh: Option<TimeRefresh>,
sync: Option<reconcile::ClientSync>,
prepared: bool,
#[cfg(feature = "system-helper")]
@@ -365,6 +448,121 @@ struct Agent {
deferred_permit: Option<(u64, ExecutionPermit)>,
}
impl Agent {
#[cfg(feature = "system-helper")]
fn start_time_refresh(
&mut self,
generation: u64,
identity: &crate::certificate_rotation::DeviceIdentity,
) -> Result<()> {
ensure!(self.time_refresh.is_none(), "TIME_REFRESH_ALREADY_RUNNING");
if !self.config.enable_jobs {
return Ok(());
}
let client = crate::https_channel::mtls_client(
self.config.connect_address,
&self.ca,
&identity.certificate_pem,
&identity.private_key_pem,
)?;
let helper = rmm_agent_windows::helper_runtime::Client::discover(
&self.identity.agent_id,
&self.identity.asset_id,
self.binding.as_ref(),
self.helper_lane.clone(),
)?;
let clock = self.clock.native.source();
let stop = Arc::new(AtomicBool::new(false));
let mut tasks = Vec::new();
let own_clock = clock.clone();
let own_stop = stop.clone();
let own_http = client.clone();
let address = self.config.connect_address;
tasks.push(tokio::spawn(async move {
while !own_stop.load(Ordering::SeqCst) {
let result = async {
if !own_clock.configured_for(generation) {
own_clock.open_connection(generation).await?;
}
let request = own_clock.begin(generation)?;
let bytes = time_response(&own_http, address, &request).await?;
ensure!(!own_stop.load(Ordering::SeqCst), "TIME_CONNECTION_CLOSED");
own_clock.complete(generation, &bytes)
}
.await;
if result.is_err() {
let _ = own_clock.close_generation(generation);
}
tokio::time::sleep(if result.is_ok() {
Duration::from_millis(20)
} else {
Duration::from_millis(500)
})
.await;
}
let _ = own_clock.close_generation(generation);
}));
if let Some(time_helper) = helper.clone() {
let helper_stop = stop.clone();
tasks.push(tokio::spawn(async move {
while !helper_stop.load(Ordering::SeqCst) {
let result = async {
let request = time_helper.time_begin(generation).await?;
let bytes = time_response(&client, address, &request).await?;
ensure!(
!helper_stop.load(Ordering::SeqCst),
"TIME_CONNECTION_CLOSED"
);
time_helper.time_complete(generation, bytes).await
}
.await;
if result.is_err() {
let _ = time_helper.time_close(generation).await;
}
tokio::time::sleep(if result.is_ok() {
Duration::from_millis(20)
} else {
Duration::from_millis(500)
})
.await;
}
let _ = time_helper.time_close(generation).await;
}));
}
self.time_refresh = Some(TimeRefresh {
generation,
stop,
clock,
helper,
tasks,
});
Ok(())
}
#[cfg(feature = "system-helper")]
async fn stop_time_refresh(&mut self) {
let Some(refresh) = self.time_refresh.take() else {
return;
};
refresh.stop.store(true, Ordering::SeqCst);
let _ = refresh.clock.close_generation(refresh.generation);
for task in &refresh.tasks {
task.abort();
}
if let Some(helper) = &refresh.helper {
let until = Instant::now() + Duration::from_millis(1200);
loop {
if helper.time_close(refresh.generation).await.is_ok() {
break;
}
if Instant::now() >= until {
// No successful remote fence is asserted after a lost or
// busy call; local effects are already closed independently.
eprintln!("HELPER_TIME_CLOSE_UNCONFIRMED");
break;
}
tokio::time::sleep(Duration::from_millis(5)).await;
}
}
}
fn close_gate(&mut self) {
self.fence.close();
#[cfg(feature = "system-helper")]
@@ -609,9 +807,9 @@ impl Agent {
let mut caps: Vec<String> = CAPABILITIES.iter().map(|c| c.to_string()).collect();
caps.push("agent.update/1".into());
if self.config.enable_jobs
&& cfg!(feature = "system-helper")
&& self.binding.is_some()
&& native::require_local_service().is_ok()
&& self.clock.now().is_ok()
{
caps.extend(["rmm.sync.v1", "refresh_inventory"].map(str::to_string));
if rmm_agent_windows::actions::powershell().is_ok() {
@@ -1157,7 +1355,7 @@ impl Agent {
let work_grant = grant.clone();
let original_boot = Uuid::parse_str(&self.boot)?;
let worker = tokio::task::spawn_blocking(move || {
let outcome = (|| -> Result<Outcome> {
let mut outcome = (|| -> Result<Outcome> {
if !fence.allows(generation, &clock)
|| verified_window(&binding, &request, &clock).is_err()
{
@@ -1200,6 +1398,13 @@ impl Agent {
prepared.run(&job, &worker_cancel)
})()
.unwrap_or_else(|_| Outcome::unknown("WINDOWS_EXECUTOR_EFFECT_UNKNOWN"));
if outcome.state == "succeeded" && clock.reading().is_err() {
// Use this worker's original connection-bound clock, never a
// newer session's evidence when its retained outcome is drained.
outcome.state = "unknown".into();
outcome.error_code = "WINDOWS_FINAL_CLOCK_UNTRUSTED".into();
outcome.evidence["postconditions_passed"] = false.into();
}
let _ = completed.blocking_send((work_offer, work_grant, outcome));
});
self.running = Some(Running {
@@ -1283,6 +1488,8 @@ impl Agent {
self.close_gate();
let result = self.session_inner(stop).await;
self.close_gate();
#[cfg(feature = "system-helper")]
self.stop_time_refresh().await;
result
}
async fn session_inner(&mut self, stop: &AtomicBool) -> Result<()> {
@@ -1331,6 +1538,9 @@ impl Agent {
generation > 0 && server.max_message_bytes == rmm_domain::MAX_MESSAGE as u32,
"SERVER_LIMITS"
);
self.clock = self.clock.for_generation(generation);
#[cfg(feature = "system-helper")]
self.start_time_refresh(generation, &identity)?;
self.queue_inventory(generation)?;
self.queue_update_observation(generation)?;
self.replay(&channel, generation).await?;
@@ -1510,7 +1720,7 @@ fn service_run(stop: &'static AtomicBool) -> Result<()> {
}
ensure!(!config.enable_jobs || binding.is_some(),"ENABLED_JOBS_REQUIRE_BINDING");
let (ledger,ledger_file)=match &binding {Some(binding)=>{let (db,file)=open_ledger(&config.state_directory,binding)?;(Some(db),Some(file))},None=>(None,None)};
let clock=JobClock{native:Arc::new(rmm_agent_windows::clock::NativeClock::new()),enabled:config.enable_jobs};
let clock=JobClock::new(config.enable_jobs);
let sync=if config.enable_jobs {binding.clone().map(|binding|reconcile::ClientSync::new(binding).with_helper_identity(reconcile::HelperIdentity::System))} else {None};
let (completed_tx,completed_rx)=tokio::sync::mpsc::channel(1);
let mut agent = Agent {
@@ -1522,6 +1732,8 @@ fn service_run(stop: &'static AtomicBool) -> Result<()> {
instance: Uuid::new_v4().to_string(),
started: Instant::now(), binding, ledger, _ledger_file:ledger_file, clock, sync,
#[cfg(feature="system-helper")]
time_refresh:None,
#[cfg(feature="system-helper")]
prepared_request:None,
#[cfg(feature="system-helper")]
helper_lane:Arc::new(tokio::sync::Semaphore::new(1)),
@@ -1713,10 +1925,7 @@ mod tests {
let config:Config=serde_json::from_value(serde_json::json!({"server_name":"example.invalid","connect_address":"127.0.0.1:443","ca_file":"C:/fixture/ca.pem","state_directory":"C:/fixture/state","enrollment_token_file":"C:/fixture/token","transport":"auto"})).unwrap();
assert!(!config.enable_jobs);
assert!(config.job_binding_file.is_none());
let clock = JobClock {
native: Arc::new(rmm_agent_windows::clock::NativeClock::new()),
enabled: config.enable_jobs,
};
let clock = JobClock::new(config.enable_jobs);
assert_eq!(
clock.now().unwrap_err().to_string(),
"WINDOWS_JOBS_NOT_ENABLED"