//! Authenticated local control of the SAME consumed SYSTEM update. IPC bytes //! identify an original attempt; actual retained handles supply every proof. use crate::{ helper_ipc::{PeerProof, Pin}, helper_system::{LedgerGuard, UpdateContext}, signed_clock::BoundClock, update_ipc, update_native::{Budget, services::Running}, update_original::Original, update_state::{Bundle, QualifiedRegistry, RetainedSet}, update_trust::TrustState, }; use anyhow::{Context, Result, ensure}; use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD}; use rmm_agent_core::{ auth::Binding, helper_reconcile::ExecutorLedgerGuard, reconcile::SyncClock, update_handoff::{ self as core, NativeControlOperation, NativeControlReply, NativeControlRequest, NativeEffect, NativeEffectStage, NativeService, Participant, UpdateParticipantGuard, }, }; use rmm_domain::{ agent_update::{ParticipantRole, UpdateDelegation}, jobs::hash, }; use rmm_updater_handoff::{Event, Evidence, Handoff, Phase, SignedHealth}; use rusqlite::Connection; use std::{cell::RefCell, path::Path, time::Duration}; use uuid::Uuid; pub(crate) struct Guard<'a, 'b> { ledger: &'a LedgerGuard, binding: &'a Binding, clock: &'a BoundClock, pin: &'a Pin, budget: &'a Budget<'b>, original: Original, trust: TrustState, bundle: Bundle, bundle_recheck: Box Result<()>>, retained: RetainedSet, registry: QualifiedRegistry, running: RefCell, own: RefCell, updater: RefCell>, participant: Participant, sqlite: usize, verified_health: RefCell>, publication: RefCell>, code_files: Vec<( crate::update_native::files::Proof, RefCell, )>, } impl<'a, 'b> Guard<'a, 'b> { pub(crate) fn open( db: &Connection, ledger: &'a LedgerGuard, binding: &'a Binding, clock: &'a BoundClock, pin: &'a Pin, budget: &'a Budget<'b>, grant: Uuid, ) -> Result { ledger.check(db)?; let journal = core::read(db, ledger, grant)?; ensure!( !matches!(journal.phase(), Phase::Unknown | Phase::OutcomePersisted), "UPDATE_NOT_ACTIVE" ); let (record,start):(Vec,Vec)=db.query_row( "SELECT h.record,e.start FROM agent_update_handoffs h JOIN execution_evidence e USING(grant_id) WHERE h.grant_id=?1", [grant.to_string()],|r|Ok((r.get(0)?,r.get(1)?)))?; let original = Original::verify_retained(binding, &start, &record, core::read_delegation(db, grant)?)?; let trust = TrustState::load_retained( original.update(), binding, original.delegation().prepared_at, )?; let (bundle, recheck) = Bundle::load(grant)?; ensure!( bundle.handoff_record == record && bundle.delegation == *original.delegation(), "UPDATE_ORIGINAL_BUNDLE_CHANGED" ); ensure!( ledger.update_identity(db)?.sha256()? == original.handoff().ledger_identity_sha256, "UPDATE_ORIGINAL_LEDGER_IDENTITY" ); let retained = RetainedSet::reopen(&bundle.retained)?; let registry = QualifiedRegistry::load(&trust)?; let running = Running::observe([pin.agent.clone(), pin.helper.clone()], budget)?; let own = PeerProof::for_service(&pin.helper, std::process::id())?; let identity = update_ipc::participant(&own, ParticipantRole::WindowsHelper)?; let restored = matches!( journal.phase(), Phase::RollbackLedgerReturnIntent | Phase::RollbackServicesStarted | Phase::RollbackHealthVerified ); let target = matches!( journal.phase(), Phase::LedgerReturnIntent | Phase::ServicesStarted | Phase::HealthVerified ); let participant = if identity == original.delegation().original_helper { Participant::OriginalHelper } else if restored && identity.image_sha256 == original.handoff().predecessor.helper_sha256 { Participant::RestoredHelper } else if target && identity.image_sha256 == original.handoff().target.helper_sha256 { Participant::NewHelper } else { Participant::Observer }; // Historical capture must be able to classify owner loss as Unknown; // an observer never authorizes an effect or a successful outcome. let updater_pin = crate::update_native::services::updater_pin(trust.policy())?; let updater = update_ipc::observe(&updater_pin, ParticipantRole::WindowsUpdater) .ok() .map(|(peer, _)| peer); // Read-sharing without WRITE/DELETE sharing makes the observed code // bytes immutable for this real control operation. Later checks retain // those exact handles/IDs/security instead of hashing EXEs repeatedly. let readers = vec![ crate::helper_ipc::service_sid(crate::SERVICE_NAME)?, crate::helper_ipc::service_sid(crate::helper_ipc::HELPER_SERVICE)?, crate::helper_ipc::service_sid(crate::update_ipc::SERVICE)?, ]; let mut code_files = vec![]; for bound in &bundle.files { let expected = if participant == Participant::NewHelper { &bound.staged } else { &bound.original }; let path = Path::new(bound.role.target()); let mut file = crate::helper_ipc::PinnedFile::open(path, false, &readers, &[], false)?; let proof = crate::update_native::files::proof(&mut file.file, path, bound.role.max_bytes())?; ensure!(&proof == expected, "UPDATE_ACTUAL_CODE_PAIR_FILES_CHANGED"); code_files.push((proof, RefCell::new(file))); } let result = Self { ledger, binding, clock, pin, budget, original, trust, bundle, bundle_recheck: Box::new(recheck), retained, registry, running: RefCell::new(running), own: RefCell::new(own), updater: RefCell::new(updater), participant, sqlite: unsafe { db.handle() } as usize, verified_health: RefCell::new(None), publication: RefCell::new(None), code_files, }; result.check(db)?; Ok(result) } fn current(&self) -> Result<()> { (self.bundle_recheck)()?; self.budget.check()?; if let Some(namespace) = self.publication.try_borrow()?.as_ref() { self.trust.recheck_other_protected()?; namespace.verify_original(self.trust.installed_raw())?; } else { self.trust.recheck_protected()?; } self.registry.verify()?; self.retained.verify()?; self.running.try_borrow_mut()?.check(self.budget)?; let proofs = self.running.try_borrow()?.proofs(); let pair = if self.participant == Participant::NewHelper { &self.original.handoff().target } else { &self.original.handoff().predecessor }; ensure!( proofs[0].process.image_sha256 == pair.agent_sha256 && proofs[1].process.image_sha256 == pair.helper_sha256 && proofs .iter() .zip(&self.trust.policy().services) .all(|(actual, pin)| serde_json::to_vec(&actual.configuration) .is_ok_and(|raw| hash(&raw) == pin.unit_sha256)), "UPDATE_ACTUAL_PAIR_CONFIGURATION_CHANGED" ); let updater = crate::update_native::services::updater_pin(self.trust.policy())?; ensure!( crate::update_native::services::updater_configuration_sha256(&updater)? == self.trust.policy().updater_service.unit_sha256, "UPDATE_UPDATER_CONFIGURATION_CHANGED" ); self.own.try_borrow_mut()?.check()?; for (proof, file) in &self.code_files { let mut file = file.try_borrow_mut()?; file.check()?; ensure!( file.identity == proof.identity && file.file.metadata()?.len() == proof.bytes && crate::update_native::files::security_sha256(&file.file)? == proof.security_sha256, "UPDATE_HELD_CODE_FILES_CHANGED" ); } Ok(()) } fn owner_current(&self) -> Result<()> { ensure!( self.participant != Participant::Observer, "UPDATE_ACTUAL_HELPER_GENERATION_REQUIRED" ); let mut owner = self.updater.try_borrow_mut()?; let owner = owner .as_mut() .context("UPDATE_ORIGINAL_UPDATER_UNAVAILABLE")?; owner.check()?; ensure!( update_ipc::participant(owner, ParticipantRole::WindowsUpdater)? == self.original.delegation().updater, "UPDATE_ORIGINAL_UPDATER_PROCESS_CHANGED" ); Ok(()) } fn effects(&self, db: &Connection) -> Result<()> { self.check(db)?; self.owner_current()?; self.original .check_current(self.binding, self.clock, self.budget)?; self.trust .recheck_crypto(self.original.update(), self.clock)?; self.trust.qualify_history(db, self.ledger, self.binding) } fn same(&self, h: &Handoff, d: &UpdateDelegation) -> Result<()> { ensure!( h.bytes()? == self.original.handoff().bytes()? && d == self.original.delegation(), "UPDATE_ORIGINAL_OWNER_CHANGED" ); self.current() } fn started(&self) -> Result<(Vec, String)> { self.current()?; let proofs = self.running.try_borrow()?.proofs(); for (p, b) in proofs.iter().zip([&self.pin.agent, &self.pin.helper]) { ensure!( p.process.image_sha256 == b.binary_sha256, "UPDATE_STARTED_IMAGE_CHANGED" ); } Ok(( proofs.iter().map(|p| p.started()).collect(), hash(&serde_json::to_vec(&proofs)?), )) } fn verify_health(&self, db: &Connection, signed: &SignedHealth) -> Result<()> { self.effects(db)?; ensure!( matches!( self.participant, Participant::NewHelper | Participant::RestoredHelper ), "UPDATE_NEW_HELPER_REQUIRED" ); let mut journal = core::read(db, self, self.original.permit().grant_id)?; if matches!( journal.phase(), Phase::ServicesStarted | Phase::RollbackServicesStarted ) { let event = journal.prepare( u64::try_from(self.clock.reading()?.upper.timestamp())?, if self.participant == Participant::RestoredHelper { Evidence::RollbackHealthVerified { receipt: signed.clone(), } } else { Evidence::HealthVerified { receipt: signed.clone(), } }, )?; journal.replay(&event)?; } else { ensure!( matches!( journal.phase(), Phase::HealthVerified | Phase::RollbackHealthVerified ), "UPDATE_HEALTH_PHASE" ); let raw:Vec=db.query_row("SELECT event FROM agent_update_handoff_events WHERE grant_id=?1 ORDER BY sequence DESC LIMIT 1", [self.original.permit().grant_id.to_string()],|r|r.get(0))?; let event: Event = serde_json::from_slice(&raw)?; ensure!( hash(&raw) == journal.head_sha256() && match event.evidence { Evidence::HealthVerified { receipt } | Evidence::RollbackHealthVerified { receipt } => receipt == *signed, _ => false, }, "UPDATE_ORIGINAL_STORED_HEALTH_REQUIRED" ); } let receipt: rmm_updater_handoff::HealthReceipt = serde_json::from_slice(&signed.payload)?; let (generation,agent,helper):(u64,String,String)=db.query_row( "SELECT generation,agent_journal_id,journal_id FROM helper_sync_meta WHERE id=1 AND fault IS NULL",[], |r|Ok((r.get(0)?,r.get(1)?,r.get(2)?)))?; ensure!( generation == receipt.connection_generation && agent == receipt.agent_journal_id.to_string() && helper == receipt.helper_journal_id.to_string() && self.started()?.0 == receipt.service_processes, "UPDATE_HEALTH_CURRENT_CHANNEL_OR_PROCESSES" ); rmm_agent_core::update_health_sync::verified_span( db, self.ledger, self.binding, self.original.handoff(), &receipt, self.trust.health_public_key(), )?; verify_inventory(&self.retained, &self.original, &receipt)?; *self.verified_health.try_borrow_mut()? = Some(hash(&serde_json::to_vec(signed)?)); Ok(()) } } impl ExecutorLedgerGuard for Guard<'_, '_> { fn check(&self, db: &Connection) -> Result<()> { self.ledger.check(db)?; self.current()?; ensure!( unsafe { db.handle() } as usize == self.sqlite, "UPDATE_ORIGINAL_SQLITE_HANDLE_CHANGED" ); ensure!( self.ledger.update_identity(db)?.sha256()? == self.original.handoff().ledger_identity_sha256, "UPDATE_ORIGINAL_LEDGER_CHANGED" ); let start: Vec = db.query_row( "SELECT start FROM execution_evidence WHERE grant_id=?1", [self.original.permit().grant_id.to_string()], |r| r.get(0), )?; ensure!( start == self.original.start_bytes(), "UPDATE_ORIGINAL_START_CHANGED" ); Ok(()) } fn check_update_owner( &self, h: &Handoff, d: &UpdateDelegation, _phase: Phase, _events: &[Event], ) -> Result<()> { self.same(h, d)?; self.owner_current()?; self.original .check_current(self.binding, self.clock, self.budget)?; self.trust .recheck_crypto(self.original.update(), self.clock) } } impl UpdateParticipantGuard for Guard<'_, '_> { fn participant(&self) -> Participant { self.participant } fn verify_native_effect( &self, h: &Handoff, d: &UpdateDelegation, effect: &NativeEffect, stage: NativeEffectStage, ) -> Result<()> { self.same(h, d)?; self.owner_current()?; self.original .check_current(self.binding, self.clock, self.budget)?; self.trust .recheck_crypto(self.original.update(), self.clock)?; match (effect, stage) { ( NativeEffect::StopService { service: NativeService::WindowsAgent | NativeService::WindowsHelper, }, NativeEffectStage::Claim, ) if self.participant == Participant::OriginalHelper => { let proofs = self.running.try_borrow()?.proofs(); self.registry .verify_observed(&proofs, &self.trust.policy().updater_service.unit_sha256)?; ensure!( proofs[0].process.image_sha256 == h.predecessor.agent_sha256 && proofs[1].process.image_sha256 == h.predecessor.helper_sha256, "UPDATE_STOP_PREDECESSOR_REQUIRED" ); Ok(()) } (NativeEffect::StartService { service }, NativeEffectStage::Observe) if self.participant == Participant::NewHelper => { self.verify_started_service( *service, h.target.agent_sha256.as_str(), h.target.helper_sha256.as_str(), ) } (NativeEffect::RollbackStartService { service }, NativeEffectStage::Observe) if self.participant == Participant::RestoredHelper => { self.verify_started_service( *service, h.predecessor.agent_sha256.as_str(), h.predecessor.helper_sha256.as_str(), ) } ( NativeEffect::SaveInstalledRecord { .. } | NativeEffect::PublishInstalledRecord { .. }, NativeEffectStage::Claim | NativeEffectStage::Observe, ) if self.participant == Participant::NewHelper => self .publication .try_borrow()? .as_ref() .context("UPDATE_RECORD_NAMESPACE_REQUIRED")? .verify_effect(effect, stage == NativeEffectStage::Observe), _ => anyhow::bail!("UPDATE_WINDOWS_HELPER_EFFECT_NOT_QUALIFIED"), } } fn verify_update_event(&self, h: &Handoff, d: &UpdateDelegation, event: &Event) -> Result<()> { self.same(h, d)?; self.owner_current()?; self.original .check_current(self.binding, self.clock, self.budget)?; self.trust .recheck_crypto(self.original.update(), self.clock)?; match &event.evidence { Evidence::ServicesStarted { services, ledger_identity_sha256, observation_sha256, } | Evidence::RollbackServicesStarted { services, ledger_identity_sha256, observation_sha256, } => { let (actual, digest) = self.started()?; ensure!( *services == actual && *observation_sha256 == digest && *ledger_identity_sha256 == self.bundle.ledger.sha256()?, "UPDATE_ACTUAL_STARTS_REQUIRED" ); Ok(()) } Evidence::HealthVerified { receipt } | Evidence::RollbackHealthVerified { receipt } => { ensure!( self.verified_health.try_borrow()?.as_ref() == Some(&hash(&serde_json::to_vec(receipt)?)), "UPDATE_ACTUAL_LOCAL_HEALTH_REQUIRED" ); Ok(()) } Evidence::OutcomePersisted { .. } => { ensure!( self.verified_health.try_borrow()?.is_some(), "UPDATE_ACTUAL_HEALTH_REQUIRED" ); self.publication .try_borrow()? .as_ref() .context("UPDATE_RECORD_NAMESPACE_REQUIRED")? .published() } Evidence::RollbackOutcomePersisted { .. } => { ensure!( self.participant == Participant::RestoredHelper && self.publication.try_borrow()?.is_none() && self.verified_health.try_borrow()?.is_some(), "UPDATE_ROLLBACK_NO_RECORD_CHANGE" ); self.trust.recheck_protected() } _ => anyhow::bail!("UPDATE_WINDOWS_HELPER_EVENT_NOT_QUALIFIED"), } } } impl Guard<'_, '_> { fn verify_started_service( &self, service: NativeService, agent: &str, helper: &str, ) -> Result<()> { let (service, image) = match service { NativeService::WindowsAgent => (crate::update_native::Service::Agent, agent), NativeService::WindowsHelper => (crate::update_native::Service::Helper, helper), _ => anyhow::bail!("UPDATE_WINDOWS_SERVICE_REQUIRED"), }; ensure!( self.running .try_borrow()? .proofs() .iter() .any(|p| p.configuration.service == service && p.process.image_sha256 == image), "UPDATE_ACTUAL_STARTED_SERVICE_REQUIRED" ); Ok(()) } } pub(crate) fn handle_updater( ctx: UpdateContext<'_>, peer: &mut PeerProof, request: &NativeControlRequest, ) -> Result { handle(ctx, peer, request, false) } pub(crate) fn handle_agent_health( ctx: UpdateContext<'_>, peer: &mut PeerProof, request: &NativeControlRequest, ) -> Result { ensure!( matches!(request.method, NativeControlOperation::Health { .. }), "UPDATE_AGENT_HEALTH_ONLY" ); handle(ctx, peer, request, true) } fn handle( ctx: UpdateContext<'_>, peer: &mut PeerProof, request: &NativeControlRequest, agent_health: bool, ) -> Result { ensure!( request.operation == "agent_update_control_v1" && request.schema_version == 1 && !request.challenge.is_nil() && request.tenant_id == ctx.binding.tenant_id && request.asset_id == ctx.binding.asset_id && request.agent_id == ctx.binding.agent_id && request.enrollment_generation == ctx.binding.enrollment_generation && request.assignment_version == ctx.binding.assignment_version, "UPDATE_CONTROL_BINDING" ); use rmm_agent_core::helper_reconcile::BootSource; let budget = Budget::new(ctx.boot, ctx.boot.current_boot()?, Duration::from_secs(5))?; let guard = Guard::open( ctx.db, ctx.guard, ctx.binding, ctx.clock, ctx.pin, &budget, request.grant_id, )?; let header = guard.original.handoff(); ensure!( header.owner_nonce == request.owner_nonce && hash(&header.bytes()?) == request.handoff_sha256, "UPDATE_CONTROL_ORIGINAL_REQUIRED" ); peer.check()?; if agent_health { peer.identity() .validate(&ctx.pin.agent, peer.identity().pid)?; let agent = guard.running.try_borrow()?.proofs()[0].process.clone(); ensure!( peer.identity().pid == agent.pid && peer.identity().creation_ticks == agent.birth && peer.identity().image_sha256 == agent.image_sha256, "UPDATE_CURRENT_AGENT_PEER_REQUIRED" ); } else { ensure!( update_ipc::participant(peer, ParticipantRole::WindowsUpdater)? == guard.original.delegation().updater, "UPDATE_ORIGINAL_UPDATER_PEER_REQUIRED" ); } if !matches!(request.method, NativeControlOperation::ReadOriginal) { ensure!(ctx.sync.is_some(), "UPDATE_EXISTING_SYNC_OWNER_REQUIRED"); let generation: u64 = ctx.db.query_row( "SELECT generation FROM helper_sync_meta WHERE id=1 AND fault IS NULL", [], |r| r.get(0), )?; ctx.clock.require_generation(generation)?; guard.effects(ctx.db)?; } let mut original_start_base64url = None; let mut original_outcome_base64url = None; let mut claim = None; match &request.method { NativeControlOperation::ReadOriginal => { original_start_base64url = Some(URL_SAFE_NO_PAD.encode(guard.original.start_bytes())) } NativeControlOperation::ClaimStop { expected_head_sha256, service, } => { claim = Some(core::claim_native_effect( ctx.db, &guard, request.grant_id, expected_head_sha256, &NativeEffect::StopService { service: *service }, ctx.clock.reading()?.upper, )?); } NativeControlOperation::ObserveStarts { services, observation_sha256, } => { let journal = core::read(ctx.db, &guard, request.grant_id)?; ensure!( matches!( journal.phase(), Phase::LedgerReturnIntent | Phase::RollbackLedgerReturnIntent ), "UPDATE_START_PHASE" ); let (actual, digest) = guard.started()?; ensure!( *services == actual && *observation_sha256 == digest, "UPDATE_ACTUAL_STARTS_REQUIRED" ); for service in [NativeService::WindowsHelper, NativeService::WindowsAgent] { let effect = if guard.participant == Participant::RestoredHelper { NativeEffect::RollbackStartService { service } } else { NativeEffect::StartService { service } }; let reserved = core::read_native_claim(ctx.db, &guard, request.grant_id, &effect)?; let proof = guard .running .try_borrow()? .proofs() .into_iter() .find(|p| { p.configuration.service.handoff_service() == match service { NativeService::WindowsHelper => { rmm_updater_handoff::Service::WindowsHelper } NativeService::WindowsAgent => { rmm_updater_handoff::Service::WindowsAgent } _ => unreachable!(), } }) .context("UPDATE_ACTUAL_START_PROOF_REQUIRED")?; core::observe_native_effect( ctx.db, &guard, &reserved, &hash(&serde_json::to_vec(&proof)?), ctx.clock.reading()?.upper, )?; } let event = journal.prepare( u64::try_from(ctx.clock.reading()?.upper.timestamp())?, if guard.participant == Participant::RestoredHelper { Evidence::RollbackServicesStarted { services: actual, ledger_identity_sha256: header.ledger_identity_sha256.clone(), observation_sha256: digest, } } else { Evidence::ServicesStarted { services: actual, ledger_identity_sha256: header.ledger_identity_sha256.clone(), observation_sha256: digest, } }, )?; core::append( ctx.db, &guard, request.grant_id, journal.head_sha256(), &event, )?; } NativeControlOperation::Health { receipt } => { guard.verify_health(ctx.db, receipt)?; let journal = core::read(ctx.db, &guard, request.grant_id)?; let event = journal.prepare( u64::try_from(ctx.clock.reading()?.upper.timestamp())?, if guard.participant == Participant::RestoredHelper { Evidence::RollbackHealthVerified { receipt: receipt.clone(), } } else { Evidence::HealthVerified { receipt: receipt.clone(), } }, )?; core::append( ctx.db, &guard, request.grant_id, journal.head_sha256(), &event, )?; } NativeControlOperation::Finalize => { original_outcome_base64url = Some(URL_SAFE_NO_PAD.encode(guard.finalize(ctx.db)?)); } } let proof = if original_outcome_base64url.is_none() { Some( core::current_proof(ctx.db, &guard, request.grant_id)? .context("UPDATE_ACTIVE_PROOF_REQUIRED")?, ) } else { None }; let pre_stop = if matches!(request.method, NativeControlOperation::ReadOriginal) { pre_stop_snapshot( ctx.db, &guard, proof.as_ref().context("UPDATE_ACTIVE_PROOF_REQUIRED")?, )? } else { None }; let (pre_stop_sync_request_base64url, pre_stop_sync_response_base64url) = match pre_stop { Some((request, response)) => ( Some(URL_SAFE_NO_PAD.encode(request)), Some(URL_SAFE_NO_PAD.encode(response)), ), None => (None, None), }; Ok(NativeControlReply { schema_version: 1, challenge: request.challenge, tenant_id: ctx.binding.tenant_id, asset_id: ctx.binding.asset_id, agent_id: ctx.binding.agent_id, enrollment_generation: ctx.binding.enrollment_generation, assignment_version: ctx.binding.assignment_version, grant_id: request.grant_id, owner_nonce: request.owner_nonce, handoff_sha256: request.handoff_sha256.clone(), ready: false, proof, claim, original_start_base64url, original_outcome_base64url, pre_stop_sync_request_base64url, pre_stop_sync_response_base64url, }) } fn verify_inventory( retained: &RetainedSet, original: &Original, receipt: &rmm_updater_handoff::HealthReceipt, ) -> Result<()> { use crate::update_state::Retention; use prost::Message; use rusqlite::OpenFlags; const PATH: &str = r"C:\ProgramData\RustDiscovery\state\telemetry.sqlite"; ensure!( retained .proofs() .iter() .any(|s| s.spec.path == Path::new(PATH) && s.spec.retention == Retention::MutableDatabase), "UPDATE_RETAINED_AGENT_JOURNAL_REQUIRED" ); retained.verify()?; let journal_pin = crate::update_state::AgentStateFile::journal()?; let db = Connection::open_with_flags( PATH, OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_NO_MUTEX, )?; db.busy_timeout(Duration::ZERO)?; // This journal belongs to the unprivileged agent. Bound SQLite's own // materialization before querying; a hostile oversized BLOB/view cannot // turn a root health check into an unbounded allocation or schema program. unsafe { rusqlite::ffi::sqlite3_limit( db.handle(), rusqlite::ffi::SQLITE_LIMIT_LENGTH, (rmm_domain::MAX_MESSAGE + 65536) as i32, ); } db.execute_batch("PRAGMA trusted_schema=OFF;PRAGMA query_only=ON;")?; let tx = db.unchecked_transaction()?; let kind: String = tx.query_row( "SELECT type FROM sqlite_master WHERE name='update_health_inventory'", [], |r| r.get(0), )?; ensure!(kind == "table", "UPDATE_AGENT_RETENTION_MUST_BE_TABLE"); let length: u64 = tx.query_row( "SELECT length(envelope) FROM update_health_inventory WHERE grant_id=?1 AND message_id=?2", rusqlite::params![ original.permit().grant_id.to_string(), receipt.inventory_message_id.to_string() ], |r| r.get(0), )?; ensure!( length > 0 && length <= rmm_domain::MAX_MESSAGE as u64, "UPDATE_LOCAL_INVENTORY_RAW_LIMIT" ); journal_pin.check()?; let envelope = rmm_agent_core::update_health_inventory::read( &tx, original.permit().grant_id, receipt.inventory_message_id, )?; let marker:(String,String)=tx.query_row("SELECT signed_decision_id,signed_response_sha256 FROM update_health_inventory WHERE grant_id=?1 AND message_id=?2",rusqlite::params![original.permit().grant_id.to_string(),receipt.inventory_message_id.to_string()],|r|Ok((r.get(0)?,r.get(1)?)))?; ensure!( marker == ( receipt.signed_sync_decision_id.to_string(), receipt.signed_sync_response_sha256.clone() ) && envelope.agent_id == original.handoff().attempt.agent_id.to_string() && envelope.boot_id == original.handoff().boot_id.to_string() && envelope.enrollment_generation == original.handoff().attempt.enrollment_generation && envelope.connection_generation == receipt.connection_generation, "UPDATE_LOCAL_INVENTORY_ORIGINAL_BINDING" ); let Some(rmm_protocol::Payload::InventorySnapshot(snapshot)) = &envelope.payload else { anyhow::bail!("UPDATE_LOCAL_BASE_INVENTORY_REQUIRED") }; ensure!( snapshot.scope == "windows.base" && !snapshot.data.is_empty() && snapshot.sha256 == hex::decode(hash(&snapshot.data))? && envelope.encode_to_vec().len() <= rmm_domain::MAX_MESSAGE, "UPDATE_LOCAL_BASE_INVENTORY_HASH" ); rmm_domain::inventory_document::validate_for_scope( &snapshot.data, chrono::Utc::now(), "windows.base", ) .map_err(anyhow::Error::msg)?; tx.commit()?; journal_pin.check()?; retained.verify() } /// Read-only selection of the one active ORIGINAL; never creates an attempt. pub(crate) fn active_grant(db: &Connection) -> Result> { let exists:bool=db.query_row("SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type='table' AND name='agent_update_handoffs')",[],|r|r.get(0))?; if !exists { return Ok(None); } let mut query=db.prepare("SELECT grant_id FROM agent_update_handoffs WHERE phase NOT IN ('unknown','outcome_persisted') ORDER BY grant_id LIMIT 2")?; let rows = query .query_map([], |r| r.get::<_, String>(0))? .collect::>>()?; ensure!(rows.len() <= 1, "UPDATE_MULTIPLE_ORIGINAL_HANDOFFS"); rows.first() .map(|id| Uuid::parse_str(id).map_err(Into::into)) .transpose() } pub(crate) fn server_pin( binding: &Binding, helper: &crate::helper_ipc::PeerPin, ) -> Result> { if !crate::update_admission::configured(binding) { return Ok(None); } let (file, raw) = crate::update_trust::Protected::read( Path::new(r"C:\ProgramData\RustDiscoveryUpdater\policy.json"), 65536, )?; let (policy, policy_sha256) = rmm_domain::agent_update_provisioning::LocalUpdatePolicy::from_bytes(&raw) .map_err(anyhow::Error::msg)?; ensure!( policy.schema_version == 2 && policy.tenant_id == binding.tenant_id && policy.asset_id == binding.asset_id && policy.agent_id == binding.agent_id && policy.enrollment_generation == binding.enrollment_generation && policy.assignment_version == binding.assignment_version, "UPDATE_CONTROL_PROTECTED_POLICY_BINDING" ); let pin = update_ipc::Pin { schema_version: 1, binding: binding.clone(), policy_sha256, helper: helper.clone(), updater: crate::update_native::services::updater_pin(&policy)?, }; file.verify()?; pin.validate()?; Ok(Some(pin)) } fn pre_stop_snapshot( db: &Connection, guard: &Guard<'_, '_>, proof: &rmm_domain::agent_update::UpdateInflightProof, ) -> Result, Vec)>> { use prost::Message; let (_, journal) = rmm_domain::agent_update::verify_inflight_proof(proof, guard.trust.health_public_key()) .map_err(anyhow::Error::msg)?; if journal.phase() != Phase::StopIntent { return Ok(None); } let latest: Option = db.query_row( "SELECT last_decision FROM helper_sync_meta WHERE id=1 AND fault IS NULL", [], |r| r.get(0), )?; let Some(id) = latest else { return Ok(None) }; let applied:bool=db.query_row("SELECT EXISTS(SELECT 1 FROM agent_update_sync_applied WHERE grant_id=?1 AND decision_id=?2)", rusqlite::params![guard.original.permit().grant_id.to_string(),id],|r|r.get(0))?; if !applied { return Ok(None); } let round = rmm_agent_core::update_health_sync::read_round( db, guard.ledger, guard.binding, guard.original.permit().grant_id, id.parse()?, )?; let (request_len, response_len): (usize, usize) = db.query_row( "SELECT length(request),length(response) FROM helper_sync_decisions WHERE decision_id=?1", [&id], |r| Ok((r.get(0)?, r.get(1)?)), )?; ensure!( request_len <= 512 * 1024 && response_len <= 512 * 1024, "UPDATE_PRE_STOP_SYNC_LIMIT" ); let (request, response): (Vec, Vec) = db.query_row( "SELECT request,response FROM helper_sync_decisions WHERE decision_id=?1", [&id], |r| Ok((r.get(0)?, r.get(1)?)), )?; let decoded = rmm_protocol::SyncRequest::decode(request.as_slice())?; if decoded.previous_decision_id.is_empty() || decoded.previous_decision_id != decoded.helper_previous_decision_id { return Ok(None); } let previous: Uuid = decoded.previous_decision_id.parse()?; let prior_applied:bool=db.query_row("SELECT EXISTS(SELECT 1 FROM agent_update_sync_applied WHERE grant_id=?1 AND decision_id=?2)", rusqlite::params![guard.original.permit().grant_id.to_string(),previous.to_string()],|r|r.get(0))?; if !prior_applied { return Ok(None); } let prior = rmm_agent_core::update_health_sync::read_round( db, guard.ledger, guard.binding, guard.original.permit().grant_id, previous, )?; let expected = rmm_domain::agent_update::inflight_decision(proof, guard.trust.health_public_key()) .map_err(anyhow::Error::msg)?; for decision in [round.decision(), prior.decision()] { ensure!( decision .attempts .iter() .any(|a| a.job_id == guard.original.permit().job_id && a.attempt_id == guard.original.permit().attempt_id && a.update_inflight.as_ref() == Some(&expected) && !a.unlock), "UPDATE_PRE_STOP_ORIGINAL_ACK_REQUIRED" ); } let proof_bytes = proof.bytes().map_err(anyhow::Error::msg)?; ensure!( decoded .attempts .iter() .any(|a| a.job_id == guard.original.permit().job_id.to_string() && a.attempt_id == guard.original.permit().attempt_id.to_string() && a.update_handoff_bytes == proof_bytes), "UPDATE_PRE_STOP_ORIGINAL_REQUEST_REQUIRED" ); guard.check(db)?; Ok(Some((request, response))) } impl Guard<'_, '_> { fn finalize(&self, db: &mut Connection) -> Result> { self.effects(db)?; let grant = self.original.permit().grant_id; let journal = core::read(db, self, grant)?; let raw:Vec=db.query_row("SELECT event FROM agent_update_handoff_events WHERE grant_id=?1 ORDER BY sequence DESC LIMIT 1", [grant.to_string()],|r|r.get(0))?; ensure!( hash(&raw) == journal.head_sha256(), "UPDATE_STORED_HEALTH_HEAD_CHANGED" ); let event: Event = serde_json::from_slice(&raw)?; let signed = match &event.evidence { Evidence::HealthVerified { receipt } if self.participant == Participant::NewHelper => { receipt } Evidence::RollbackHealthVerified { receipt } if self.participant == Participant::RestoredHelper => { receipt } _ => anyhow::bail!("UPDATE_ORIGINAL_STORED_HEALTH_REQUIRED"), }; self.verify_health(db, signed)?; let health_sha256 = hash(&serde_json::to_vec(signed)?); if self.participant == Participant::RestoredHelper { self.trust.recheck_protected()?; let outcome = rmm_agent_core::auth::Outcome { state: "failed".into(), stdout: vec![], stderr: vec![], exit_code: None, output_truncated: false, reboot_required: false, error_code: "AGENT_UPDATE_RETURNED_TO_PREDECESSOR".into(), evidence: serde_json::json!({"postconditions_passed":false,"previous_boot_id":self.original.handoff().boot_id, "agent_update":{"schema_version":2,"handoff_sha256":journal.handoff_sha256(), "manifest_sha256":self.original.handoff().target.manifest_sha256, "predecessor_record_sha256":self.original.handoff().predecessor_record_sha256, "installed_record_sha256":self.original.handoff().predecessor_record_sha256, "signed_health_sha256":health_sha256,"rolled_back":true}}), }; core::finalize_rollback( db, self, self.original.permit(), journal.head_sha256(), u64::try_from(self.clock.reading()?.upper.timestamp())?, &outcome, )?; } else { let built = crate::update_record::BuiltRecord::build( &self.original, self.trust.installed_raw(), &journal, &raw, )?; let namespace = crate::update_record::Transition::prepare(built)?; ensure!( self.publication .try_borrow_mut()? .replace(namespace) .is_none(), "UPDATE_RECORD_NO_RESUME" ); for index in 0..2 { let effect = self .publication .try_borrow()? .as_ref() .context("UPDATE_RECORD_NAMESPACE_REQUIRED")? .effect()?; let claim = core::claim_native_effect( db, self, grant, journal.head_sha256(), &effect, self.clock.reading()?.upper, )?; if index == 0 { let new_sha256 = self .publication .try_borrow()? .as_ref() .context("UPDATE_RECORD_NAMESPACE_REQUIRED")? .built() .sha256() .to_owned(); self.trust.release_installed_pin(&claim, &new_sha256)?; } self.publication .try_borrow_mut()? .as_mut() .context("UPDATE_RECORD_NAMESPACE_REQUIRED")? .apply(&claim)?; let observation = self .publication .try_borrow()? .as_ref() .context("UPDATE_RECORD_NAMESPACE_REQUIRED")? .observation()?; core::observe_native_effect( db, self, &claim, &observation, self.clock.reading()?.upper, )?; } let (record_sha256, floor) = { let namespace = self.publication.try_borrow()?; let namespace = namespace .as_ref() .context("UPDATE_RECORD_NAMESPACE_REQUIRED")?; namespace.published()?; ( namespace.built().sha256().to_owned(), namespace.built().record().activation_floor, ) }; let outcome = rmm_agent_core::auth::Outcome { state: "succeeded".into(), stdout: vec![], stderr: vec![], exit_code: Some(0), output_truncated: false, reboot_required: false, error_code: String::new(), evidence: serde_json::json!({"postconditions_passed":true,"previous_boot_id":self.original.handoff().boot_id, "agent_update":{"schema_version":2,"handoff_sha256":journal.handoff_sha256(), "manifest_sha256":self.original.handoff().target.manifest_sha256, "predecessor_record_sha256":self.original.handoff().predecessor_record_sha256, "installed_record_sha256":record_sha256,"signed_health_sha256":health_sha256,"activation_floor":floor,"rolled_back":false}}), }; core::finalize( db, self, self.original.permit(), journal.head_sha256(), u64::try_from(self.clock.reading()?.upper.timestamp())?, &outcome, )?; } db.query_row( "SELECT outcome FROM execution_evidence WHERE grant_id=?1", [grant.to_string()], |r| r.get(0), ) .map_err(Into::into) } } /// This guard can persist uncertainty only. It cannot qualify native effects, /// success, health, lease, rollback or a replacement original. struct UnknownGuard<'a> { ledger: &'a LedgerGuard, original: Original, helper: RefCell, sqlite: usize, } impl ExecutorLedgerGuard for UnknownGuard<'_> { fn check(&self, db: &Connection) -> Result<()> { self.ledger.check(db)?; self.helper.try_borrow_mut()?.check()?; ensure!( unsafe { db.handle() } as usize == self.sqlite && self.ledger.update_identity(db)?.sha256()? == self.original.handoff().ledger_identity_sha256, "UPDATE_UNKNOWN_ORIGINAL_LEDGER_REQUIRED" ); let (record,start):(Vec,Vec)=db.query_row( "SELECT h.record,e.start FROM agent_update_handoffs h JOIN execution_evidence e USING(grant_id) WHERE h.grant_id=?1", [self.original.permit().grant_id.to_string()],|r|Ok((r.get(0)?,r.get(1)?)))?; ensure!( record == self.original.handoff().bytes()? && start == self.original.start_bytes(), "UPDATE_UNKNOWN_ORIGINAL_CHANGED" ); Ok(()) } } impl UpdateParticipantGuard for UnknownGuard<'_> { fn participant(&self) -> Participant { Participant::Observer } fn verify_update_event(&self, h: &Handoff, d: &UpdateDelegation, event: &Event) -> Result<()> { ensure!( matches!(event.evidence, Evidence::Unknown { .. }) && h.bytes()? == self.original.handoff().bytes()? && d == self.original.delegation() && crate::update_state::Uncertain::read(h, d)?, "UPDATE_UNKNOWN_ONLY_ORIGINAL_REPORT" ); self.helper.try_borrow_mut()?.check() } } pub(crate) fn observe_worker_unknown(ctx: UpdateContext<'_>) -> Result { let Some(grant) = active_grant(ctx.db)? else { return Ok(false); }; ctx.guard.check(ctx.db)?; let (record,start):(Vec,Vec)=ctx.db.query_row( "SELECT h.record,e.start FROM agent_update_handoffs h JOIN execution_evidence e USING(grant_id) WHERE h.grant_id=?1", [grant.to_string()],|r|Ok((r.get(0)?,r.get(1)?)))?; let delegation = core::read_delegation(ctx.db, grant)?; let header: Handoff = serde_json::from_slice(&record)?; if !crate::update_state::Uncertain::read(&header, &delegation)? { return Ok(false); } let original = Original::verify_retained(ctx.binding, &start, &record, delegation)?; let helper = PeerProof::for_service(&ctx.pin.helper, std::process::id())?; ensure!( helper.identity().image_sha256 == header.predecessor.helper_sha256 || helper.identity().image_sha256 == header.target.helper_sha256, "UPDATE_UNKNOWN_QUALIFIED_HELPER_IMAGE_REQUIRED" ); let guard = UnknownGuard { ledger: ctx.guard, original, helper: RefCell::new(helper), sqlite: unsafe { ctx.db.handle() } as usize, }; let journal = core::read(ctx.db, &guard, grant)?; // Never rewrite a known outcome, including a successful Finalize whose // receipt the worker could not observe. Already persisted bytes win. let outcome: Option> = ctx.db.query_row( "SELECT outcome FROM execution_evidence WHERE grant_id=?1", [grant.to_string()], |r| r.get(0), )?; if outcome.is_some() { return Ok(false); } let observed = ctx .clock .reading() .map(|r| r.upper) .unwrap_or_else(|_| chrono::Utc::now()); // When time is unqualified this is only an observed wall timestamp on an // Unknown event, never time evidence or permission. Kernel chronology must // still accept it; no invented/backdated maximum or new deadline is used. core::mark_unknown( ctx.db, &guard, guard.original.permit(), journal.head_sha256(), u64::try_from(observed.timestamp())?, rmm_updater_handoff::UnknownReason::StateChanged, )?; if let Some(sync) = ctx.sync { sync.close(); } Ok(true) }