//! 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, identity: ParticipantIdentity, clock: RuntimeClock, generation: Arc, pending: Option, current: Option, seen: BTreeMap, state: State, } impl Worker { fn open(clock: RuntimeClock, generation: Arc) -> Result { 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 { 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::>() .try_into() .map_err(|_| anyhow::anyhow!("UPDATE_FIVE_FILES_REQUIRED"))?; let stages = bundle .files .iter() .map(|f| f.staged.clone()) .collect::>() .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 { 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 { 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 { 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() }