//! Private Windows installed-record builder and fixed handle-based namespace. //! Public metadata assembly is never permission to publish a record/floor. use crate::{ helper_ipc::PinnedFile, update_native::files::{self, Proof}, update_original::Original, }; use anyhow::{Result, ensure}; use ed25519_dalek::{Signature, VerifyingKey}; use rmm_agent_core::update_handoff::{NativeEffect, NativeEffectClaim}; use rmm_domain::{ agent_update::ResolvedAgentUpdate, agent_update_provisioning::{InstalledReleaseRecord, MAX_RECORD_BYTES}, jobs::hash, }; use rmm_updater_handoff::{ Event, Evidence, HEALTH_DOMAIN, HealthReceipt, Journal, Phase, SignedHealth, }; use std::{ fs::{File, OpenOptions}, io::Write, os::windows::fs::OpenOptionsExt, path::{Path, PathBuf}, }; use uuid::Uuid; use windows_sys::Win32::Storage::FileSystem::*; const ROOT: &str = r"C:\ProgramData\RustDiscoveryUpdater"; const CURRENT: &str = r"C:\ProgramData\RustDiscoveryUpdater\installed-record.json"; const RECORDS: &str = r"C:\ProgramData\RustDiscoveryUpdater\records"; pub(crate) struct BuiltRecord { record: InstalledReleaseRecord, raw: Vec, prior_raw: Vec, old_sha256: String, sha256: String, grant_id: Uuid, owner_nonce: Uuid, } impl BuiltRecord { pub(crate) fn build( original: &Original, prior_raw: &[u8], journal: &Journal, health_event_raw: &[u8], ) -> Result { let header = original.handoff(); let handoff_sha256 = hash(&header.bytes()?); ensure!( journal.phase() == Phase::HealthVerified && journal.handoff_sha256() == handoff_sha256 && !health_event_raw.is_empty() && health_event_raw.len() <= rmm_updater_handoff::MAX_EVENT_BYTES && hash(health_event_raw) == journal.head_sha256(), "UPDATE_RECORD_HEALTH_HEAD" ); let event: Event = serde_json::from_slice(health_event_raw)?; ensure!( serde_json::to_vec(&event)? == health_event_raw && event.handoff_sha256 == handoff_sha256 && event.boot_id == header.boot_id, "UPDATE_RECORD_HEALTH_EVENT" ); let Evidence::HealthVerified { receipt: signed } = &event.evidence else { anyhow::bail!("UPDATE_RECORD_HEALTH_REQUIRED") }; ensure!( !signed.payload.is_empty() && signed.payload.len() <= 4096 && signed.signature.len() == 64, "UPDATE_RECORD_HEALTH_LIMIT" ); let receipt: HealthReceipt = serde_json::from_slice(&signed.payload)?; ensure!( serde_json::to_vec(&receipt)? == signed.payload, "UPDATE_RECORD_HEALTH_NONCANONICAL" ); // Journal possession is not independent key trust. Authenticate the // exact receipt again with the ORIGINAL signed job's external key pin. let raw: [u8; 32] = hex::decode(&original.update().updater.health_public_key_hex)? .try_into() .map_err(|_| anyhow::anyhow!("UPDATE_RECORD_HEALTH_KEY"))?; let public = VerifyingKey::from_bytes(&raw)?; ensure!(!public.is_weak(), "UPDATE_RECORD_HEALTH_KEY"); let mut message = HEALTH_DOMAIN.to_vec(); message.extend_from_slice(&signed.payload); public.verify_strict(&message, &Signature::from_slice(&signed.signature)?)?; ensure!( receipt.schema_version == 1 && receipt.handoff_sha256 == handoff_sha256 && receipt.owner_nonce == header.owner_nonce && receipt.boot_id == header.boot_id && receipt.helper_journal_id == header.helper_journal_id && receipt.agent_journal_id == header.agent_journal_id && receipt.connection_generation > header.connection_generation && !receipt.ready && receipt.issued_at >= header.consumed_at && receipt.issued_at <= event.observed_at && event.observed_at < receipt.valid_until && receipt.valid_until <= header.finish_before, "UPDATE_RECORD_HEALTH_BINDING" ); Self::assemble( original.update(), prior_raw, &handoff_sha256, signed, &receipt, header.attempt.grant_id, header.owner_nonce, ) } fn assemble( update: &ResolvedAgentUpdate, prior_raw: &[u8], handoff_sha256: &str, signed: &SignedHealth, receipt: &HealthReceipt, grant_id: Uuid, owner_nonce: Uuid, ) -> Result { ensure!( update.validate() && !grant_id.is_nil() && !owner_nonce.is_nil(), "UPDATE_RECORD_INPUT" ); let record = rmm_domain::agent_update_provisioning::assemble_updated_record( update, prior_raw, handoff_sha256, signed, receipt, ) .map_err(anyhow::Error::msg)?; let old_sha256 = hash(prior_raw); let raw = record.bytes().map_err(anyhow::Error::msg)?; let sha256 = hash(&raw); ensure!(sha256 != old_sha256, "UPDATE_RECORD_SAME_BYTES"); Ok(Self { record, raw, prior_raw: prior_raw.to_vec(), old_sha256, sha256, grant_id, owner_nonce, }) } pub(crate) fn record(&self) -> &InstalledReleaseRecord { &self.record } pub(crate) fn sha256(&self) -> &str { &self.sha256 } } #[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize)] enum State { Staged, Archived, Published, } pub(crate) struct Transition { built: BuiltRecord, root: std::cell::RefCell, records: std::cell::RefCell, old_proof: Proof, new_proof: Proof, new: File, old: Option, stage: PathBuf, archive: PathBuf, state: State, } fn open(path: &Path, delete: bool) -> Result { let mut options = OpenOptions::new(); options .read(true) .share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE) .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_WRITE_THROUGH); if delete { options .access_mode(FILE_GENERIC_READ | FILE_GENERIC_WRITE | DELETE) .share_mode(FILE_SHARE_READ); } Ok(options.open(path)?) } fn read(path: &Path) -> Result { files::proof(&mut open(path, false)?, path, MAX_RECORD_BYTES as u64) } impl Transition { pub(crate) fn prepare(built: BuiltRecord) -> Result { let root = PinnedFile::open(Path::new(ROOT), true, &[], &[], false)?; let records = PinnedFile::open(Path::new(RECORDS), true, &[], &[], false)?; let mut original = open(Path::new(CURRENT), false)?; let old_proof = files::proof(&mut original, Path::new(CURRENT), MAX_RECORD_BYTES as u64)?; ensure!( old_proof.sha256 == built.old_sha256, "UPDATE_RECORD_ORIGINAL_FILE_REQUIRED" ); let stage = Path::new(ROOT).join(format!(".rmm-record-{}.stage", built.owner_nonce)); let archive = Path::new(RECORDS).join(format!("{}.json", built.old_sha256)); ensure!( !archive.try_exists()?, "UPDATE_RECORD_ARCHIVE_ALREADY_PRESENT" ); let mut new = files::create_record_stage(&original, &stage)?; new.write_all(&built.raw)?; new.sync_all()?; let new_proof = files::proof(&mut new, &stage, MAX_RECORD_BYTES as u64)?; ensure!( new_proof.sha256 == built.sha256 && new_proof.security_sha256 == old_proof.security_sha256 && new_proof.identity != old_proof.identity, "UPDATE_RECORD_STAGE_BINDING" ); let result = Self { built, root: std::cell::RefCell::new(root), records: std::cell::RefCell::new(records), old_proof, new_proof, new, old: None, stage, archive, state: State::Staged, }; result.verify()?; Ok(result) } pub(crate) fn verify(&self) -> Result<()> { self.root.try_borrow_mut()?.check()?; self.records.try_borrow_mut()?.check()?; match self.state { State::Staged => ensure!( read(Path::new(CURRENT))? == self.old_proof && read(&self.stage)? == self.new_proof && !self.archive.try_exists()?, "UPDATE_RECORD_STAGED_NAMESPACE_CHANGED" ), State::Archived => ensure!( read(&self.archive)? == self.old_proof && read(&self.stage)? == self.new_proof && !Path::new(CURRENT).try_exists()?, "UPDATE_RECORD_ARCHIVED_NAMESPACE_CHANGED" ), State::Published => ensure!( read(&self.archive)? == self.old_proof && read(Path::new(CURRENT))? == self.new_proof && !self.stage.try_exists()?, "UPDATE_RECORD_PUBLISHED_NAMESPACE_CHANGED" ), } Ok(()) } pub(crate) fn verify_original(&self, raw: &[u8]) -> Result<()> { ensure!( self.built.prior_raw == raw && hash(raw) == self.old_proof.sha256, "UPDATE_RECORD_PREDECESSOR_CHANGED" ); self.verify() } pub(crate) fn effect(&self) -> Result { let old_sha256 = self.built.old_sha256.clone(); let new_sha256 = self.built.sha256.clone(); Ok(match self.state { State::Staged => NativeEffect::SaveInstalledRecord { old_sha256, new_sha256, }, State::Archived => NativeEffect::PublishInstalledRecord { old_sha256, new_sha256, }, State::Published => anyhow::bail!("UPDATE_RECORD_ALREADY_PUBLISHED"), }) } pub(crate) fn verify_effect(&self, effect: &NativeEffect, observed: bool) -> Result<()> { self.verify()?; let expected = match (self.state, observed) { (State::Staged, false) | (State::Archived, true) => NativeEffect::SaveInstalledRecord { old_sha256: self.built.old_sha256.clone(), new_sha256: self.built.sha256.clone(), }, (State::Archived, false) | (State::Published, true) => { NativeEffect::PublishInstalledRecord { old_sha256: self.built.old_sha256.clone(), new_sha256: self.built.sha256.clone(), } } _ => anyhow::bail!("UPDATE_RECORD_EFFECT_PHASE"), }; ensure!( *effect == expected, "UPDATE_RECORD_EXACT_NATIVE_EFFECT_REQUIRED" ); Ok(()) } pub(crate) fn apply(&mut self, claim: &NativeEffectClaim) -> Result<()> { self.verify_effect(claim.effect(), false)?; ensure!( claim.grant_id() == self.built.grant_id && claim.owner_nonce() == self.built.owner_nonce, "UPDATE_RECORD_ORIGINAL_CLAIM_REQUIRED" ); match self.state { State::Staged => { let mut old = open(Path::new(CURRENT), true)?; ensure!( files::proof(&mut old, Path::new(CURRENT), MAX_RECORD_BYTES as u64)? == self.old_proof, "UPDATE_RECORD_OLD_HANDLE_CHANGED" ); files::rename_record(&old, &self.archive)?; ensure!( files::proof(&mut old, &self.archive, MAX_RECORD_BYTES as u64)? == self.old_proof, "UPDATE_RECORD_ARCHIVE_READBACK" ); self.old = Some(old); self.state = State::Archived; } State::Archived => { files::rename_record(&self.new, Path::new(CURRENT))?; ensure!( files::proof(&mut self.new, Path::new(CURRENT), MAX_RECORD_BYTES as u64)? == self.new_proof, "UPDATE_RECORD_PUBLISH_READBACK" ); self.state = State::Published; } State::Published => anyhow::bail!("UPDATE_RECORD_NO_RETRY"), } self.verify() } pub(crate) fn observation(&self) -> Result { self.verify()?; Ok(hash(&serde_json::to_vec(&( self.state, &self.old_proof, &self.new_proof, ))?)) } pub(crate) fn built(&self) -> &BuiltRecord { &self.built } pub(crate) fn published(&self) -> Result<()> { ensure!( self.state == State::Published, "UPDATE_RECORD_PUBLICATION_REQUIRED" ); self.verify() } }