use anyhow::{Context, Result, ensure}; use chrono::Utc; use prost::Message; use rcgen::{CertificateParams, DnType, KeyPair}; use rmm_agent_core::{ auth::{Binding, Outcome, Request}, jobs, ledger, reconcile::{self, SyncClock}, }; use rmm_agent_windows::certificate_rotation::{ProtectedKeyFiles, RotationStore}; use rmm_agent_windows::{CAPABILITIES, job_binding::readonly_binding, journal::Journal, native}; use rmm_domain::jobs::{Action, ExecutionPermitPayload}; use rmm_protocol::*; use rusqlite::{Connection, OptionalExtension}; use serde::Deserialize; use sha2::{Digest, Sha256}; use std::{ fs, path::{Path, PathBuf}, sync::{ Arc, atomic::{AtomicBool, AtomicI64, AtomicU64, Ordering}, }, time::{Duration, Instant}, }; use uuid::Uuid; #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct Config { server_name: String, connect_address: std::net::SocketAddr, ca_file: PathBuf, state_directory: PathBuf, enrollment_token_file: PathBuf, transport: String, #[serde(default)] job_binding_file: Option, // Explicit protected opt-in only; this flag never qualifies a clock or pins. #[serde(default)] enable_jobs: bool, } fn create_private(path: &Path, bytes: &[u8]) -> Result<()> { use std::io::Write; let mut file = fs::OpenOptions::new() .write(true) .create_new(true) .open(path)?; file.write_all(bytes)?; file.sync_all()?; native::private_path(path, false) } fn protected_read(path: &Path, max: usize) -> Result> { native::private_path(path, false)?; ensure!( fs::metadata(path)?.len() <= max as u64, "PRIVATE_FILE_LIMIT" ); Ok(fs::read(path)?) } async fn enrollment(config: &Config, ca: &[u8]) -> Result { let state = &config.state_directory; let identity = state.join("identity.json"); if identity.try_exists()? { return Ok(serde_json::from_slice(&protected_read(&identity, 32768)?)?); } let key_path = state.join("device.key"); let key = if key_path.try_exists()? { KeyPair::from_pem(std::str::from_utf8(&protected_read(&key_path, 16384)?)?)? } else { let key = KeyPair::generate()?; create_private(&key_path, key.serialize_pem().as_bytes())?; key }; let mut parameters = CertificateParams::default(); parameters .distinguished_name .push(DnType::CommonName, "new-windows-device"); let csr = parameters.serialize_request(&key)?.pem()?; let token = String::from_utf8(protected_read(&config.enrollment_token_file, 128)?)? .trim() .to_owned(); ensure!( token.len() == 64 && token.bytes().all(|b| b.is_ascii_hexdigit()), "ENROLLMENT_TOKEN_FORMAT" ); let client = reqwest::Client::builder() .https_only(true) .tls_built_in_root_certs(false) .add_root_certificate(reqwest::Certificate::from_pem(ca)?) .resolve(&config.server_name, config.connect_address) .no_proxy() .redirect(reqwest::redirect::Policy::none()) .timeout(Duration::from_secs(20)) .build()?; let response = client .post(format!( "https://{}:{}/agent/v1/enroll", config.server_name, config.connect_address.port() )) .json(&EnrollmentRequest { token, csr_pem: csr, }) .send() .await?; let bytes = crate::https_channel::bounded_body(response, 32768, "application/json").await?; let identity: EnrollmentResponse = serde_json::from_slice(&bytes)?; Uuid::parse_str(&identity.agent_id)?; Uuid::parse_str(&identity.asset_id)?; // The server consumes the token once; a lost response is an explicit recovery // gate. No automatic re-enrollment or replacement identity is attempted. create_private( &state.join("device.pem"), identity.certificate_pem.as_bytes(), )?; create_private( &state.join("identity.json"), &serde_json::to_vec(&identity)?, )?; fs::remove_file(&config.enrollment_token_file)?; Ok(identity) } #[derive(Clone)] struct JobClock { #[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> { Ok(self.reading()?.own_wall) } fn reading(&self) -> Result { 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, clock: rmm_agent_windows::signed_clock::RuntimeClock, helper: Option, tasks: Vec>, } #[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> { 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 { generation: AtomicU64, helper_generation: AtomicU64, deadline: AtomicI64, } impl EffectFence { fn close(&self) { self.generation.store(0, Ordering::SeqCst); self.helper_generation.store(0, Ordering::SeqCst); } fn allows(&self, generation: u64, clock: &impl SyncClock) -> bool { self.allows_identity(generation, false, clock) } fn allows_identity(&self, generation: u64, helper: bool, clock: &impl SyncClock) -> bool { (!helper || self.helper_generation.load(Ordering::SeqCst) == generation) && self.generation.load(Ordering::SeqCst) == generation && generation > 0 && 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) }) } } type Completion = (JobOffer, ExecutionPermitPayload, Outcome); #[cfg(feature = "system-helper")] fn needs_bound_outcome( db: &Connection, bound: &rmm_agent_windows::helper_runtime::BoundOutcome, ) -> Result { use rmm_domain::reconciliation::{ReconciledOutcome, canonical_outcome_bytes}; // Archiving is durable retention only: no ACK, event deletion or unlock. reconcile::archive_events(db)?; let (state, revision, grant): (String, u64, String) = db.query_row( "SELECT state,revision,grant_id FROM job_attempts WHERE job=?1 AND attempt=?2", rusqlite::params![bound.job_id.to_string(), bound.attempt_id.to_string()], |r| Ok((r.get(0)?, r.get(1)?, r.get(2)?)), )?; let bytes:Option>=db.query_row("SELECT envelope FROM reconcile_results WHERE job=?1 AND attempt=?2 ORDER BY revision DESC LIMIT 1",rusqlite::params![bound.job_id.to_string(),bound.attempt_id.to_string()],|r|r.get(0)).optional()?; if state == bound.outcome.state && grant == bound.grant_id.to_string() && let Some(bytes) = bytes { let envelope = Envelope::decode(bytes.as_slice())?; if let Some(Payload::JobResult(r)) = envelope.payload && r.revision == revision && r.grant_id == grant { let saved = ReconciledOutcome { state: r.state, stdout: r.stdout, stderr: r.stderr, exit_code: r.exit_code, output_truncated: r.output_truncated, reboot_required: r.reboot_required, evidence: serde_json::from_str(&r.evidence_json)?, error_code: r.error_code, }; let actual: ReconciledOutcome = serde_json::from_value(serde_json::to_value(&bound.outcome)?)?; if canonical_outcome_bytes(&saved)? == canonical_outcome_bytes(&actual)? { return Ok(false); } } } Ok(true) } struct Running { offer: JobOffer, grant: ExecutionPermitPayload, cancel: Arc, worker: tokio::task::JoinHandle<()>, } fn verified_window( binding: &Binding, request: &Request, clock: &impl SyncClock, ) -> Result<(rmm_domain::jobs::JobPayload, ExecutionPermitPayload)> { let now = clock.now()?; // The entire qualified <=2s clock interval must lie inside the grant window. let result = binding.verify(request, now - chrono::Duration::seconds(2))?; binding.verify(request, now + chrono::Duration::seconds(2))?; Ok(result) } fn import_legacy_inventory(journal: &mut Journal) -> Result<()> { let original = { let mut q = journal .connection() .prepare("SELECT id,payload FROM events ORDER BY rowid")?; q.query_map([], |r| { Ok((r.get::<_, String>(0)?, r.get::<_, Vec>(1)?)) })? .collect::>>()? }; let tx = journal.connection_mut().transaction()?; for (id, bytes) in original { let envelope = Envelope::decode(bytes.as_slice())?; ensure!( envelope.message_id == id && matches!(envelope.payload, Some(Payload::InventorySnapshot(_))), "LEGACY_INVENTORY_BINDING" ); let old: Option> = tx .query_row("SELECT payload FROM job_events WHERE id=?1", [&id], |r| { r.get(0) }) .optional()?; ensure!( old.as_ref().is_none_or(|old| old == &bytes), "LEGACY_INVENTORY_CONFLICT" ); // Copy original bytes/ID, never decode/re-encode or discard pending telemetry. tx.execute( "INSERT OR IGNORE INTO job_events(id,payload) VALUES(?1,?2)", rusqlite::params![id, bytes], )?; } // Core ACK/Sync deletion and the old queue advance in the SAME transaction. tx.execute_batch("CREATE TRIGGER IF NOT EXISTS windows_legacy_inventory_ack AFTER DELETE ON job_events BEGIN DELETE FROM events WHERE id=OLD.id AND payload=OLD.payload; END;")?; tx.commit()?; Ok(()) } fn open_ledger(directory: &Path, binding: &Binding) -> Result<(Connection, fs::File)> { use std::os::windows::fs::OpenOptionsExt; use windows_sys::Win32::Storage::FileSystem::{FILE_SHARE_READ, FILE_SHARE_WRITE}; let path = directory.join("consumption.sqlite"); let file = fs::OpenOptions::new() .create(true) .truncate(false) .read(true) .write(true) .share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE) .open(&path)?; native::private_path(&path, false)?; let db = Connection::open(&path)?; ledger::initialize_ledger(&db)?; db.execute_batch("CREATE TABLE IF NOT EXISTS windows_binding(identity TEXT NOT NULL);")?; let identity = format!( "{}:{}:{}:{}:{}", binding.tenant_id, binding.asset_id, binding.agent_id, binding.enrollment_generation, binding.assignment_version ); let old: Option = db .query_row("SELECT identity FROM windows_binding", [], |r| r.get(0)) .optional()?; if let Some(old) = old { ensure!(old == identity, "LEDGER_IDENTITY_MISMATCH"); } else { db.execute("INSERT INTO windows_binding VALUES(?1)", [identity])?; } Ok((db, file)) } #[cfg(feature = "system-helper")] type MirrorCompletion = ( Connection, Result<( rmm_agent_windows::helper_runtime::ControlSnapshot, Vec, )>, ); #[cfg(feature = "system-helper")] enum HelperControl { Snapshot( u64, tokio::task::JoinHandle>, ), Apply( u64, tokio::task::JoinHandle>, ), Mirror(u64, tokio::task::JoinHandle), } #[cfg(feature = "system-helper")] impl HelperControl { fn finished(&self) -> bool { match self { Self::Snapshot(_, t) | Self::Apply(_, t) => t.is_finished(), Self::Mirror(_, t) => t.is_finished(), } } fn abort(self) -> Option { match self { Self::Snapshot(_, t) | Self::Apply(_, t) => { t.abort(); None } mirror @ Self::Mirror(..) => Some(mirror), } } } struct Agent { config: Config, identity: EnrollmentResponse, ca: Vec, journal: Journal, certificates: RotationStore, key_files: ProtectedKeyFiles, boot: String, instance: String, started: Instant, binding: Option, ledger: Option, _ledger_file: Option, clock: JobClock, #[cfg(feature = "system-helper")] time_refresh: Option, sync: Option, prepared: bool, #[cfg(feature = "system-helper")] prepared_request: Option>, #[cfg(feature = "system-helper")] helper_lane: Arc, #[cfg(feature = "system-helper")] helper: Option, #[cfg(feature = "system-helper")] helper_probe: Option>>>, #[cfg(feature = "system-helper")] helper_probe_at: Instant, #[cfg(feature = "system-helper")] helper_control: Option, #[cfg(feature = "system-helper")] helper_anchor: Option, #[cfg(feature = "system-helper")] helper_checked: bool, #[cfg(feature = "system-helper")] helper_refused: bool, fence: Arc, completed_tx: tokio::sync::mpsc::Sender, completed_rx: tokio::sync::mpsc::Receiver, running: Option, 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")] if let Some(running) = &self.running && running.grant.execution_identity == "system" { running.cancel.store(true, Ordering::SeqCst); let denied = (|| -> Result<()> { let mut store = rmm_agent_windows::helper_runtime::intent::Store::open(true)?; let intent = store.by_grant(running.grant.grant_id)?; ensure!( intent.permit()? == running.grant, "SYSTEM_CANCEL_GRANT_BINDING" ); store.deny(&intent.request, Uuid::parse_str(&self.boot)?) })(); if denied.is_err() { self.helper_refused = true; eprintln!("SYSTEM_CANCEL_PERSISTENCE_FAILED"); } } if let Some(sync) = &mut self.sync { sync.close(); } self.prepared = false; #[cfg(feature = "system-helper")] { self.prepared_request = None; self.helper_anchor = None; if let Some(control) = self.helper_control.take() { self.helper_control = control.abort(); } } self.deferred_permit = None; } fn helper_control_pending(&self) -> bool { #[cfg(feature = "system-helper")] { self.helper_control.is_some() || self.helper_probe.is_some() || !self.helper_checked || self.helper_refused } #[cfg(not(feature = "system-helper"))] { false } } #[cfg(feature = "system-helper")] async fn poll_helper( &mut self, channel: &crate::wire_channel::Handle, generation: u64, ) -> Result<()> { if self .helper_control .as_ref() .is_some_and(HelperControl::finished) { match self .helper_control .take() .context("HELPER_CONTROL_REQUIRED")? { HelperControl::Snapshot(expected, task) => { ensure!(expected == generation, "HELPER_CHANNEL_CHANGED"); let snapshot = task.await??; let helper = self .helper .clone() .context("WINDOWS_HELPER_NOT_CONFIGURED")?; let observed_at = self.clock.now()?; let mut ledger = self.ledger.take().context("LEDGER_REQUIRED")?; self.helper_control = Some(HelperControl::Mirror( generation, tokio::task::spawn_blocking(move || { let result = helper .mirror(&snapshot.raw, &mut ledger, observed_at) .map(|unknowns| (snapshot, unknowns)); (ledger, result) }), )); } HelperControl::Mirror(expected, task) => { // Always restore ownership, including after reconnect. A // stale generation may discard its snapshot, never its DB. let (ledger, result) = task.await?; self.ledger = Some(ledger); let (snapshot, unknowns) = result?; for bound in unknowns { if needs_bound_outcome(self.journal.connection(), &bound)? { let bytes: Vec = self.journal.connection().query_row( "SELECT offer FROM job_attempts WHERE job=?1 AND attempt=?2", rusqlite::params![ bound.job_id.to_string(), bound.attempt_id.to_string() ], |r| r.get(0), )?; self.record( generation, &JobOffer::decode(bytes.as_slice())?, &bound.grant_id.to_string(), bound.outcome, )?; } } if expected != generation { self.close_gate(); return Ok(()); } self.send_sync( channel, generation, Some(&rmm_agent_windows::helper_runtime::map_snapshot( &snapshot.raw, )), ) .await?; } HelperControl::Apply(expected, task) => { ensure!(expected == generation, "HELPER_CHANNEL_CHANGED"); let snapshot = task.await??; self.helper_anchor = snapshot.no_start_anchor; let mapped = rmm_agent_windows::helper_runtime::map_snapshot(&snapshot.raw); let sync = self.sync.as_mut().context("SYNC_NOT_CONFIGURED")?; if mapped .attempts .iter() .any(|a| !a.update_handoff_bytes.is_empty()) { sync.confirm_update_helper(&mapped)?; } else { sync.confirm_helper(&mapped)?; } self.open_fence(generation)?; } } } if self .helper_probe .as_ref() .is_some_and(|task| task.is_finished()) { let result = self .helper_probe .take() .context("HELPER_PROBE_REQUIRED")? .await?; self.helper_probe_at = Instant::now(); self.helper_checked = true; match result { Ok(client) => { self.helper_refused = false; if self.helper.as_ref().map(|c| c.pin_hash()) != client.as_ref().map(|c| c.pin_hash()) { self.close_gate(); } self.helper = client; } Err(error) => { self.helper_refused = true; self.helper = None; self.close_gate(); return Err(error); } } } if self.helper_probe.is_none() && self.helper_control.is_none() && !self.prepared && self.running.is_none() && !self.journal.connection().query_row("SELECT EXISTS(SELECT 1 FROM job_attempts WHERE state IN ('requesting','running','verifying'))",[],|r|r.get::<_,bool>(0))? && self.helper_probe_at.elapsed() >= Duration::from_secs(30) { let agent = self.identity.agent_id.clone(); let asset = self.identity.asset_id.clone(); let binding = self.binding.clone(); let lane = self.helper_lane.clone(); let state = self.config.state_directory.clone(); self.helper_probe = Some(tokio::spawn(async move { rmm_agent_windows::helper_runtime::Client::refresh( agent, asset, binding, lane, state, ) .await })); } Ok(()) } fn channel(&self, generation: u64) -> Result { Ok(reconcile::Channel { connection_generation: generation, boot_id: Uuid::parse_str(&self.boot)?, }) } fn ready(&self, generation: u64) -> bool { self.ready_identity(generation, false) } fn ready_identity(&self, generation: u64, helper: bool) -> bool { #[cfg(feature = "system-helper")] if helper && !self.helper_anchor.as_ref().is_some_and(|a| { a.connection_generation() == generation && a.boot_id().to_string() == self.boot }) { return false; } self.config.enable_jobs && !self.helper_control_pending() && self.channel(generation).is_ok_and(|channel| { self.sync .as_ref() .is_some_and(|sync| sync.can_start(&channel, helper, &self.clock)) }) } fn supported_job(&self, job: &rmm_domain::jobs::JobPayload) -> bool { if native::require_local_service().is_err() { return false; } if rmm_agent_windows::actions::supported(job) { return true; } #[cfg(feature = "system-helper")] { (job.action.windows_msi().is_none() || (self.config.state_directory == Path::new(rmm_agent_windows::msi_cache::AGENT_STATE) && rmm_agent_windows::msi_cache::stage_configured())) && Path::new(rmm_agent_windows::helper_runtime::intent::DB).is_file() && self .helper .as_ref() .is_some_and(|helper| helper.supports_system(job)) } #[cfg(not(feature = "system-helper"))] { false } } fn capabilities(&self) -> Vec { let mut caps: Vec = 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() { caps.extend(["rmm.sync.v1", "refresh_inventory"].map(str::to_string)); if rmm_agent_windows::actions::powershell().is_ok() { // The process_remote_signed profile is implemented but remains // unpublished until its separate native qualification passes. caps.extend(["run_script", "script.powershell/1"].map(str::to_string)); } } caps } fn record( &mut self, generation: u64, offer: &JobOffer, grant: &str, outcome: Outcome, ) -> Result<()> { let mut envelope = self.envelope(generation, Payload::JobResult(JobResult::default()))?; let tx = self.journal.connection_mut().transaction()?; let revision = jobs::transition(&tx, offer, &outcome.state, grant)?; envelope.payload = Some(Payload::JobResult(jobs::result( offer, revision, grant, outcome, ))); jobs::event(&tx, &envelope)?; tx.commit()?; Ok(()) } fn recover_interrupted(&mut self) -> Result<()> { let Some(binding) = self.binding.clone() else { return Ok(()); }; #[cfg(feature = "system-helper")] if Path::new(rmm_agent_windows::helper_runtime::intent::DB).is_file() { let mut intents = rmm_agent_windows::helper_runtime::intent::Store::open(true)?; let pending = intents.pending()?; if let Some(intent) = pending.first() { let p = intent.permit()?; let incompatible:bool=self.journal.connection().query_row("SELECT EXISTS(SELECT 1 FROM job_attempts WHERE state IN ('requesting','running','verifying','unknown','awaiting_reboot') AND NOT(job=?1 AND attempt=?2))",rusqlite::params![p.job_id.to_string(),p.attempt_id.to_string()],|r|r.get(0))?; ensure!(!incompatible, "SYSTEM_PENDING_INTENT_CONFLICT"); binding.verify_historical_for_denial_with( &intent.request, reconcile::HelperIdentity::System, &rmm_agent_core::crypto::DalekVerifier, )?; let bytes: Vec = self.journal.connection().query_row( "SELECT offer FROM job_attempts WHERE job=?1 AND attempt=?2", rusqlite::params![p.job_id.to_string(), p.attempt_id.to_string()], |r| r.get(0), )?; let offer = JobOffer::decode(bytes.as_slice())?; ensure!( offer.payload_bytes == intent.request.job_bytes && offer.plan_hash == intent.request.plan_hash && offer.authorization_id == intent.request.authorization_id.to_string(), "SYSTEM_PENDING_INTENT_BINDING" ); // Even prepared-only intents are never executed after restart. // Snapshot/explicit bound denial recovery is the only route. intents.check()?; let ledger = self.ledger.as_ref().context("LEDGER_REQUIRED")?; let consumed: bool = ledger.query_row( "SELECT EXISTS(SELECT 1 FROM consumed WHERE grant_id=?1)", [p.grant_id.to_string()], |r| r.get(0), )?; let actual = if consumed { jobs::recover_interrupted_outcome( ledger, &binding, &offer, &p.grant_id.to_string(), )? } else { None }; if let Some(actual) = &actual { let bound = rmm_agent_windows::helper_runtime::BoundOutcome { job_id: p.job_id, attempt_id: p.attempt_id, grant_id: p.grant_id, outcome: actual.clone(), }; if !needs_bound_outcome(self.journal.connection(), &bound)? { return Ok(()); } } self.record( 0, &offer, &p.grant_id.to_string(), actual.unwrap_or_else(|| { Outcome::unknown("SYSTEM_DELEGATION_INTERRUPTED_REQUIRES_HELPER_EVIDENCE") }), )?; return Ok(()); } } let interrupted = jobs::interrupted( self.journal.connection(), self.ledger.as_ref().context("LEDGER_REQUIRED")?, &binding, )?; for (offer, grant) in interrupted { if grant.is_empty() { jobs::interrupted_request(self.journal.connection(), &offer)?; } else { let outcome = jobs::recover_interrupted_outcome( self.ledger.as_ref().context("LEDGER_REQUIRED")?, &binding, &offer, &grant, )? .unwrap_or_else(|| Outcome::unknown("AGENT_PROCESS_INTERRUPTED")); // Replay original durable evidence only. Normal signed Sync, // never startup, releases the previously consumed attempt. self.record(0, &offer, &grant, outcome)?; } } Ok(()) } async fn replay( &mut self, channel: &crate::wire_channel::Handle, generation: u64, ) -> Result<()> { let events = jobs::events(self.journal.connection())?; let passive = self.journal.events()?; tokio::time::timeout(Duration::from_secs(2), async { for mut event in events.into_iter().chain(passive).take(8) { event.connection_generation = generation; channel.send(&event).await?; } Ok::<_, anyhow::Error>(()) }) .await??; Ok(()) } async fn start_sync( &mut self, channel: &crate::wire_channel::Handle, generation: u64, ) -> Result<()> { self.fence.close(); ensure!(!self.helper_control_pending(), "HELPER_CONTROL_NOT_SETTLED"); #[cfg(feature = "system-helper")] if let Some(helper) = self.helper.clone() { ensure!(self.helper_control.is_none(), "HELPER_CONTROL_PENDING"); let boot = self.channel(generation)?.boot_id; let instance = Uuid::parse_str(&self.instance)?; let clock = self.clock.clone(); self.helper_control = Some(HelperControl::Snapshot( generation, tokio::spawn(async move { let denial_resume = tokio::task::spawn_blocking(move || -> Result<_> { if Path::new(rmm_agent_windows::helper_runtime::intent::DB).is_file() { use rmm_agent_windows::helper_runtime::intent::{Phase, Store}; let mut store = Store::open(true)?; if let Some(intent) = store.pending()?.first() { let (_, phase) = store.load(intent.id)?; if phase == Phase::KnownNoDispatch && intent.agent_instance != instance && store.claim_denial_resume( intent.id, instance, boot, clock.now()?, )? { return Ok(Some(intent.clone())); } } } Ok(None) }) .await??; if let Some(intent) = denial_resume { let _denial = helper.resume_denial(intent).await; } helper.snapshot(generation, boot).await }), )); return Ok(()); } self.send_sync(channel, generation, None).await } async fn send_sync( &mut self, channel: &crate::wire_channel::Handle, generation: u64, helper: Option<&reconcile::HelperSnapshot>, ) -> Result<()> { let context = self.channel(generation)?; let sync = self.sync.as_mut().context("SYNC_NOT_CONFIGURED")?; let prepared = sync.prepare( self.journal.connection_mut(), self.ledger.as_ref().context("LEDGER_REQUIRED")?, context, helper, &self.clock, )?; #[cfg(feature = "system-helper")] { self.prepared_request = Some(prepared.request.encode_to_vec()); } self.prepared = true; channel.send(&prepared.envelope).await?; Ok(()) } fn apply_sync(&mut self, generation: u64, response: SyncResponse) -> Result<()> { ensure!(self.prepared, "UNSOLICITED_SYNC_RESPONSE"); self.prepared = false; let sync = self.sync.as_mut().context("SYNC_NOT_CONFIGURED")?; let applied = sync.apply(self.journal.connection_mut(), &response, &self.clock)?; sync.apply_consumption( self.ledger.as_mut().context("LEDGER_REQUIRED")?, &self.clock, )?; if let Some(instruction) = applied.helper_instruction { #[cfg(feature = "system-helper")] { ensure!(self.helper_control.is_none(), "HELPER_CONTROL_PENDING"); let helper = self .helper .clone() .context("WINDOWS_HELPER_NOT_CONFIGURED")?; let request = self .prepared_request .take() .context("ORIGINAL_SYNC_REQUEST_REQUIRED")?; let boot = self.channel(generation)?.boot_id; self.helper_control = Some(HelperControl::Apply( generation, tokio::spawn(async move { helper.apply(&instruction.response, request, boot).await }), )); return Ok(()); } #[cfg(not(feature = "system-helper"))] { let _ = instruction; anyhow::bail!("WINDOWS_HELPER_NOT_CONFIGURED"); } } #[cfg(feature = "system-helper")] { self.prepared_request = None; } self.open_fence(generation) } fn open_fence(&self, generation: u64) -> Result<()> { if self.ready(generation) { let deadline = self .sync .as_ref() .and_then(|sync| sync.validity_deadline()) .context("SIGNED_LEASE_REQUIRED")?; self.fence .deadline .store(deadline.timestamp_millis(), Ordering::SeqCst); self.fence.generation.store(generation, Ordering::SeqCst); self.fence.helper_generation.store( if self.ready_identity(generation, true) { generation } else { 0 }, Ordering::SeqCst, ); } Ok(()) } fn completed(&mut self, generation: u64, (offer, grant, outcome): Completion) -> Result<()> { let running = self .running .as_ref() .context("UNSOLICITED_EXECUTOR_COMPLETION")?; ensure!( running.offer.job_id == offer.job_id && running.offer.attempt_id == offer.attempt_id && running.grant == grant, "EXECUTOR_COMPLETION_BINDING" ); if grant.execution_identity == "system" { // No local consumption or definitive result from an IPC outcome. // Import only a fresh raw helper snapshot before the next Sync. self.record( generation, &offer, &grant.grant_id.to_string(), Outcome::unknown("SYSTEM_DELEGATION_REQUIRES_HELPER_SNAPSHOT"), )?; self.running = None; self.close_gate(); return Ok(()); } ledger::persist_outcome( self.ledger.as_ref().context("LEDGER_REQUIRED")?, &grant, &outcome, )?; self.record( generation, &offer, &grant.grant_id.to_string(), outcome.clone(), )?; ledger::finish( self.ledger.as_ref().context("LEDGER_REQUIRED")?, &grant, &outcome, )?; self.running = None; if grant.execution_identity == "system" { self.close_gate(); } Ok(()) } fn permit(&mut self, generation: u64, permit: ExecutionPermit) -> Result<()> { if let Some((old_generation, old)) = &self.deferred_permit { ensure!( *old_generation == generation && *old == permit, "PENDING_PERMIT_CONFLICT" ); return Ok(()); } let offer = jobs::requesting(self.journal.connection())?.context("UNSOLICITED_PERMIT")?; if !permit.denial_code.is_empty() { self.record( generation, &offer, "", Outcome::unknown("PERMIT_DENIED_RECONCILIATION_REQUIRED"), )?; return Ok(()); } ensure!( self.ready(generation) && self.running.is_none(), "FENCED_SYNC_REQUIRED" ); let binding = self .binding .as_ref() .context("JOB_BINDING_REQUIRED")? .clone(); let request = jobs::permit_request(&offer, &permit)?; let now = self.clock.now()?; // Authenticate before interpreting timing. A freshly issued grant may // need two seconds before the full uncertainty interval is inside it. let (_, authenticated) = binding.verify(&request, now + chrono::Duration::seconds(2))?; if now - chrono::Duration::seconds(2) < authenticated.not_before { self.deferred_permit = Some((generation, permit)); return Ok(()); } let (job, grant) = verified_window(&binding, &request, &self.clock)?; ensure!(self.supported_job(&job), "UNSUPPORTED_CAPABILITY"); let system = job.execution_identity == "system"; ensure!( self.ready_identity(generation, system), "SYSTEM_HELPER_SYNC_REQUIRED" ); let cancelled: bool = self.journal.connection().query_row( "SELECT cancel_requested FROM job_attempts WHERE job=?1 AND attempt=?2", rusqlite::params![offer.job_id, offer.attempt_id], |r| r.get(0), )?; #[cfg(feature = "system-helper")] if system { use rmm_agent_windows::helper_runtime::intent::{Intent, Store}; let helper = self .helper .clone() .context("WINDOWS_HELPER_NOT_CONFIGURED")?; let intent = Intent { schema_version: 1, id: Uuid::new_v4(), request: request.clone(), anchor: self .helper_anchor .clone() .context("SYSTEM_READY_ANCHOR_REQUIRED")?, original_boot_id: Uuid::parse_str(&self.boot)?, agent_instance: Uuid::parse_str(&self.instance)?, connection_generation: generation, recorded_at: self.clock.now()?, policy_sha256: helper.pin_hash().into(), helper_binary_sha256: helper.helper_binary_hash().into(), }; let mut store = Store::open(true)?; store.prepare(&intent)?; if cancelled { store.decide(intent.id, false)?; } let cancelled = Arc::new(AtomicBool::new(cancelled)); let worker_cancel = cancelled.clone(); let clock = self.clock.clone(); let fence = self.fence.clone(); let completed = self.completed_tx.clone(); let work_offer = offer.clone(); let work_grant = grant.clone(); let msi = job.action.windows_msi().cloned(); let address = self.config.connect_address; let ca = self.ca.clone(); let tls_identity = self.certificates.current( self.journal.connection(), &self.key_files, Utc::now().timestamp(), )?; let request_for_stage = request.clone(); let binding_for_stage = binding.clone(); let worker = tokio::spawn(async move { let staged = if let Some(m) = msi { let result = async { ensure!( !worker_cancel.load(Ordering::SeqCst) && fence.allows_identity(generation, true, &clock), "MSI_DOWNLOAD_FENCED" ); verified_window(&binding_for_stage, &request_for_stage, &clock)?; let tls = crate::https_channel::mtls_client( address, &ca, &tls_identity.certificate_pem, &tls_identity.private_key_pem, )?; let response = tls .get(format!( "https://{}:{}/agent/v1/artifacts/{}?job_id={}&attempt_id={}", crate::https_channel::server_name()?, address.port(), m.recipe.artifact.artifact_id, work_grant.job_id, work_grant.attempt_id )) .send() .await?; ensure!( response .headers() .get("x-artifact-sha256") .and_then(|v| v.to_str().ok()) == Some(m.recipe.artifact.sha256.as_str()), "MSI_DOWNLOAD_METADATA" ); let bytes = crate::https_channel::bounded_body( response, m.recipe.artifact.bytes as usize, "application/octet-stream", ) .await?; ensure!( !worker_cancel.load(Ordering::SeqCst) && fence.allows_identity(generation, true, &clock), "MSI_DOWNLOAD_FENCED" ); verified_window(&binding_for_stage, &request_for_stage, &clock)?; tokio::task::spawn_blocking(move || { rmm_agent_windows::msi_cache::stage(&m, &bytes) }) .await??; Ok::<_, anyhow::Error>(()) } .await; result.is_ok() } else { true }; let _result = helper .delegate(intent, move || { ensure!(staged, "MSI_DOWNLOAD_NOT_READY"); ensure!( !worker_cancel.load(Ordering::SeqCst), "CANCELLED_BEFORE_DISPATCH" ); ensure!( fence.allows_identity(generation, true, &clock), "FENCED_BEFORE_DISPATCH" ); verified_window(&binding, &request, &clock)?; Ok(()) }) .await; let _ = completed .send(( work_offer, work_grant, Outcome::unknown("SYSTEM_DELEGATION_REQUIRES_HELPER_SNAPSHOT"), )) .await; }); self.running = Some(Running { offer, grant, cancel: cancelled, worker, }); return Ok(()); } let started_at = self.clock.now()?; let ledger = self.ledger.as_mut().context("LEDGER_REQUIRED")?; ledger::begin_execution( ledger, &grant, &request, Uuid::parse_str(&self.boot)?, started_at, )?; if cancelled { let outcome = jobs::no_start("cancelled", "CANCELLED_BEFORE_EFFECT"); ledger::persist_outcome( self.ledger.as_ref().context("LEDGER_REQUIRED")?, &grant, &outcome, )?; self.record( generation, &offer, &grant.grant_id.to_string(), outcome.clone(), )?; ledger::finish( self.ledger.as_ref().context("LEDGER_REQUIRED")?, &grant, &outcome, )?; return Ok(()); } let mut started = self.envelope( generation, Payload::JobStateChanged(JobStateChanged::default()), )?; let tx = self.journal.connection_mut().transaction()?; let revision = jobs::transition(&tx, &offer, "running", &grant.grant_id.to_string())?; started.payload = Some(Payload::JobStateChanged(JobStateChanged { job_id: offer.job_id.clone(), attempt_id: offer.attempt_id.clone(), revision, state: "running".into(), grant_id: grant.grant_id.to_string(), })); jobs::event(&tx, &started)?; tx.commit()?; let cancelled = Arc::new(AtomicBool::new(false)); let worker_cancel = cancelled.clone(); let clock = self.clock.clone(); let fence = self.fence.clone(); let completed = self.completed_tx.clone(); let directory = self.config.state_directory.join("jobs"); let work_offer = offer.clone(); let work_grant = grant.clone(); let original_boot = Uuid::parse_str(&self.boot)?; let worker = tokio::task::spawn_blocking(move || { let mut outcome = (|| -> Result { if !fence.allows(generation, &clock) || verified_window(&binding, &request, &clock).is_err() { return Ok(jobs::no_start( "failed", "START_WINDOW_OR_CLOCK_INVALID_BEFORE_EFFECT", )); } let prepared = match rmm_agent_windows::actions::PreparedAction::prepare( &job, &directory, work_grant.grant_id, &request, original_boot, ) { Ok(prepared) => prepared, Err(_) => { return Ok(jobs::no_start( "failed", if matches!(job.action, Action::RunScript { .. }) { "SCRIPT_PREPARATION_FAILED" } else { "ACTION_PREPARATION_FAILED" }, )); } }; // File creation, pool scheduling and fsync never extend a start window. if worker_cancel.load(Ordering::SeqCst) { return Ok(jobs::no_start("cancelled", "CANCELLED_BEFORE_EFFECT")); } if !fence.allows(generation, &clock) || verified_window(&binding, &request, &clock).is_err() { return Ok(jobs::no_start( "failed", "START_WINDOW_OR_CLOCK_INVALID_BEFORE_EFFECT", )); } 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 { offer, grant, cancel: cancelled, worker, }); Ok(()) } fn envelope(&mut self, generation: u64, payload: Payload) -> Result { Ok(Envelope { protocol_major: 1, protocol_minor: 0, message_id: Uuid::new_v4().to_string(), agent_id: self.identity.agent_id.clone(), enrollment_generation: self.binding.as_ref().map_or(1, |b| b.enrollment_generation), connection_generation: generation, boot_id: self.boot.clone(), sequence: self.journal.next_sequence()?, observed_at: Utc::now().timestamp_millis(), payload: Some(payload), }) } fn queue_inventory(&mut self, generation: u64) -> Result<()> { if self.journal.count()? > 0 || !jobs::events(self.journal.connection())?.is_empty() { return Ok(()); } let data = serde_json::to_vec(&native::snapshot()?)?; ensure!(data.len() <= 32768, "WINDOWS_INVENTORY_LIMIT"); let envelope = self.envelope( generation, Payload::InventorySnapshot(InventorySnapshot { snapshot_id: Uuid::new_v4().to_string(), scope: "windows.base".into(), schema_version: 1, chunk_index: 0, chunk_count: 1, sha256: Sha256::digest(&data).to_vec(), data, completeness: "partial".into(), }), )?; if self.binding.is_some() { jobs::event(self.journal.connection(), &envelope) } else { self.journal.save(&envelope) } } fn queue_update_observation(&mut self, generation: u64) -> Result<()> { if self.journal.count()? > 0 || !jobs::events(self.journal.connection())?.is_empty() { return Ok(()); } // Schema support is passive only; no qualified updater/helper observer // is configured by this source checkpoint, so apply remains closed. let observation = rmm_domain::agent_update::AgentUpdateObservation::not_configured( rmm_domain::agent_update::Platform::WindowsX64, Utc::now(), ); let data = serde_json::to_vec(&serde_json::json!({"agent_update":observation}))?; let envelope = self.envelope( generation, Payload::InventorySnapshot(InventorySnapshot { snapshot_id: Uuid::new_v4().to_string(), scope: "agent.update".into(), schema_version: 1, chunk_index: 0, chunk_count: 1, sha256: Sha256::digest(&data).to_vec(), data, completeness: "partial".into(), }), )?; if self.binding.is_some() { jobs::event(self.journal.connection(), &envelope) } else { self.journal.save(&envelope) } } async fn session(&mut self, stop: &AtomicBool) -> Result<()> { 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<()> { // Server commit may have fenced Hello even if its HTTP response was // lost. Recover the durable original CSR before requiring any channel. if self.certificates.has_pending(self.journal.connection())? { ensure!( !self.config.enable_jobs, "ROTATION_PENDING_REQUIRES_PASSIVE_RECOVERY" ); self.renew_certificate().await?; } self.boot = native::boot_id().await?; let advertised = self.capabilities(); let hello = self.envelope( 0, Payload::ClientHello(ClientHello { agent_version: env!("CARGO_PKG_VERSION").into(), capabilities: advertised.clone(), }), )?; let identity = self.certificates.current( self.journal.connection(), &self.key_files, Utc::now().timestamp(), )?; let mode = crate::wire_channel::Mode::parse(&self.config.transport)?; let mut channel = crate::wire_channel::connect( mode, self.config.connect_address, &self.ca, &identity, hello, ) .await?; let reply = tokio::time::timeout(Duration::from_secs(20), channel.receive()).await??; ensure!( reply.agent_id == self.identity.agent_id && reply.enrollment_generation == self.binding.as_ref().map_or(1, |b| b.enrollment_generation) && reply.protocol_major == 1 && reply.protocol_minor == 0, "SERVER_HELLO_BINDING" ); let Some(Payload::ServerHello(server)) = reply.payload else { anyhow::bail!("SERVER_HELLO_REQUIRED") }; let generation = server.connection_generation; ensure!( 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?; let mut needs_sync = self.sync.is_some(); if self.sync.is_some() && self.running.is_none() { if self.start_sync(&channel, generation).await.is_err() { self.close_gate(); } else { needs_sync = false; } } let mut sync_at = Instant::now(); let mut capabilities_at = Instant::now(); let mut replay = Instant::now() - Duration::from_secs(10); let mut inventory = Instant::now(); let mut update_at = Instant::now(); let mut rotation_at = Instant::now(); let mut heartbeat = Instant::now() - Duration::from_secs(60); let mut heartbeat_after = Duration::from_secs(30); let mut tick = tokio::time::interval(Duration::from_secs(1)); while !stop.load(Ordering::SeqCst) || self.running.is_some() { if stop.load(Ordering::SeqCst) { self.close_gate(); if let Some(running) = &self.running { running.cancel.store(true, Ordering::SeqCst); } } tokio::select! { Some(completion)=self.completed_rx.recv()=>{self.completed(generation,completion)?;needs_sync=true;}, _=tick.tick()=>{ #[cfg(feature = "system-helper")] if !stop.load(Ordering::SeqCst) && self.poll_helper(&channel,generation).await.is_err() {self.close_gate();needs_sync=self.sync.is_some();} if !stop.load(Ordering::SeqCst) && let Some((pending_generation,permit))=self.deferred_permit.take() { ensure!(pending_generation==generation,"PENDING_PERMIT_GENERATION");self.permit(generation,permit)?; } if self.running.as_ref().is_some_and(|r|r.worker.is_finished()) { if let Ok(completion)=self.completed_rx.try_recv(){self.completed(generation,completion)?;} else {let running=self.running.as_ref().context("RUNNING_REQUIRED")?;self.completed(generation,(running.offer.clone(),running.grant.clone(),Outcome::unknown("EXECUTOR_THREAD_INTERRUPTED")))?;} needs_sync=true; } let busy=self.running.is_some() || self.journal.connection().query_row("SELECT EXISTS(SELECT 1 FROM job_attempts WHERE state IN ('requesting','running','verifying'))",[],|r|r.get::<_,bool>(0))?; if !stop.load(Ordering::SeqCst) && !busy { if capabilities_at.elapsed()>=Duration::from_secs(60) {capabilities_at=Instant::now();if advertised!=self.capabilities(){return Ok(());}} if self.prepared && sync_at.elapsed()>=Duration::from_secs(20){self.close_gate();needs_sync=true;} if self.sync.is_some() && !self.prepared && !self.helper_control_pending() && (needs_sync || sync_at.elapsed()>=Duration::from_secs(40) || !self.ready(generation)) { if self.start_sync(&channel,generation).await.is_err(){self.close_gate();needs_sync=true;}else{needs_sync=false;}sync_at=Instant::now(); } if !needs_sync && !self.prepared && self.ready(generation) && jobs::events(self.journal.connection())?.is_empty() && self.journal.count()?==0 { let now=self.clock.now()?; if let Some(offer)=jobs::next_at(self.journal.connection(),now)? { let job=self.binding.as_ref().context("JOB_BINDING_REQUIRED")?.job(&offer.payload_bytes)?; if now>=job.start_before {self.record(generation,&offer,"",jobs::no_start("expired","START_DEADLINE_EXPIRED"))?;needs_sync=true;} else if now-chrono::Duration::seconds(2)>=job.not_before && self.ready_identity(generation,job.execution_identity=="system") { jobs::reserve_request(self.journal.connection(),&offer)?; let request=self.envelope(generation,Payload::ExecutionPermitRequest(ExecutionPermitRequest{job_id:offer.job_id,attempt_id:offer.attempt_id,job_payload_hash:offer.job_payload_hash,assignment_version:job.assignment_version}))?; channel.send(&request).await?; } } } } }, message=channel.receive()=>{ let message=message?; ensure!(message.agent_id==self.identity.agent_id && message.enrollment_generation==self.binding.as_ref().map_or(1,|b|b.enrollment_generation) && message.protocol_major==1 && message.protocol_minor==0 && message.connection_generation==generation,"SERVER_ENVELOPE_BINDING"); match message.payload { Some(Payload::Ack(ack))=>{ let pending:Option>=self.journal.connection().query_row("SELECT payload FROM job_events WHERE id=?1",[&ack.message_id],|r|r.get(0)).optional()?; if let Some(bytes)=pending && matches!(Envelope::decode(bytes.as_slice())?.payload,Some(Payload::InventorySnapshot(_)|Payload::JobResult(_))){needs_sync=true;} self.journal.ack(&ack.message_id)?;jobs::ack(self.journal.connection_mut(),&ack.message_id)?; }, Some(Payload::SyncResponse(response))=>{if self.apply_sync(generation,response).is_err(){self.close_gate();needs_sync=true;}sync_at=Instant::now();}, Some(Payload::JobOffer(offer))=>{ ensure!(self.config.enable_jobs,"UNSUPPORTED_EXECUTION_CAPABILITY"); let binding=self.binding.as_ref().context("JOB_BINDING_REQUIRED")?.clone(); let accepted=self.envelope(generation,Payload::JobAccepted(JobAccepted{job_id:offer.job_id.clone(),attempt_id:offer.attempt_id.clone(),job_payload_hash:offer.job_payload_hash.clone(),journal_proof:rmm_domain::jobs::hash(&offer.encode_to_vec())}))?; let supported=self.supported_job(&binding.job(&offer.payload_bytes)?); let tx=self.journal.connection_mut().transaction()?; let fresh=jobs::accept(&tx,&binding,&offer,|_|supported)?; jobs::event(&tx,&accepted)?;tx.commit()?;needs_sync|=fresh; }, Some(Payload::ExecutionPermit(permit))=>self.permit(generation,permit)?, Some(Payload::CancelRequest(cancel))=>{ let row:Option<(Vec,String,String)>=self.journal.connection().query_row("SELECT offer,state,grant_id FROM job_attempts WHERE job=?1 AND attempt=?2",rusqlite::params![cancel.job_id,cancel.attempt_id],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?))).optional()?; if let Some((bytes,state,grant))=row { self.journal.connection().execute("UPDATE job_attempts SET cancel_requested=1 WHERE job=?1 AND attempt=?2",rusqlite::params![cancel.job_id,cancel.attempt_id])?; if let Some(running)=&self.running && running.offer.job_id==cancel.job_id && running.offer.attempt_id==cancel.attempt_id {running.cancel.store(true,Ordering::SeqCst);} #[cfg(feature="system-helper")] if Path::new(rmm_agent_windows::helper_runtime::intent::DB).is_file() { let mut store=rmm_agent_windows::helper_runtime::intent::Store::open(true)?; if let Some(intent)=store.pending()?.first() && intent.permit()?.job_id.to_string()==cancel.job_id && intent.permit()?.attempt_id.to_string()==cancel.attempt_id {store.deny(&intent.request,Uuid::parse_str(&self.boot)?)?;store.cancel_before_dispatch(intent.id)?;} } if state=="accepted" {self.record(generation,&JobOffer::decode(bytes.as_slice())?,&grant,jobs::no_start("cancelled","CANCELLED_BEFORE_START"))?;needs_sync=true;} } let ack=self.envelope(generation,Payload::Ack(Ack{message_id:message.message_id}))?;channel.send(&ack).await?; }, _=>anyhow::bail!("UNSUPPORTED_SERVER_MESSAGE") } } } if stop.load(Ordering::SeqCst) { continue; } // This slice renews only passive clients. Job admission and helper // lifecycle are not extended by certificate maintenance. if !self.config.enable_jobs && rotation_at.elapsed() >= Duration::from_secs(30) { rotation_at = Instant::now(); let now = Utc::now().timestamp(); if self .certificates .due(self.journal.connection(), &self.key_files, now)? { self.renew_certificate().await?; // The server fences the previous connection generation. // A new Hello/Sync uses the newly selected pair. return Ok(()); } } if heartbeat.elapsed() >= heartbeat_after { let payload = Payload::Heartbeat(Heartbeat { instance_id: self.instance.clone(), uptime_seconds: self.started.elapsed().as_secs(), }); let h = self.envelope(generation, payload)?; channel.send(&h).await?; if channel.uses_https() { let poll = self.envelope( generation, Payload::Heartbeat(Heartbeat { instance_id: self.instance.clone(), uptime_seconds: self.started.elapsed().as_secs(), }), )?; channel.poll(poll).await?; } heartbeat = Instant::now(); heartbeat_after = Duration::from_millis(rand::random_range(27000..33000)); } if replay.elapsed() >= Duration::from_secs(5) { self.replay(&channel, generation).await?; replay = Instant::now(); } if !stop.load(Ordering::SeqCst) && inventory.elapsed() >= Duration::from_secs(86400) { self.queue_inventory(generation)?; inventory = Instant::now(); } if !stop.load(Ordering::SeqCst) && update_at.elapsed() >= Duration::from_secs(60) { self.queue_update_observation(generation)?; update_at = Instant::now(); } } Ok(()) } async fn renew_certificate(&mut self) -> Result<()> { ensure!(!self.config.enable_jobs, "PASSIVE_RENEWAL_ONLY"); self.close_gate(); let request = self.certificates.prepare( self.journal.connection_mut(), &self.key_files, Utc::now().timestamp(), )?; let client = crate::https_channel::mtls_client( self.config.connect_address, &self.ca, &request.identity.certificate_pem, &request.identity.private_key_pem, )?; let response = client .post(format!( "https://{}:{}/agent/v1/certificates/renew", crate::https_channel::server_name()?, self.config.connect_address.port() )) .json(&serde_json::json!({"csr_pem":request.csr_pem})) .send() .await?; let bytes = crate::https_channel::bounded_body(response, 65536, "application/json").await?; self.certificates.install( self.journal.connection_mut(), &self.key_files, &request, &bytes, Utc::now().timestamp(), ) } } fn service_run(stop: &'static AtomicBool) -> Result<()> { let arguments: Vec = std::env::args().skip(1).collect(); ensure!( arguments.len() == 3 && arguments[0] == "--service" && arguments[1] == "--config", "SERVICE_ARGUMENTS" ); let path = Path::new(&arguments[2]); ensure!(path.is_absolute(), "ABSOLUTE_CONFIG_REQUIRED"); let config: Config = serde_json::from_slice(&protected_read(path, 32768)?)?; native::require_local_service()?; ensure!( config.state_directory.is_absolute(), "ABSOLUTE_STATE_REQUIRED" ); native::private_path(&config.state_directory, true)?; ensure!( crate::https_channel::server_name()? == config.server_name, "SERVER_NAME" ); let ca = protected_read(&config.ca_file, 32768)?; for child in fs::read_dir(&config.state_directory)? { let child = child?; native::private_path(&child.path(), child.file_type()?.is_dir())?; } let journal = Journal::open(&config.state_directory)?; let runtime = tokio::runtime::Builder::new_multi_thread() .enable_all() .worker_threads(2) .build()?; runtime.block_on(async move { let identity = enrollment(&config, &ca).await?; let mut journal=journal; journal.pin_identity(&identity.agent_id)?; let boot = native::boot_id().await?; let binding=config.job_binding_file.as_deref().map(readonly_binding).transpose()?; if let Some(binding)=&binding { ensure!(binding.agent_id.to_string()==identity.agent_id && binding.asset_id.to_string()==identity.asset_id,"ENROLLMENT_JOB_BINDING_MISMATCH"); native::private_path(&config.state_directory.join("jobs"),true)?; import_legacy_inventory(&mut journal)?; } ensure!(!config.enable_jobs || binding.is_some(),"ENABLED_JOBS_REQUIRE_BINDING"); let certificates=RotationStore::new(Uuid::parse_str(&identity.agent_id)?,binding.as_ref().map_or(1,|b|b.enrollment_generation),ca.clone())?; let key_files=ProtectedKeyFiles::open(&config.state_directory)?; certificates.initialize(journal.connection_mut(),&key_files,&protected_read(&config.state_directory.join("device.pem"),32768)?,Utc::now().timestamp())?; // SQLite and sidecars inherit the same service-SID-only state ACL. for child in fs::read_dir(&config.state_directory)? { let child=child?;native::private_path(&child.path(),child.file_type()?.is_dir())?; } 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::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 { config, identity, ca, journal, certificates, key_files, boot, 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)), #[cfg(feature="system-helper")] helper:None, #[cfg(feature="system-helper")] helper_probe:None, #[cfg(feature="system-helper")] helper_probe_at:Instant::now()-Duration::from_secs(30), #[cfg(feature="system-helper")] helper_control:None, #[cfg(feature="system-helper")] helper_anchor:None, #[cfg(feature="system-helper")] helper_checked:false, #[cfg(feature="system-helper")] helper_refused:false, prepared:false,fence:Arc::new(EffectFence::default()),completed_tx,completed_rx,running:None,deferred_permit:None, }; agent.recover_interrupted()?; let mut backoff = 1; while !stop.load(Ordering::SeqCst) || agent.running.is_some() { if stop.load(Ordering::SeqCst) { agent.close_gate(); if let Some(running)=&agent.running {running.cancel.store(true,Ordering::SeqCst);} if let Ok(completion)=agent.completed_rx.try_recv(){agent.completed(0,completion)?;} if agent.running.as_ref().is_some_and(|r|r.worker.is_finished()) { let running=agent.running.as_ref().context("RUNNING_REQUIRED")?; agent.completed(0,(running.offer.clone(),running.grant.clone(),Outcome::unknown("EXECUTOR_THREAD_INTERRUPTED")))?; } if agent.running.is_some() {tokio::select!{Some(completion)=agent.completed_rx.recv()=>agent.completed(0,completion)?,_=tokio::time::sleep(Duration::from_millis(250))=>{}}} continue; } let start = Instant::now(); let _ = agent.session(stop).await; if start.elapsed() > Duration::from_secs(60) { backoff = 1; } let delay = crate::https_channel::retry_delay(backoff); backoff = (backoff + 1).min(6); let until = Instant::now() + delay; while Instant::now() < until && (!stop.load(Ordering::SeqCst) || agent.running.is_some()) { if stop.load(Ordering::SeqCst) { agent.close_gate();if let Some(running)=&agent.running {running.cancel.store(true,Ordering::SeqCst);} } if let Ok(completion)=agent.completed_rx.try_recv(){agent.completed(0,completion)?;} if agent.running.as_ref().is_some_and(|r|r.worker.is_finished()) { let running=agent.running.as_ref().context("RUNNING_REQUIRED")?; agent.completed(0,(running.offer.clone(),running.grant.clone(),Outcome::unknown("EXECUTOR_THREAD_INTERRUPTED")))?; } tokio::time::sleep(Duration::from_millis(250)).await; } } Ok(()) }) } pub fn main() -> Result<()> { let args: Vec = std::env::args().skip(1).collect(); if args.first().map(String::as_str) == Some(rmm_agent_windows::event_log_job::MODE) { ensure!(args.len() == 2, "EVENT_LOG_WORKER_ARGUMENTS"); return rmm_agent_windows::event_log_job::worker(Path::new(&args[1])); } if args == ["--help"] { println!( "Development Windows service. --service --config ABSOLUTE_PATH. Jobs disabled by default; require qualified clock, provisioned signing binding, signed Sync and WebUI-authorized grant. No approval bypass." ); return Ok(()); } if args == ["--native-probe"] { let runtime = tokio::runtime::Runtime::new()?; let boot = runtime.block_on(native::boot_id())?; let inventory = native::snapshot()?; println!( "{}", serde_json::json!({"platform":"windows","architecture":std::env::consts::ARCH,"hostname_available":!inventory["hostname"].as_str().unwrap_or("").is_empty(),"system_volume_available":inventory["root_available_bytes"].as_u64().is_some(),"inodes":null,"boot_id":boot,"capabilities":CAPABILITIES,"jobs_supported":false}) ); return Ok(()); } ensure!( args.first().map(String::as_str) == Some("--service"), "UNKNOWN_ARGUMENT" ); ensure!( args.len() == 3 && args[1] == "--config", "SERVICE_ARGUMENTS" ); let config: Config = serde_json::from_slice(&protected_read(Path::new(&args[2]), 32768)?)?; // Shared transport reads its one DNS identity. Set it before SCM dispatch // creates its service thread and before any Tokio/collector threads exist. unsafe { std::env::set_var("RMM_SERVER_NAME", &config.server_name); } ensure!( crate::https_channel::server_name()? == config.server_name, "SERVER_NAME" ); rmm_agent_windows::service::dispatch(service_run) } #[cfg(test)] mod tests { use super::*; #[cfg(feature = "system-helper")] #[test] fn bound_helper_unknown_repairs_generic_crash_gap_without_ack_or_duplicate_result() { let path = std::env::temp_dir().join(format!("windows-bound-unknown-{}", Uuid::new_v4())); fs::create_dir(&path).unwrap(); let journal = Journal::open(&path).unwrap(); let db = journal.connection(); let job = Uuid::new_v4(); let attempt = Uuid::new_v4(); let grant = Uuid::new_v4(); let offer = JobOffer { job_id: job.to_string(), attempt_id: attempt.to_string(), ..Default::default() }; db.execute("INSERT INTO job_attempts(job,attempt,offer,state,revision,grant_id) VALUES(?1,?2,?3,'unknown',1,?4)",rusqlite::params![offer.job_id,offer.attempt_id,offer.encode_to_vec(),grant.to_string()]).unwrap(); let original = Envelope { message_id: Uuid::new_v4().to_string(), payload: Some(Payload::JobResult(jobs::result( &offer, 1, &grant.to_string(), Outcome::unknown("GENERIC_REPLY_LOST"), ))), ..Default::default() }; jobs::event(db, &original).unwrap(); let mut actual = Outcome::unknown("SYSTEM_PREVIOUS_EFFECT_UNRESOLVED"); actual.evidence = serde_json::json!({"retained_helper_evidence":true}); let bound = rmm_agent_windows::helper_runtime::BoundOutcome { job_id: job, attempt_id: attempt, grant_id: grant, outcome: actual.clone(), }; // Represents a crash after actual raw-helper outcome persistence but // before the corresponding journal write, even if mirror receipt exists. assert!(needs_bound_outcome(db, &bound).unwrap()); assert_eq!(jobs::events(db).unwrap().len(), 1); let revision = jobs::transition(db, &offer, "unknown", &grant.to_string()).unwrap(); let repaired = Envelope { message_id: Uuid::new_v4().to_string(), payload: Some(Payload::JobResult(jobs::result( &offer, revision, &grant.to_string(), actual, ))), ..Default::default() }; jobs::event(db, &repaired).unwrap(); assert!(!needs_bound_outcome(db, &bound).unwrap()); assert_eq!(jobs::events(db).unwrap().len(), 2); // retention is never ACK let mut terminal = bound.outcome.clone(); terminal.state = "failed".into(); let terminal_bound = rmm_agent_windows::helper_runtime::BoundOutcome { job_id: job, attempt_id: attempt, grant_id: grant, outcome: terminal.clone(), }; let revision = jobs::transition(db, &offer, "failed", &grant.to_string()).unwrap(); jobs::event( db, &Envelope { message_id: Uuid::new_v4().to_string(), payload: Some(Payload::JobResult(jobs::result( &offer, revision, &grant.to_string(), terminal, ))), ..Default::default() }, ) .unwrap(); // Two restarts after the terminal journal committed but before a // mirror receipt may never request terminal -> terminal transitions. assert!(!needs_bound_outcome(db, &terminal_bound).unwrap()); assert!(!needs_bound_outcome(db, &terminal_bound).unwrap()); assert_eq!(jobs::events(db).unwrap().len(), 3); drop(journal); fs::remove_dir_all(path).unwrap(); } #[test] fn old_passive_configuration_cannot_enable_jobs_or_read_the_clock() { 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::new(config.enable_jobs); assert_eq!( clock.now().unwrap_err().to_string(), "WINDOWS_JOBS_NOT_ENABLED" ); } #[test] fn legacy_inventory_keeps_original_bytes_until_concrete_core_ack() { let directory = std::env::temp_dir().join(format!("windows-runtime-import-{}", Uuid::new_v4())); fs::create_dir(&directory).unwrap(); let mut journal = Journal::open(&directory).unwrap(); journal.pin_identity("retained").unwrap(); let sequence = journal.next_sequence().unwrap(); let envelope = Envelope { message_id: Uuid::new_v4().to_string(), sequence, payload: Some(Payload::InventorySnapshot(InventorySnapshot::default())), ..Default::default() }; journal.save(&envelope).unwrap(); let mut original = envelope.encode_to_vec(); original.extend([0xf8, 0x07, 0x01]); // Unknown additive protobuf field must remain byte-exact. journal .connection() .execute( "UPDATE events SET payload=?1 WHERE id=?2", rusqlite::params![&original, &envelope.message_id], ) .unwrap(); import_legacy_inventory(&mut journal).unwrap(); for table in ["events", "job_events"] { let bytes: Vec = journal .connection() .query_row( &format!("SELECT payload FROM {table} WHERE id=?1"), [&envelope.message_id], |r| r.get(0), ) .unwrap(); assert_eq!(bytes, original); } jobs::ack(journal.connection_mut(), &Uuid::new_v4().to_string()).unwrap(); assert_eq!(journal.count().unwrap(), 1); import_legacy_inventory(&mut journal).unwrap(); // Exact same-ID copy is idempotent. assert_eq!(journal.next_sequence().unwrap(), sequence + 1); jobs::ack(journal.connection_mut(), &envelope.message_id).unwrap(); assert_eq!(journal.count().unwrap(), 0); assert!(jobs::events(journal.connection()).unwrap().is_empty()); drop(journal); fs::remove_dir_all(directory).unwrap(); } #[test] fn worker_fence_requires_same_generation_and_entire_clock_interval() { struct Clock(chrono::DateTime); impl SyncClock for Clock { fn now(&self) -> Result> { Ok(self.0) } } let now = Utc::now(); let fence = EffectFence::default(); fence.deadline.store( (now + chrono::Duration::seconds(3)).timestamp_millis(), Ordering::SeqCst, ); assert!(!fence.allows(1, &Clock(now))); fence.generation.store(1, Ordering::SeqCst); assert!(fence.allows(1, &Clock(now))); assert!(!fence.allows_identity(1, true, &Clock(now))); fence.helper_generation.store(1, Ordering::SeqCst); assert!(fence.allows_identity(1, true, &Clock(now))); assert!(!fence.allows(2, &Clock(now))); assert!(!fence.allows(1, &Clock(now + chrono::Duration::seconds(1)))); fence.close(); assert!(!fence.allows_identity(1, true, &Clock(now))); assert!(!fence.allows(1, &Clock(now))); } }