//! Complete current FD/maps observations plus exact known process generations. //! This is one half of admission, never a replacement for the independently //! qualified closed bootstrap/service registry or actual singleton/flock guard. use crate::{ agent_startup::{BoundAgentLock, HeldAgentLock}, census_process::{Proc, Stamp}, reader_registry::QualifiedRegistry, retained::{RetainedSet, Retention}, }; use anyhow::{Context, Result, ensure}; use rmm_domain::jobs::hash; use rmm_updater_linux::{ Budget, files::{Directory, Identity, LedgerGuard, LedgerIdentity}, services::{HeldService, Service, ServiceProof, StoppedServices}, }; use serde::{Deserialize, Serialize}; use std::{ fs::{File, OpenOptions}, os::unix::fs::{MetadataExt, OpenOptionsExt}, path::Path, time::{Duration, Instant}, }; const PATHS: [&str; 5] = [ "/var/lib/rmm-agent-remote/journal.sqlite", "/var/lib/rmm-agent-remote/consumption.sqlite", "/var/lib/rmm-helper/consumption.sqlite", "/var/lib/rmm-helper/executor.lock", "/var/lib/rmm-agent-remote/agent.lock", ]; /// Raw metadata only. Authority requires equality with the separately protected /// compatible-bootstrap registry; own-namespace == PID1 alone is insufficient. #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] #[serde(deny_unknown_fields)] pub struct HostContext { pub proc_device: u64, pub proc_inode: u64, pub user_namespace_device: u64, pub user_namespace_inode: u64, pub pid_namespace_device: u64, pub pid_namespace_inode: u64, pub cgroup_namespace_device: u64, pub cgroup_namespace_inode: u64, } pub fn current_host_context() -> Result { Proc::open()?.context() } struct Target { directory: Directory, file: File, identity: Identity, } /// Always the fixed three existing databases and two distinct existing locks. pub struct Targets { files: Vec, sha256: String, } impl Targets { pub fn bind( retained: &RetainedSet, ledger: &LedgerIdentity, agent: &BoundAgentLock, ) -> Result { retained.verify()?; let specs = retained.specs(); let mut files = Vec::new(); for (index, path) in PATHS.iter().enumerate() { let expected = match index { 3 => ledger.lock.clone(), 4 => agent.identity().clone(), _ => { let spec = specs .iter() .find(|s| s.path == Path::new(path)) .context("UPDATE_CENSUS_DATABASE_WITNESS_REQUIRED")?; ensure!( spec.retention == Retention::MutableDatabase, "UPDATE_CENSUS_DATABASE_WITNESS_REQUIRED" ); if index == 2 { ensure!( spec.identity == ledger.ledger, "UPDATE_CENSUS_ROOT_LEDGER_CHANGED" ); } spec.identity.clone() } }; ensure!( expected.uid == if index < 2 || index == 4 { 993 } else { 0 } && expected.mode & 0o022 == 0, "UPDATE_CENSUS_TARGET_PERMISSIONS" ); let directory = Directory::open( Path::new(path) .parent() .context("UPDATE_CENSUS_TARGET_PARENT")?, expected.uid, true, )?; // O_PATH binds identity without reading any database/key contents. let file = OpenOptions::new() .read(true) .custom_flags(libc::O_PATH | libc::O_NOFOLLOW | libc::O_CLOEXEC) .open(path)?; files.push(Target { directory, file, identity: expected, }); } let sha256 = hash(&serde_json::to_vec( &files.iter().map(|t| &t.identity).collect::>(), )?); let result = Self { files, sha256 }; result.verify()?; Ok(result) } fn verify(&self) -> Result<()> { ensure!(self.files.len() == 5, "UPDATE_CENSUS_TARGET_SET"); for (target, path) in self.files.iter().zip(PATHS) { target.directory.verify()?; let held = target.file.metadata()?; let named = std::fs::symlink_metadata(path)?; ensure!( held.is_file() && named.is_file() && !named.file_type().is_symlink() && identity(&held) == target.identity && identity(&named) == target.identity, "UPDATE_CENSUS_TARGET_REPLACED" ); } Ok(()) } } struct Known { service: ServiceProof, stamp: Stamp, } /// Private observation, no Deserialize/Clone/caller completeness boolean. pub struct Admission { host: HostContext, targets_sha256: String, known: Vec, finished: Instant, summary: Summary, } #[derive(Serialize)] struct Summary { schema_version: u32, phase: &'static str, targets_sha256: String, host_context_sha256: String, known_generations_sha256: String, pid_count: usize, fd_count: usize, map_count: usize, project_matches: Vec, } #[derive(Serialize)] struct Match { pid: u32, birth: u64, target_indices: Vec, } pub struct Stopped { host: HostContext, targets_sha256: String, updater: ServiceProof, finished: Instant, summary: Summary, } pub struct ClosureInputs<'a, 'stopped> { pub targets: &'a Targets, pub root: &'a LedgerGuard<'stopped>, pub agent: &'a HeldAgentLock, pub stopped: &'a StoppedServices, pub updater: &'a HeldService, pub registry: &'a QualifiedRegistry, } /// The observed absence is retained only under continuously borrowed original /// singleton/flock guards. No freshness timestamp is renewed and no future /// noncooperating privileged process absence is claimed. pub struct ClosedReaders<'a, 'stopped> { proof: Stopped, input: ClosureInputs<'a, 'stopped>, } impl ClosedReaders<'_, '_> { pub fn verify(&self, budget: &Budget) -> Result<()> { self.input.registry.verify_protected()?; self.proof.verify_held( self.input.targets, self.input.root, self.input.agent, self.input.stopped, self.input.updater, budget, ) } } impl Admission { pub fn sha256(&self) -> Result { Ok(hash(&serde_json::to_vec(&self.summary)?)) } /// Must be called again by the exact live original authorizer immediately /// before consumption; a passive persisted hash cannot stand in for it. pub fn verify_fresh( &self, targets: &Targets, known: &[&HeldService], budget: &Budget, ) -> Result<()> { budget.check()?; ensure!( self.finished.elapsed() < Duration::from_secs(1) && self.targets_sha256 == targets.sha256, "UPDATE_CENSUS_ADMISSION_STALE" ); targets.verify()?; ensure!( known.len() == self.known.len(), "UPDATE_CENSUS_READER_SET_CHANGED" ); let proc = Proc::open()?; ensure!( proc.context()? == self.host, "UPDATE_CENSUS_HOST_CONTEXT_CHANGED" ); for (held, old) in known.iter().zip(&self.known) { held.verify(budget)?; ensure!( *held.proof() == old.service && proc.process(old.stamp.pid)?.stamp == old.stamp, "UPDATE_CENSUS_READER_GENERATION_CHANGED" ); } targets.verify()?; budget.check()?; ensure!( self.finished.elapsed() < Duration::from_secs(1), "UPDATE_CENSUS_ADMISSION_STALE" ); Ok(()) } } impl Stopped { pub fn bind<'a, 'stopped>( self, input: ClosureInputs<'a, 'stopped>, budget: &Budget, ) -> Result> { input.registry.verify_protected()?; ensure!( *input.registry.host_context() == self.host, "UPDATE_CENSUS_REGISTRY_HOST_MISMATCH" ); self.verify_fresh( input.targets, input.root, input.agent, input.stopped, input.updater, budget, )?; Ok(ClosedReaders { proof: self, input }) } pub fn sha256(&self) -> Result { Ok(hash(&serde_json::to_vec(&self.summary)?)) } pub fn verify_fresh( &self, targets: &Targets, root: &LedgerGuard<'_>, agent: &HeldAgentLock, stopped: &StoppedServices, updater: &HeldService, budget: &Budget, ) -> Result<()> { budget.check()?; ensure!( self.finished.elapsed() < Duration::from_secs(1) && self.targets_sha256 == targets.sha256, "UPDATE_CENSUS_STOPPED_STALE" ); self.verify_held(targets, root, agent, stopped, updater, budget)?; budget.check()?; ensure!( self.finished.elapsed() < Duration::from_secs(1), "UPDATE_CENSUS_STOPPED_STALE" ); Ok(()) } fn verify_held( &self, targets: &Targets, root: &LedgerGuard<'_>, agent: &HeldAgentLock, stopped: &StoppedServices, updater: &HeldService, budget: &Budget, ) -> Result<()> { targets.verify()?; root.verify_for_effect(budget)?; agent.verify()?; stopped.verify_still_stopped(budget)?; updater.verify(budget)?; ensure!( self.targets_sha256 == targets.sha256 && targets.files[2].identity == root.identity().ledger && targets.files[3].identity == root.identity().lock && targets.files[4].identity == *agent.identity() && *updater.proof() == self.updater && current_host_context()? == self.host, "UPDATE_CENSUS_HELD_CLOSURE_CHANGED" ); targets.verify()?; budget.check() } } pub fn scan_admission( targets: &Targets, known: &[&HeldService], qualified_host: &HostContext, budget: &Budget, ) -> Result { ensure!( known.iter().map(|s| s.proof().service).eq([ Service::Agent, Service::General, Service::Full, Service::Updater ]), "UPDATE_CENSUS_KNOWN_READERS" ); targets.verify()?; let proc = Proc::open()?; ensure!( proc.context()? == *qualified_host, "UPDATE_CENSUS_HOST_CONTEXT_UNQUALIFIED" ); let mut saved = Vec::new(); for held in known { held.verify(budget)?; let process = proc.process(held.proof().process.pid)?; proc.verify_known_namespace(&process.stamp)?; bind_process(&process.stamp, held.proof())?; saved.push(Known { service: held.proof().clone(), stamp: process.stamp, }); } ensure!( saved .iter() .filter(|s| s.stamp.pid == std::process::id() && matches!(s.service.service, Service::Full | Service::Updater)) .count() == 1, "UPDATE_CENSUS_AUTHORIZER_PROCESS_REQUIRED" ); let summary = scan(&proc, targets, &saved, &[], "admission", budget)?; let finished = Instant::now(); for (held, old) in known.iter().zip(&saved) { held.verify(budget)?; ensure!( proc.process(old.stamp.pid)?.stamp == old.stamp, "UPDATE_CENSUS_READER_CHANGED" ); } targets.verify()?; ensure!( finished.elapsed() < Duration::from_secs(1), "UPDATE_CENSUS_ADMISSION_STALE" ); Ok(Admission { host: proc.context()?, targets_sha256: targets.sha256.clone(), known: saved, finished, summary, }) } pub fn scan_stopped( targets: &Targets, admission: &Admission, root: &LedgerGuard<'_>, agent: &HeldAgentLock, stopped: &StoppedServices, updater: &HeldService, budget: &Budget, ) -> Result { root.verify_for_effect(budget)?; agent.verify()?; stopped.verify_still_stopped(budget)?; updater.verify(budget)?; targets.verify()?; ensure!( admission.targets_sha256 == targets.sha256 && targets.files[2].identity == root.identity().ledger && targets.files[3].identity == root.identity().lock && targets.files[4].identity == *agent.identity() && updater.proof().service == Service::Updater && updater.proof().process.pid == std::process::id(), "UPDATE_CENSUS_STOPPED_LOCKS_OR_OWNER" ); let old = stopped.proofs(); ensure!( old.len() == 3 && old .iter() .zip(&admission.known) .all(|(s, k)| *s == k.service), "UPDATE_CENSUS_ORIGINAL_STOP_SET_CHANGED" ); let original_updater = admission .known .last() .context("UPDATE_CENSUS_UPDATER_MISSING")?; ensure!( *updater.proof() == original_updater.service, "UPDATE_CENSUS_ORIGINAL_UPDATER_CHANGED" ); let forbidden = admission.known[..3] .iter() .flat_map(|k| k.stamp.cgroup.iter().cloned()) .collect::>(); let proc = Proc::open()?; ensure!( proc.context()? == admission.host, "UPDATE_CENSUS_HOST_CONTEXT_CHANGED" ); proc.verify_known_namespace(&original_updater.stamp)?; let summary = scan( &proc, targets, std::slice::from_ref(original_updater), &forbidden, "stopped", budget, )?; let finished = Instant::now(); root.verify_for_effect(budget)?; agent.verify()?; stopped.verify_still_stopped(budget)?; updater.verify(budget)?; targets.verify()?; ensure!( finished.elapsed() < Duration::from_secs(1), "UPDATE_CENSUS_STOPPED_STALE" ); Ok(Stopped { host: admission.host.clone(), targets_sha256: targets.sha256.clone(), updater: updater.proof().clone(), finished, summary, }) } fn scan( proc: &Proc, targets: &Targets, allowed: &[Known], forbidden_cgroups: &[String], phase: &'static str, budget: &Budget, ) -> Result { let began = Instant::now(); let pids = proc.pids(budget)?; let ids = targets .files .iter() .map(|t| t.identity.clone()) .collect::>(); let mut summary = Summary { schema_version: 1, phase, targets_sha256: targets.sha256.clone(), host_context_sha256: hash(&serde_json::to_vec(&proc.context()?)?), known_generations_sha256: hash(&serde_json::to_vec( &allowed.iter().map(|k| &k.service).collect::>(), )?), pid_count: pids.len(), fd_count: 0, map_count: 0, project_matches: Vec::new(), }; for pid in &pids { budget.check()?; ensure!( began.elapsed() < Duration::from_secs(5), "UPDATE_CENSUS_TOTAL_DEADLINE" ); let process = proc.process(*pid)?; let hits = process.inspect(&ids, budget)?; ensure!( !hits.task_cgroups.iter().any(|c| forbidden_cgroups .iter() .any(|old| c == old || c.starts_with(&(old.to_owned() + "/")))), "UPDATE_CENSUS_STOPPED_CGROUP_HAS_PROCESS" ); summary.fd_count += hits.fd_count; summary.map_count += hits.map_count; let known = allowed.iter().find(|k| k.stamp.pid == *pid); if let Some(known) = known { ensure!( known.stamp == hits.stamp, "UPDATE_CENSUS_KNOWN_PROCESS_CHANGED" ); } if !hits.descriptors.is_empty() || !hits.mappings.is_empty() { ensure!(known.is_some(), "UPDATE_CENSUS_UNKNOWN_READER"); proc.verify_known_namespace(&hits.stamp)?; let mut indices = hits.descriptors; indices.extend(hits.mappings); indices.sort_unstable(); indices.dedup(); summary.project_matches.push(Match { pid: *pid, birth: hits.stamp.birth, target_indices: indices, }); } } ensure!( proc.pids(budget)? == pids && began.elapsed() < Duration::from_secs(5), "UPDATE_CENSUS_INCOMPLETE_OR_CHANGED_PID_SET" ); Ok(summary) } fn bind_process(stamp: &Stamp, service: &ServiceProof) -> Result<()> { ensure!( stamp.pid == service.process.pid && stamp.birth == service.process.birth && stamp.uid == service.process.uid && stamp.gid == service.process.gid && stamp.image.is_some(), "UPDATE_CENSUS_PINNED_PROCESS_CHANGED" ); ensure!( stamp .cgroup .iter() .any(|p| p.rsplit('/').next() == Some(service.service.unit())), "UPDATE_CENSUS_SERVICE_CGROUP_UNBOUND" ); Ok(()) } fn identity(meta: &std::fs::Metadata) -> Identity { Identity { device: meta.dev(), inode: meta.ino(), uid: meta.uid(), gid: meta.gid(), mode: meta.mode(), links: meta.nlink(), } }