//! Closed control of the one ORIGINAL Full-authorized update. Caller data never //! authorizes an event: actual process/file/ledger observations are independent. use crate::{Binding, reconcile::ExecutorGuard, update_guard::FullUpdateGuard}; use anyhow::{Context, Result, ensure}; use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD}; use rmm_agent_core::{ reconcile::SyncClock, update_handoff::{ self as core, NativeControlOperation, NativeControlReply, NativeControlRequest, NativeEffect, NativeService, }, }; use rmm_updater_handoff::{Evidence, Phase}; use rmm_updater_worker::clock::NativeClock; use rusqlite::Connection; use std::os::unix::net::UnixStream; use uuid::Uuid; pub 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 fn handle( db: &mut Connection, executor: &ExecutorGuard, binding: &Binding, clock: &NativeClock, stream: &UnixStream, request: &NativeControlRequest, ) -> Result { ensure!( request.operation == "agent_update_control_v1" && request.schema_version == 1 && !request.challenge.is_nil() && request.tenant_id == binding.tenant_id && request.asset_id == binding.asset_id && request.agent_id == binding.agent_id && request.enrollment_generation == binding.enrollment_generation && request.assignment_version == binding.assignment_version, "UPDATE_CONTROL_BINDING" ); let mut guard = FullUpdateGuard::open(db, executor, binding, clock, request.grant_id)?; let header = guard.original().handoff().clone(); ensure!( header.owner_nonce == request.owner_nonce && rmm_domain::jobs::hash(&header.bytes()?) == request.handoff_sha256, "UPDATE_CONTROL_ORIGINAL_REQUIRED" ); if !matches!(request.method, NativeControlOperation::ReadOriginal) { guard.qualify_effects(db)?; } if matches!(request.method, NativeControlOperation::Health { .. }) { guard.verify_health_peer(stream)?; } else { guard.verify_updater_peer(stream)?; } let mut original_start_base64url = None; let mut claim = None; let mut original_outcome_base64url = 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( db, &guard, request.grant_id, expected_head_sha256, &NativeEffect::StopService { service: *service }, clock.now()?, )?); } NativeControlOperation::ObserveStarts { services, observation_sha256, } => { let journal = core::read(db, &guard, request.grant_id)?; ensure!( journal.phase() == Phase::LedgerReturnIntent, "UPDATE_START_ALREADY_OBSERVED_OR_PHASE" ); let (actual, actual_hash) = guard.started()?; ensure!( services == &actual && observation_sha256 == &actual_hash, "UPDATE_START_WORKER_WITNESS_CHANGED" ); for service in [ NativeService::General, NativeService::Full, NativeService::Agent, ] { let effect = NativeEffect::StartService { service }; let reserved = core::read_native_claim(db, &guard, request.grant_id, &effect)?; let already:bool=db.query_row("SELECT EXISTS(SELECT 1 FROM agent_update_native_observations WHERE grant_id=?1 AND claim_sha256=?2)",rusqlite::params![request.grant_id.to_string(),rmm_domain::jobs::hash(&serde_json::to_vec(&reserved)?)],|r|r.get(0))?; // One control request performs one sequence, never retries an // uncertain partially committed start-observation transaction. ensure!(!already, "UPDATE_START_OBSERVATION_ALREADY_COMMITTED"); core::observe_native_effect( db, &guard, &reserved, &guard.service_observation_sha256(service)?, clock.now()?, )?; } let event = journal.prepare( u64::try_from(clock.now()?.timestamp())?, Evidence::ServicesStarted { services: actual, ledger_identity_sha256: header.ledger_identity_sha256.clone(), observation_sha256: actual_hash, }, )?; core::append(db, &guard, request.grant_id, journal.head_sha256(), &event)?; } NativeControlOperation::Health { receipt } => { guard.qualify_health(db, receipt)?; let journal = core::read(db, &guard, request.grant_id)?; let event = journal.prepare( u64::try_from(clock.now()?.timestamp())?, Evidence::HealthVerified { receipt: receipt.clone(), }, )?; core::append(db, &guard, request.grant_id, journal.head_sha256(), &event)?; } NativeControlOperation::Finalize => { original_outcome_base64url = Some(URL_SAFE_NO_PAD.encode(guard.publish_record_and_finalize(db)?)); } } let proof = if original_outcome_base64url.is_some() { None } else { Some( core::current_proof(db, &guard, request.grant_id)? .context("UPDATE_ACTIVE_PROOF_REQUIRED")?, ) }; Ok(NativeControlReply { schema_version: 1, challenge: request.challenge, tenant_id: binding.tenant_id, asset_id: binding.asset_id, agent_id: binding.agent_id, enrollment_generation: binding.enrollment_generation, assignment_version: 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, }) }