Files
rust-discovery/crates/privileged-helper/src/update_control.rs
T
2026-11-16 15:25:46 +01:00

225 lines
9.0 KiB
Rust

//! 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, NativeEffectStage, NativeService, UpdateParticipantGuard,
},
};
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<Option<Uuid>> {
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','rollback_outcome_persisted') ORDER BY grant_id LIMIT 2")?;
let rows = query
.query_map([], |r| r.get::<_, String>(0))?
.collect::<rusqlite::Result<Vec<_>>>()?;
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<NativeControlReply> {
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!(
matches!(
journal.phase(),
Phase::LedgerReturnIntent | Phase::RollbackLedgerReturnIntent
),
"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 = if guard.restored() {
NativeEffect::RollbackStartService { service }
} else {
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())?,
if guard.restored() {
Evidence::RollbackServicesStarted {
services: actual,
ledger_identity_sha256: header.ledger_identity_sha256.clone(),
observation_sha256: actual_hash,
}
} else {
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)?;
if header.schema_version == 2 && !guard.restored() {
let observation = guard.native_observation_sha256(
&header,
guard.original().delegation(),
&NativeEffect::ConditionalRollbackStopGeneral,
NativeEffectStage::ObserveNonstart,
)?;
core::deny_conditional_stop(
db,
&guard,
request.grant_id,
&observation,
clock.now()?,
)?;
}
}
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())?,
if guard.restored() {
Evidence::RollbackHealthVerified {
receipt: receipt.clone(),
}
} else {
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(if guard.restored() {
guard.finalize_restored(db)?
} else {
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")?,
)
};
let pre_stop = if matches!(request.method, NativeControlOperation::ReadOriginal) {
guard.pre_stop_signed_sync(db)?
} 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: 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,
pre_stop_sync_request_base64url,
pre_stop_sync_response_base64url,
})
}