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:
@@ -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"
|
||||
|
||||
Reference in New Issue
Block a user