Files
rust-discovery/crates/agent-windows/src/runtime.rs
T
2026-11-14 10:06:10 +01:00

1763 lines
74 KiB
Rust

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<PathBuf>,
// 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<Vec<u8>> {
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<EnrollmentResponse> {
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<rmm_agent_windows::clock::NativeClock>,
enabled: bool,
}
impl SyncClock for JobClock {
fn now(&self) -> Result<chrono::DateTime<Utc>> {
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<bool> {
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<Vec<u8>>=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<AtomicBool>,
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<Binding> {
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<String> {
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::<ACCESS_ALLOWED_ACE>() };
ensure!(
ace.Header.AceType == 0
&& usize::from(ace.Header.AceSize)
>= std::mem::size_of::<ACCESS_ALLOWED_ACE>(),
"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<u8>>(1)?))
})?
.collect::<rusqlite::Result<Vec<_>>>()?
};
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<Vec<u8>> = 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<String> = 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<rmm_agent_windows::helper_runtime::BoundOutcome>,
)>,
);
#[cfg(feature = "system-helper")]
enum HelperControl {
Snapshot(
u64,
tokio::task::JoinHandle<Result<rmm_agent_windows::helper_runtime::ControlSnapshot>>,
),
Apply(
u64,
tokio::task::JoinHandle<Result<rmm_agent_windows::helper_runtime::ControlSnapshot>>,
),
Mirror(u64, tokio::task::JoinHandle<MirrorCompletion>),
}
#[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<Self> {
match self {
Self::Snapshot(_, t) | Self::Apply(_, t) => {
t.abort();
None
}
mirror @ Self::Mirror(..) => Some(mirror),
}
}
}
struct Agent {
config: Config,
identity: EnrollmentResponse,
ca: Vec<u8>,
journal: Journal,
boot: String,
instance: String,
started: Instant,
binding: Option<Binding>,
ledger: Option<Connection>,
_ledger_file: Option<fs::File>,
clock: JobClock,
sync: Option<reconcile::ClientSync>,
prepared: bool,
#[cfg(feature = "system-helper")]
prepared_request: Option<Vec<u8>>,
#[cfg(feature = "system-helper")]
helper_lane: Arc<tokio::sync::Semaphore>,
#[cfg(feature = "system-helper")]
helper: Option<rmm_agent_windows::helper_runtime::Client>,
#[cfg(feature = "system-helper")]
helper_probe:
Option<tokio::task::JoinHandle<Result<Option<rmm_agent_windows::helper_runtime::Client>>>>,
#[cfg(feature = "system-helper")]
helper_probe_at: Instant,
#[cfg(feature = "system-helper")]
helper_control: Option<HelperControl>,
#[cfg(feature = "system-helper")]
helper_anchor: Option<rmm_agent_core::helper_reconcile::NoStartAnchor>,
#[cfg(feature = "system-helper")]
helper_checked: bool,
#[cfg(feature = "system-helper")]
helper_refused: bool,
fence: Arc<EffectFence>,
completed_tx: tokio::sync::mpsc::Sender<Completion>,
completed_rx: tokio::sync::mpsc::Receiver<Completion>,
running: Option<Running>,
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<u8> = 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<reconcile::Channel> {
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<String> {
let mut caps: Vec<String> = 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<u8> = 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<Outcome> {
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<Envelope> {
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<Vec<u8>>=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<u8>,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<String> = 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<String> = 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<u8> = 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<Utc>);
impl SyncClock for Clock {
fn now(&self) -> Result<chrono::DateTime<Utc>> {
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)));
}
}