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::{CAPABILITIES, 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, // False until the independent LocalService clock qualification is complete. #[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 { native: Arc, enabled: bool, } impl SyncClock for JobClock { fn now(&self) -> Result> { ensure!(self.enabled, "WINDOWS_JOBS_NOT_ENABLED"); self.native.now() } } #[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.now().is_ok_and(|now| { (now + chrono::Duration::seconds(2)).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 readonly_binding(path: &Path) -> Result { use std::ptr; use windows_sys::Win32::{ Foundation::LocalFree, Security::{ self, ACCESS_ALLOWED_ACE, ACL, Authorization::{ConvertSidToStringSidW, GetNamedSecurityInfoW, SE_FILE_OBJECT}, DACL_SECURITY_INFORMATION, OWNER_SECURITY_INFORMATION, }, }; unsafe fn sid(sid: Security::PSID) -> Result { let mut raw = ptr::null_mut(); ensure!( unsafe { ConvertSidToStringSidW(sid, &mut raw) } != 0, "BINDING_SID" ); let mut len = 0; while unsafe { *raw.add(len) } != 0 { len += 1; ensure!(len < 256, "BINDING_SID_LIMIT"); } let value = String::from_utf16(unsafe { std::slice::from_raw_parts(raw, len) })?; unsafe { LocalFree(raw.cast()); } Ok(value) } ensure!(path.is_absolute(), "ABSOLUTE_JOB_BINDING_REQUIRED"); // The immediate configuration directory must also deny agent replacement. for (item, directory) in [ (path, false), (path.parent().context("BINDING_PARENT")?, true), ] { native::private_path(item, directory)?; let mut owner = ptr::null_mut(); let mut dacl: *mut ACL = ptr::null_mut(); let mut descriptor = ptr::null_mut(); let status = unsafe { GetNamedSecurityInfoW( native::wide(item).as_ptr(), SE_FILE_OBJECT, OWNER_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION, &mut owner, ptr::null_mut(), &mut dacl, ptr::null_mut(), &mut descriptor, ) }; ensure!(status == 0, "BINDING_SECURITY"); let check = (|| -> Result<()> { ensure!(!owner.is_null() && !dacl.is_null(), "BINDING_NULL_SECURITY"); ensure!( matches!(unsafe { sid(owner) }?.as_str(), "S-1-5-18" | "S-1-5-32-544"), "BINDING_ADMIN_OWNER_REQUIRED" ); for index in 0..unsafe { (*dacl).AceCount } { let mut raw = ptr::null_mut(); ensure!( unsafe { Security::GetAce(dacl, u32::from(index), &mut raw) } != 0, "BINDING_ACE" ); let ace = unsafe { &*raw.cast::() }; ensure!( ace.Header.AceType == 0 && usize::from(ace.Header.AceSize) >= std::mem::size_of::(), "BINDING_ACE_TYPE" ); let who = unsafe { sid(ptr::addr_of!(ace.SidStart).cast_mut().cast()) }?; if !matches!(who.as_str(), "S-1-5-18" | "S-1-5-32-544") { // Generic write/all, owner/DACL/delete and all file/directory mutation bits. ensure!(ace.Mask & 0x500d_0156 == 0, "BINDING_AGENT_WRITE_FORBIDDEN"); } } Ok(()) })(); unsafe { LocalFree(descriptor.cast()); } check?; } let binding: Binding = serde_json::from_slice(&protected_read(path, 8192)?)?; ensure!( !binding.tenant_id.is_nil() && !binding.agent_id.is_nil() && !binding.asset_id.is_nil() && binding.enrollment_generation > 0 && binding.assignment_version > 0 && binding.public_key_hex.len() == 64 && binding .public_key_hex .bytes() .all(|b| b.is_ascii_hexdigit()), "JOB_BINDING_PROFILE" ); Ok(binding) } 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, boot: String, instance: String, started: Instant, binding: Option, ledger: Option, _ledger_file: Option, clock: JobClock, 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 { fn close_gate(&mut self) { self.fence.close(); 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; self.sync .as_mut() .context("SYNC_NOT_CONFIGURED")? .confirm_helper(&rmm_agent_windows::helper_runtime::map_snapshot( &snapshot.raw, ))?; 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")] { 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(); if self.config.enable_jobs && 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() { // 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 worker = tokio::spawn(async move { let _result = helper .delegate(intent, move || { 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 worker = tokio::task::spawn_blocking(move || { let 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 script = if matches!(job.action, Action::RunScript { .. }) { match rmm_agent_windows::actions::Script::prepare( &job, &directory, work_grant.grant_id, ) { Ok(script) => Some(script), Err(_) => return Ok(jobs::no_start("failed", "SCRIPT_PREPARATION_FAILED")), } } else { None }; // 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", )); } if let Some(script) = script { script.run(&job, &worker_cancel) } else { rmm_agent_windows::actions::inventory(&job) } })() .unwrap_or_else(|_| Outcome::unknown("WINDOWS_EXECUTOR_EFFECT_UNKNOWN")); 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) } } async fn session(&mut self, stop: &AtomicBool) -> Result<()> { self.close_gate(); let result = self.session_inner(stop).await; self.close_gate(); result } async fn session_inner(&mut self, stop: &AtomicBool) -> Result<()> { 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 = crate::certificate_rotation::DeviceIdentity { certificate_pem: protected_read( &self.config.state_directory.join("device.pem"), 32768, )?, private_key_pem: protected_read( &self.config.state_directory.join("device.key"), 16384, )?, }; 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.queue_inventory(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 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.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; } 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(); } } Ok(()) } } 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 (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 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, boot, instance: Uuid::new_v4().to_string(), started: Instant::now(), binding, ledger, _ledger_file:ledger_file, clock, sync, #[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 == ["--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 { native: Arc::new(rmm_agent_windows::clock::NativeClock::new()), enabled: 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))); } }