800 lines
31 KiB
Rust
800 lines
31 KiB
Rust
//! Stable, separately provisioned SCM updater. Activation is one live pass:
|
|
//! only a successfully drained reply releases the queued original; no startup
|
|
//! scan resumes effects, and a duplicate activation is always denied.
|
|
use crate::{
|
|
helper_ipc::{self as ipc, PeerProof},
|
|
helper_system::{self, WindowsBoot},
|
|
signed_clock::{BoundClock, RuntimeClock, UpdaterConfiguration},
|
|
update_ipc::{self, Pin, Request, Response, State},
|
|
update_native::{
|
|
self as native, Budget, control_fence,
|
|
files::{BoundStage, Staged},
|
|
services,
|
|
},
|
|
update_original::Original,
|
|
update_owned,
|
|
update_state::{Bundle, QualifiedRegistry, RetainedSet},
|
|
update_time_transport::Transport,
|
|
update_trust::{Protected, TrustState},
|
|
};
|
|
use anyhow::{Context, Result, ensure};
|
|
use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
|
|
use rmm_agent_core::{
|
|
auth::Binding,
|
|
helper_reconcile::BootSource,
|
|
reconcile::SyncClock,
|
|
update_handoff::{
|
|
NativeControlOperation, NativeControlReply, NativeControlRequest, NativeService,
|
|
},
|
|
};
|
|
use rmm_domain::{
|
|
agent_update::{ParticipantIdentity, ParticipantRole, verify_inflight_proof},
|
|
jobs::hash,
|
|
};
|
|
use rmm_updater_handoff::Phase;
|
|
use std::{
|
|
cell::RefCell,
|
|
collections::BTreeMap,
|
|
path::Path,
|
|
sync::{
|
|
Arc,
|
|
atomic::{AtomicBool, AtomicU64, Ordering},
|
|
},
|
|
time::Duration,
|
|
};
|
|
use uuid::Uuid;
|
|
struct Worker {
|
|
binding: Binding,
|
|
policy: rmm_domain::agent_update_provisioning::LocalUpdatePolicy,
|
|
policy_file: Protected,
|
|
profile_file: Protected,
|
|
pin: Pin,
|
|
own: RefCell<PeerProof>,
|
|
identity: ParticipantIdentity,
|
|
clock: RuntimeClock,
|
|
generation: Arc<AtomicU64>,
|
|
pending: Option<Uuid>,
|
|
current: Option<Uuid>,
|
|
seen: BTreeMap<Uuid, (Uuid, String)>,
|
|
state: State,
|
|
}
|
|
impl Worker {
|
|
fn open(clock: RuntimeClock, generation: Arc<AtomicU64>) -> Result<Self> {
|
|
let (policy_file, raw) = 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)?;
|
|
let (profile_file, raw) =
|
|
Protected::read(Path::new(crate::signed_clock::UPDATER_CONFIG_PATH), 16384)?;
|
|
let profile: UpdaterConfiguration = serde_json::from_slice(&raw)?;
|
|
ensure!(
|
|
policy.schema_version == 2
|
|
&& profile.schema_version == 3
|
|
&& profile.updater_policy_sha256 == policy_sha256
|
|
&& policy.tenant_id == profile.binding.tenant_id
|
|
&& policy.asset_id == profile.binding.asset_id
|
|
&& policy.agent_id == profile.binding.agent_id
|
|
&& policy.enrollment_generation == profile.binding.enrollment_generation
|
|
&& policy.assignment_version == profile.binding.assignment_version,
|
|
"UPDATE_WORKER_PROTECTED_BINDING"
|
|
);
|
|
let boot = WindowsBoot::capture()?;
|
|
let budget = Budget::new(&boot, boot.current_boot()?, Duration::from_secs(5))?;
|
|
let (own, identity) = services::observe_updater(&policy, &budget)?;
|
|
let (settings, _) = helper_system::read_settings()?;
|
|
ensure!(
|
|
serde_json::to_vec(&settings.binding)? == serde_json::to_vec(&profile.binding)?,
|
|
"UPDATE_WORKER_HELPER_BINDING"
|
|
);
|
|
let pin = Pin {
|
|
schema_version: 1,
|
|
binding: profile.binding.clone(),
|
|
policy_sha256,
|
|
helper: settings.helper,
|
|
updater: services::updater_pin(&policy)?,
|
|
};
|
|
pin.validate()?;
|
|
Ok(Self {
|
|
binding: profile.binding,
|
|
policy,
|
|
policy_file,
|
|
profile_file,
|
|
pin,
|
|
own: RefCell::new(own),
|
|
identity,
|
|
clock,
|
|
generation,
|
|
pending: None,
|
|
current: None,
|
|
seen: BTreeMap::new(),
|
|
state: State::NotConfigured,
|
|
})
|
|
}
|
|
fn check(&self) -> Result<()> {
|
|
self.policy_file.verify()?;
|
|
self.profile_file.verify()?;
|
|
let mut own = self.own.try_borrow_mut()?;
|
|
own.check()?;
|
|
ensure!(
|
|
update_ipc::participant(&own, ParticipantRole::WindowsUpdater)? == self.identity
|
|
&& services::updater_configuration_sha256(&self.pin.updater)?
|
|
== self.policy.updater_service.unit_sha256,
|
|
"UPDATE_WORKER_OWN_INSTANCE_CHANGED"
|
|
);
|
|
Ok(())
|
|
}
|
|
fn bound_clock(&self) -> BoundClock {
|
|
self.clock
|
|
.for_generation(self.generation.load(Ordering::SeqCst))
|
|
}
|
|
fn request(
|
|
&self,
|
|
h: &rmm_updater_handoff::Handoff,
|
|
method: NativeControlOperation,
|
|
) -> Result<NativeControlReply> {
|
|
self.check()?;
|
|
let r = NativeControlRequest {
|
|
operation: "agent_update_control_v1".into(),
|
|
schema_version: 1,
|
|
challenge: Uuid::new_v4(),
|
|
tenant_id: self.binding.tenant_id,
|
|
asset_id: self.binding.asset_id,
|
|
agent_id: self.binding.agent_id,
|
|
enrollment_generation: self.binding.enrollment_generation,
|
|
assignment_version: self.binding.assignment_version,
|
|
grant_id: h.attempt.grant_id,
|
|
owner_nonce: h.owner_nonce,
|
|
handoff_sha256: hash(&h.bytes()?),
|
|
method,
|
|
};
|
|
crate::update_control_ipc::exchange(&self.pin, &r)
|
|
}
|
|
fn drive(&mut self, grant: Uuid) -> Result<()> {
|
|
self.check()?;
|
|
let (bundle, bundle_recheck) = Bundle::load(grant)?;
|
|
let h = bundle.validate()?;
|
|
ensure!(
|
|
h.schema_version == 2 && bundle.delegation.updater == self.identity,
|
|
"UPDATE_WORKER_ORIGINAL_OWNER_REQUIRED"
|
|
);
|
|
let mut reply = self.request(&h, NativeControlOperation::ReadOriginal)?;
|
|
let start = URL_SAFE_NO_PAD.decode(
|
|
reply
|
|
.original_start_base64url
|
|
.as_ref()
|
|
.context("UPDATE_ORIGINAL_START_REQUIRED")?,
|
|
)?;
|
|
let boot = WindowsBoot::capture()?;
|
|
let budget = Budget::new(&boot, h.boot_id, Duration::from_secs(600))?;
|
|
let clock = self.bound_clock();
|
|
clock.require_generation(h.connection_generation)?;
|
|
let original = Original::verify(
|
|
&self.binding,
|
|
&start,
|
|
&bundle.handoff_record,
|
|
bundle.delegation.clone(),
|
|
&clock,
|
|
&budget,
|
|
)?;
|
|
let trust = TrustState::load_prepared(original.update(), &self.binding, &clock)?;
|
|
let retained = RetainedSet::reopen(&bundle.retained)?;
|
|
let registry = QualifiedRegistry::load(&trust)?;
|
|
let (settings, _) = helper_system::read_settings()?;
|
|
let mut running =
|
|
services::Running::observe([settings.agent.clone(), settings.helper.clone()], &budget)?;
|
|
registry.verify_observed(
|
|
&running.proofs(),
|
|
&services::updater_configuration_sha256(&self.pin.updater)?,
|
|
)?;
|
|
running.check(&budget)?;
|
|
while !pre_stop_context(&self.binding, &original, &trust, &clock, &reply)? {
|
|
original.check_current(&self.binding, &clock, &budget)?;
|
|
std::thread::sleep(Duration::from_millis(100));
|
|
reply = self.request(&h, NativeControlOperation::ReadOriginal)?;
|
|
}
|
|
let proof = reply
|
|
.proof
|
|
.as_ref()
|
|
.context("UPDATE_ORIGINAL_PREFIX_REQUIRED")?;
|
|
let (_, journal) =
|
|
verify_inflight_proof(proof, trust.health_public_key()).map_err(anyhow::Error::msg)?;
|
|
ensure!(
|
|
journal.phase() == Phase::StopIntent,
|
|
"UPDATE_NO_REENTER_OR_RESUME"
|
|
);
|
|
let mut claims = vec![];
|
|
for service in [NativeService::WindowsAgent, NativeService::WindowsHelper] {
|
|
claims.push(
|
|
self.request(
|
|
&h,
|
|
NativeControlOperation::ClaimStop {
|
|
expected_head_sha256: journal.head_sha256().into(),
|
|
service,
|
|
},
|
|
)?
|
|
.claim
|
|
.context("UPDATE_ORIGINAL_STOP_CLAIM_REQUIRED")?,
|
|
);
|
|
}
|
|
let context = || control_fence::Context {
|
|
original: &original,
|
|
binding: &self.binding,
|
|
clock: &clock,
|
|
budget: &budget,
|
|
updater: &self.own,
|
|
retained: &retained,
|
|
trust: &trust,
|
|
};
|
|
let proofs = running
|
|
.proofs()
|
|
.try_into()
|
|
.map_err(|_| anyhow::anyhow!("UPDATE_TWO_ORIGINAL_SERVICES_REQUIRED"))?;
|
|
let mut stop = control_fence::StopFence::new(
|
|
context(),
|
|
claims
|
|
.try_into()
|
|
.map_err(|_| anyhow::anyhow!("UPDATE_TWO_STOP_CLAIMS_REQUIRED"))?,
|
|
proofs,
|
|
proof,
|
|
)?;
|
|
let stopped = running.stop(&budget, &mut stop)?;
|
|
let observations = stop.finish(&stopped)?;
|
|
let closed = update_owned::ClosedFiles::acquire(&bundle, &stopped, &budget)?;
|
|
let mut ledger = update_owned::OwnedLedger::open(update_owned::Inputs {
|
|
closed: &closed,
|
|
stopped: &stopped,
|
|
bundle: &bundle,
|
|
bundle_recheck: &bundle_recheck,
|
|
original: &original,
|
|
binding: &self.binding,
|
|
clock: &clock,
|
|
budget: &budget,
|
|
updater: &self.own,
|
|
retained: &retained,
|
|
registry: ®istry,
|
|
trust: &trust,
|
|
})?;
|
|
ledger.record_stops(observations)?;
|
|
let originals = bundle
|
|
.files
|
|
.iter()
|
|
.map(|f| f.original.clone())
|
|
.collect::<Vec<_>>()
|
|
.try_into()
|
|
.map_err(|_| anyhow::anyhow!("UPDATE_FIVE_FILES_REQUIRED"))?;
|
|
let stages = bundle
|
|
.files
|
|
.iter()
|
|
.map(|f| f.staged.clone())
|
|
.collect::<Vec<_>>()
|
|
.try_into()
|
|
.map_err(|_| anyhow::anyhow!("UPDATE_FIVE_FILES_REQUIRED"))?;
|
|
let (db, guard) = ledger.parts();
|
|
let mut fence = native::fence::LedgerFence::new(native::fence::Inputs {
|
|
db,
|
|
guard,
|
|
clock: &clock,
|
|
budget: &budget,
|
|
original: &h,
|
|
originals: &originals,
|
|
staged: &stages,
|
|
})?;
|
|
let mut published = vec![];
|
|
for f in &bundle.files {
|
|
let stage = Staged::reopen_bound(
|
|
BoundStage {
|
|
role: f.role,
|
|
owner_nonce: h.owner_nonce,
|
|
original: &f.original,
|
|
staged: &f.staged,
|
|
},
|
|
&budget,
|
|
)?;
|
|
published.push(stage.publish(&stopped, &budget, &mut fence)?);
|
|
}
|
|
fence.finish()?;
|
|
for file in published {
|
|
file.release(&budget)?;
|
|
}
|
|
let prepared = ledger.prepare_return_and_close()?;
|
|
let released = closed.release(&bundle, &stopped, &budget)?;
|
|
let mut start_fence = prepared.bind(context(), released, &bundle)?;
|
|
let (settings, _) = helper_system::read_settings()?;
|
|
let result = stopped.start_observed(
|
|
[settings.agent, settings.helper.clone()],
|
|
&budget,
|
|
&mut start_fence,
|
|
)?;
|
|
let (mut started, rolled_back) = match result {
|
|
services::StartResult::Running(mut running) => {
|
|
start_fence.finish(&mut running)?;
|
|
(running, false)
|
|
}
|
|
services::StartResult::KnownFailure(failed) => {
|
|
// Only first-helper failure has no started candidate reader.
|
|
// Partial starts require separately authorized stops; this
|
|
// branch cannot infer those from a caller reason or timeout.
|
|
let stopped = start_fence.helper_failed(*failed)?;
|
|
let closed = update_owned::ClosedFiles::acquire(&bundle, &stopped, &budget)?;
|
|
let mut ledger = update_owned::OwnedLedger::open(update_owned::Inputs {
|
|
closed: &closed,
|
|
stopped: &stopped,
|
|
bundle: &bundle,
|
|
bundle_recheck: &bundle_recheck,
|
|
original: &original,
|
|
binding: &self.binding,
|
|
clock: &clock,
|
|
budget: &budget,
|
|
updater: &self.own,
|
|
retained: &retained,
|
|
registry: ®istry,
|
|
trust: &trust,
|
|
})?;
|
|
ledger.begin_failed_helper_rollback()?;
|
|
let (db, guard) = ledger.parts();
|
|
let mut fence = native::fence::RestoreFence::new(native::fence::Inputs {
|
|
db,
|
|
guard,
|
|
clock: &clock,
|
|
budget: &budget,
|
|
original: &h,
|
|
originals: &originals,
|
|
staged: &stages,
|
|
})?;
|
|
for f in bundle.files.iter().rev() {
|
|
native::files::Published::reopen_bound(
|
|
BoundStage {
|
|
role: f.role,
|
|
owner_nonce: h.owner_nonce,
|
|
original: &f.original,
|
|
staged: &f.staged,
|
|
},
|
|
&stopped,
|
|
&budget,
|
|
)?
|
|
.restore(&stopped, &budget, &mut fence)?;
|
|
}
|
|
fence.finish()?;
|
|
let prepared = ledger.prepare_rollback_return_and_close()?;
|
|
let released = closed.release(&bundle, &stopped, &budget)?;
|
|
let mut fence = prepared.bind(context(), released, &bundle)?;
|
|
let (settings, _) = helper_system::read_settings()?;
|
|
let result = stopped.start_observed(
|
|
[settings.agent, settings.helper],
|
|
&budget,
|
|
&mut fence,
|
|
)?;
|
|
let services::StartResult::Running(mut running) = result else {
|
|
anyhow::bail!("UPDATE_PREDECESSOR_START_FAILED_NO_SECOND_RETURN")
|
|
};
|
|
fence.finish(&mut running)?;
|
|
(running, true)
|
|
}
|
|
};
|
|
self.pin.helper = helper_system::read_settings()?.0.helper;
|
|
let health_key = trust.health_public_key();
|
|
let proof = started.proofs();
|
|
self.request(
|
|
&h,
|
|
NativeControlOperation::ObserveStarts {
|
|
services: proof.iter().map(|p| p.started()).collect(),
|
|
observation_sha256: hash(&serde_json::to_vec(&proof)?),
|
|
},
|
|
)?;
|
|
loop {
|
|
original.check_current(&self.binding, &clock, &budget)?;
|
|
started.check(&budget)?;
|
|
let reply = self.request(&h, NativeControlOperation::ReadOriginal)?;
|
|
let proof = reply.proof.context("UPDATE_ACTIVE_PREFIX_REQUIRED")?;
|
|
let (_, journal) =
|
|
verify_inflight_proof(&proof, health_key).map_err(anyhow::Error::msg)?;
|
|
if journal.phase()
|
|
== if rolled_back {
|
|
Phase::RollbackHealthVerified
|
|
} else {
|
|
Phase::HealthVerified
|
|
}
|
|
{
|
|
trust.recheck_prepared(original.update(), &clock)?;
|
|
let released = if rolled_back {
|
|
None
|
|
} else {
|
|
Some(trust.release_worker_record_pin_after_health(&h, &proof)?)
|
|
};
|
|
let reply = self.request(&h, NativeControlOperation::Finalize)?;
|
|
if rolled_back {
|
|
verify_rollback_outcome(&original, &trust, &proof, &reply)?;
|
|
trust.recheck_protected()?;
|
|
} else {
|
|
verify_final_record(&original, &trust, &proof, &reply)?;
|
|
released
|
|
.context("UPDATE_WORKER_READ_PIN_RELEASE_REQUIRED")?
|
|
.verify_archive()?;
|
|
trust.recheck_other_protected()?;
|
|
}
|
|
self.state = State::OutcomePersisted;
|
|
return Ok(());
|
|
}
|
|
ensure!(
|
|
journal.phase()
|
|
== if rolled_back {
|
|
Phase::RollbackServicesStarted
|
|
} else {
|
|
Phase::ServicesStarted
|
|
},
|
|
"UPDATE_UNEXPECTED_POST_START_PHASE"
|
|
);
|
|
std::thread::sleep(Duration::from_millis(100));
|
|
}
|
|
}
|
|
}
|
|
// This is evidence of one already applied original control context, not a new
|
|
// grant/approval/start window. Absent witness means bounded no-effect waiting.
|
|
fn pre_stop_context(
|
|
binding: &Binding,
|
|
original: &Original,
|
|
trust: &TrustState,
|
|
clock: &BoundClock,
|
|
reply: &NativeControlReply,
|
|
) -> Result<bool> {
|
|
use prost::Message;
|
|
let (Some(raw), Some(signed)) = (
|
|
&reply.pre_stop_sync_request_base64url,
|
|
&reply.pre_stop_sync_response_base64url,
|
|
) else {
|
|
return Ok(false);
|
|
};
|
|
let raw = URL_SAFE_NO_PAD.decode(raw)?;
|
|
let signed = URL_SAFE_NO_PAD.decode(signed)?;
|
|
ensure!(
|
|
raw.len() <= 512 * 1024 && signed.len() <= 512 * 1024,
|
|
"UPDATE_PRE_STOP_SYNC_LIMIT"
|
|
);
|
|
let request = rmm_protocol::SyncRequest::decode(raw.as_slice())?;
|
|
let signed: rmm_agent_core::helper_reconcile::SignedResponse = serde_json::from_slice(&signed)?;
|
|
let response = rmm_protocol::SyncResponse {
|
|
decision_bytes: signed.decision_bytes,
|
|
signature: signed.signature,
|
|
};
|
|
let decision: rmm_domain::reconciliation::ReconcileDecisionPayload =
|
|
serde_json::from_slice(&response.decision_bytes)?;
|
|
clock.require_generation(decision.connection_generation)?;
|
|
let (lower, upper) = clock.bounds()?;
|
|
ensure!(
|
|
request.encode_to_vec() == raw
|
|
&& decision.issued_at <= lower
|
|
&& upper < decision.valid_until
|
|
&& !request.previous_decision_id.is_empty()
|
|
&& request.previous_decision_id == request.helper_previous_decision_id,
|
|
"UPDATE_PRE_STOP_CURRENT_CONFIRMED_CONTEXT_REQUIRED"
|
|
);
|
|
let verified = rmm_agent_core::reconcile::verify_response(
|
|
binding,
|
|
&request,
|
|
&rmm_agent_core::reconcile::Channel {
|
|
connection_generation: decision.connection_generation,
|
|
boot_id: original.handoff().boot_id,
|
|
},
|
|
&response,
|
|
lower,
|
|
)?;
|
|
let proof = reply
|
|
.proof
|
|
.as_ref()
|
|
.context("UPDATE_PRE_STOP_PREFIX_REQUIRED")?;
|
|
let expected = rmm_domain::agent_update::inflight_decision(proof, trust.health_public_key())
|
|
.map_err(anyhow::Error::msg)?;
|
|
let (header, journal) =
|
|
verify_inflight_proof(proof, trust.health_public_key()).map_err(anyhow::Error::msg)?;
|
|
ensure!(
|
|
header.bytes()? == original.handoff().bytes()?
|
|
&& journal.phase() == Phase::StopIntent
|
|
&& verified
|
|
.attempts
|
|
.iter()
|
|
.any(|a| a.job_id == original.permit().job_id
|
|
&& a.attempt_id == original.permit().attempt_id
|
|
&& a.update_inflight.as_ref() == Some(&expected)
|
|
&& !a.unlock),
|
|
"UPDATE_PRE_STOP_EXACT_ORIGINAL_ACK_REQUIRED"
|
|
);
|
|
let proof_bytes = proof.bytes().map_err(anyhow::Error::msg)?;
|
|
ensure!(
|
|
request
|
|
.attempts
|
|
.iter()
|
|
.any(|a| a.job_id == original.permit().job_id.to_string()
|
|
&& a.attempt_id == original.permit().attempt_id.to_string()
|
|
&& a.update_handoff_bytes == proof_bytes),
|
|
"UPDATE_PRE_STOP_EXACT_ORIGINAL_REQUEST_REQUIRED"
|
|
);
|
|
Ok(true)
|
|
}
|
|
impl update_ipc::Engine for Worker {
|
|
fn handle(&mut self, peer: &ParticipantIdentity, request: Request) -> Result<Response> {
|
|
self.check()?;
|
|
match request {
|
|
Request::Describe {} => {
|
|
if self.pending.is_none()
|
|
&& self.state != State::Unknown
|
|
&& self.state != State::OutcomePersisted
|
|
{
|
|
self.state = if self.bound_clock().now().is_ok() {
|
|
State::Described
|
|
} else {
|
|
State::NotConfigured
|
|
};
|
|
}
|
|
}
|
|
Request::Activate {
|
|
grant_id,
|
|
owner_nonce,
|
|
handoff_sha256,
|
|
} => {
|
|
ensure!(
|
|
self.pending.is_none() && !self.seen.contains_key(&grant_id),
|
|
"UPDATE_ACTIVATION_NO_REPLAY"
|
|
);
|
|
let (bundle, recheck) = Bundle::load(grant_id)?;
|
|
let h = bundle.validate()?;
|
|
ensure!(
|
|
h.schema_version == 2
|
|
&& h.owner_nonce == owner_nonce
|
|
&& hash(&h.bytes()?) == handoff_sha256
|
|
&& bundle.delegation.original_helper == *peer
|
|
&& bundle.delegation.updater == self.identity,
|
|
"UPDATE_ACTIVATION_ORIGINAL_BINDING"
|
|
);
|
|
self.bound_clock()
|
|
.require_generation(h.connection_generation)?;
|
|
self.bound_clock().now()?;
|
|
recheck()?;
|
|
ensure!(
|
|
matches!(self.state, State::Described | State::OutcomePersisted)
|
|
&& self.seen.len() < 64,
|
|
"UPDATE_WORKER_NOT_AVAILABLE_FOR_NEW_ATTEMPT"
|
|
);
|
|
self.seen.insert(grant_id, (owner_nonce, handoff_sha256));
|
|
self.pending = Some(grant_id);
|
|
self.current = Some(grant_id);
|
|
self.state = State::Inflight;
|
|
}
|
|
Request::Read {
|
|
grant_id,
|
|
owner_nonce,
|
|
handoff_sha256,
|
|
} => ensure!(
|
|
self.current == Some(grant_id)
|
|
&& self.seen.get(&grant_id) == Some(&(owner_nonce, handoff_sha256)),
|
|
"UPDATE_NO_ACTIVE_ORIGINAL"
|
|
),
|
|
Request::Health { .. } => anyhow::bail!("UPDATE_AGENT_HEALTH_USES_SYSTEM_CONTROL"),
|
|
}
|
|
Ok(Response {
|
|
schema_version: 1,
|
|
state: self.state,
|
|
ready: false,
|
|
updater: self.identity.clone(),
|
|
head_sha256: None,
|
|
})
|
|
}
|
|
}
|
|
fn current_generation_hint() -> Result<u64> {
|
|
const LEDGER: &str = r"C:\ProgramData\RustDiscoverySystem\state\ledger.sqlite";
|
|
let file = ipc::PinnedFile::open(
|
|
Path::new(LEDGER),
|
|
false,
|
|
&[],
|
|
&[ipc::service_sid(ipc::HELPER_SERVICE)?],
|
|
true,
|
|
)?;
|
|
let db = rusqlite::Connection::open_with_flags(
|
|
LEDGER,
|
|
rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY | rusqlite::OpenFlags::SQLITE_OPEN_NO_MUTEX,
|
|
)?;
|
|
db.busy_timeout(Duration::ZERO)?;
|
|
db.execute_batch("PRAGMA query_only=ON;PRAGMA trusted_schema=OFF")?;
|
|
let generation: u64 = db.query_row(
|
|
"SELECT generation FROM helper_sync_meta WHERE id=1 AND fault IS NULL",
|
|
[],
|
|
|r| r.get(0),
|
|
)?;
|
|
ensure!(generation > 0, "UPDATE_TIME_GENERATION_HINT_MISSING");
|
|
db.close().map_err(|(_, error)| error)?;
|
|
ensure!(
|
|
ipc::file_identity(&file.file)? == file.identity,
|
|
"UPDATE_TIME_HINT_FILE_CHANGED"
|
|
);
|
|
// Hint only: independent server context/signature/nonce validates it.
|
|
Ok(generation)
|
|
}
|
|
pub fn dispatch() -> Result<()> {
|
|
crate::service::dispatch_named(update_ipc::SERVICE, run)
|
|
}
|
|
fn run(stop: &'static AtomicBool) -> Result<()> {
|
|
let runtime = tokio::runtime::Builder::new_multi_thread()
|
|
.worker_threads(2)
|
|
.enable_all()
|
|
.build()?;
|
|
let clock = RuntimeClock::new(rmm_time_attestation::Role::Updater);
|
|
let generation = Arc::new(AtomicU64::new(current_generation_hint()?));
|
|
let mut worker = Worker::open(clock.clone(), generation.clone())?;
|
|
let binding = worker.binding.clone();
|
|
let time_clock = clock.clone();
|
|
let time_generation = generation.clone();
|
|
let time_task = runtime.spawn(async move {
|
|
loop {
|
|
if stop.load(Ordering::SeqCst) {
|
|
break;
|
|
}
|
|
let generation = time_generation.load(Ordering::SeqCst);
|
|
let result = async {
|
|
if !time_clock.configured_for(generation) {
|
|
time_clock.open_connection(generation).await?;
|
|
}
|
|
let mut transport = Transport::open(&binding)?;
|
|
let request = time_clock.begin(generation)?;
|
|
let response = transport.compare(&request).await?;
|
|
time_clock.complete(generation, &response)
|
|
}
|
|
.await;
|
|
if result.is_err() {
|
|
let _ = time_clock.close_generation(generation);
|
|
}
|
|
tokio::time::sleep(Duration::from_millis(if result.is_ok() {
|
|
250
|
|
} else {
|
|
1000
|
|
}))
|
|
.await;
|
|
}
|
|
});
|
|
let mut server = update_ipc::Server::bind(worker.pin.clone())?;
|
|
while !stop.load(Ordering::SeqCst) {
|
|
let delivered = server.serve_one(&mut worker);
|
|
match delivered {
|
|
Ok(true) => {
|
|
if let Some(grant) = worker.pending.take() {
|
|
// Only this successful drain receipt allows a live pass.
|
|
let result = worker.drive(grant);
|
|
if result.is_err() {
|
|
worker.state = State::Unknown;
|
|
let _report =
|
|
crate::update_state::Uncertain::write(grant, &worker.identity);
|
|
}
|
|
drop(server);
|
|
let (settings, _) = helper_system::read_settings()?;
|
|
worker.pin.helper = settings.helper;
|
|
server = update_ipc::Server::bind(worker.pin.clone())?;
|
|
generation.store(current_generation_hint()?, Ordering::SeqCst);
|
|
}
|
|
}
|
|
Ok(false) => {}
|
|
Err(_) => {
|
|
// Lost reply/receipt can never execute the queued original.
|
|
if let Some(grant) = worker.pending.take() {
|
|
worker.state = State::Unknown;
|
|
let _report = crate::update_state::Uncertain::write(grant, &worker.identity);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
time_task.abort();
|
|
clock.close()?;
|
|
Ok(())
|
|
}
|
|
|
|
fn verify_final_record(
|
|
original: &Original,
|
|
trust: &TrustState,
|
|
proof: &rmm_domain::agent_update::UpdateInflightProof,
|
|
reply: &NativeControlReply,
|
|
) -> Result<()> {
|
|
let encoded = reply
|
|
.original_outcome_base64url
|
|
.as_ref()
|
|
.context("UPDATE_ORIGINAL_FINAL_OUTCOME_REQUIRED")?;
|
|
let raw = URL_SAFE_NO_PAD.decode(encoded)?;
|
|
let outcome: rmm_domain::reconciliation::ReconciledOutcome = serde_json::from_slice(&raw)?;
|
|
ensure!(
|
|
rmm_domain::reconciliation::canonical_outcome_bytes(&outcome)? == raw
|
|
&& outcome.state == "succeeded"
|
|
&& !outcome.reboot_required
|
|
&& outcome.error_code.is_empty()
|
|
&& outcome.exit_code == Some(0)
|
|
&& outcome.evidence["postconditions_passed"] == true,
|
|
"UPDATE_ORIGINAL_FINAL_OUTCOME_CHANGED"
|
|
);
|
|
let event_raw = URL_SAFE_NO_PAD.decode(
|
|
proof
|
|
.events
|
|
.last()
|
|
.context("UPDATE_ORIGINAL_HEALTH_EVENT_REQUIRED")?,
|
|
)?;
|
|
let event: rmm_updater_handoff::Event = serde_json::from_slice(&event_raw)?;
|
|
let rmm_updater_handoff::Evidence::HealthVerified { receipt: signed } = event.evidence else {
|
|
anyhow::bail!("UPDATE_ORIGINAL_HEALTH_EVENT_REQUIRED")
|
|
};
|
|
let receipt: rmm_updater_handoff::HealthReceipt = serde_json::from_slice(&signed.payload)?;
|
|
let expected = rmm_domain::agent_update_provisioning::assemble_updated_record(
|
|
original.update(),
|
|
trust.installed_raw(),
|
|
&hash(&original.handoff().bytes()?),
|
|
&signed,
|
|
&receipt,
|
|
)
|
|
.map_err(anyhow::Error::msg)?
|
|
.bytes()
|
|
.map_err(anyhow::Error::msg)?;
|
|
let (file, actual) = Protected::read(
|
|
Path::new(r"C:\ProgramData\RustDiscoveryUpdater\installed-record.json"),
|
|
32768,
|
|
)?;
|
|
let evidence = &outcome.evidence["agent_update"];
|
|
ensure!(
|
|
actual == expected
|
|
&& evidence["handoff_sha256"] == hash(&original.handoff().bytes()?)
|
|
&& evidence["installed_record_sha256"] == hash(&actual)
|
|
&& evidence["manifest_sha256"] == original.handoff().target.manifest_sha256
|
|
&& evidence["predecessor_record_sha256"]
|
|
== original.handoff().predecessor_record_sha256
|
|
&& evidence["signed_health_sha256"] == hash(&serde_json::to_vec(&signed)?)
|
|
&& evidence["rolled_back"] == false,
|
|
"UPDATE_ORIGINAL_RECORD_AND_OUTCOME_CHANGED"
|
|
);
|
|
file.verify()
|
|
}
|
|
|
|
fn verify_rollback_outcome(
|
|
original: &Original,
|
|
trust: &TrustState,
|
|
proof: &rmm_domain::agent_update::UpdateInflightProof,
|
|
reply: &NativeControlReply,
|
|
) -> Result<()> {
|
|
let raw = URL_SAFE_NO_PAD.decode(
|
|
reply
|
|
.original_outcome_base64url
|
|
.as_ref()
|
|
.context("UPDATE_ORIGINAL_ROLLBACK_OUTCOME_REQUIRED")?,
|
|
)?;
|
|
let outcome: rmm_domain::reconciliation::ReconciledOutcome = serde_json::from_slice(&raw)?;
|
|
let event_raw = URL_SAFE_NO_PAD.decode(
|
|
proof
|
|
.events
|
|
.last()
|
|
.context("UPDATE_ROLLBACK_HEALTH_EVENT_REQUIRED")?,
|
|
)?;
|
|
let event: rmm_updater_handoff::Event = serde_json::from_slice(&event_raw)?;
|
|
let rmm_updater_handoff::Evidence::RollbackHealthVerified { receipt: signed } = event.evidence
|
|
else {
|
|
anyhow::bail!("UPDATE_ROLLBACK_HEALTH_EVENT_REQUIRED")
|
|
};
|
|
let evidence = &outcome.evidence["agent_update"];
|
|
ensure!(
|
|
rmm_domain::reconciliation::canonical_outcome_bytes(&outcome)? == raw
|
|
&& outcome.state == "failed"
|
|
&& outcome.error_code == "AGENT_UPDATE_RETURNED_TO_PREDECESSOR"
|
|
&& !outcome.reboot_required
|
|
&& outcome.evidence["postconditions_passed"] == false
|
|
&& evidence["rolled_back"] == true
|
|
&& evidence["handoff_sha256"] == hash(&original.handoff().bytes()?)
|
|
&& evidence["predecessor_record_sha256"]
|
|
== original.handoff().predecessor_record_sha256
|
|
&& evidence["installed_record_sha256"] == original.handoff().predecessor_record_sha256
|
|
&& evidence["signed_health_sha256"] == hash(&serde_json::to_vec(&signed)?),
|
|
"UPDATE_ROLLBACK_OUTCOME_CHANGED"
|
|
);
|
|
let (file, raw) = Protected::read(
|
|
Path::new(r"C:\ProgramData\RustDiscoveryUpdater\installed-record.json"),
|
|
32768,
|
|
)?;
|
|
ensure!(
|
|
raw == trust.installed_raw(),
|
|
"UPDATE_ROLLBACK_CHANGED_RECORD_OR_FLOOR"
|
|
);
|
|
file.verify()
|
|
}
|