diff --git a/crates/domain/src/agent_update_provisioning.rs b/crates/domain/src/agent_update_provisioning.rs index 3c61315..4349e10 100644 --- a/crates/domain/src/agent_update_provisioning.rs +++ b/crates/domain/src/agent_update_provisioning.rs @@ -223,6 +223,8 @@ pub struct LocalUpdatePolicy { pub installed_record_path: String, pub keyring_path: String, pub health_pin_path: String, + pub registry_path: String, + pub reader_registry_sha256: String, pub services: Vec, pub updater_service: LocalServicePin, pub updater_binary_sha256: String, @@ -254,6 +256,8 @@ impl LocalUpdatePolicy { && self.installed_record_path == "/var/lib/rmm-agent-updater/installed-record.json" && self.keyring_path == "/etc/rmm-agent-updater/keyring.json" && self.health_pin_path == "/etc/rmm-agent-updater/health-key.json" + && self.registry_path == "/etc/rmm-agent-updater/reader-registry.json" + && digest(&self.reader_registry_sha256) && (names == SERVICES || names == [ diff --git a/crates/updater-worker/src/census.rs b/crates/updater-worker/src/census.rs new file mode 100644 index 0000000..b815066 --- /dev/null +++ b/crates/updater-worker/src/census.rs @@ -0,0 +1,558 @@ +//! 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(), + } +} diff --git a/crates/updater-worker/src/census_process.rs b/crates/updater-worker/src/census_process.rs new file mode 100644 index 0000000..e62fb90 --- /dev/null +++ b/crates/updater-worker/src/census_process.rs @@ -0,0 +1,697 @@ +//! Bounded kernel observations only. No command line/environment/key reads and +//! no data from unrelated processes is returned. Not admission by itself. +use anyhow::{Context, Result, ensure}; +use rmm_updater_linux::{Budget, files::Identity}; +use std::{ + ffi::CString, + fs::File, + io::Read, + os::{ + fd::{AsRawFd, FromRawFd}, + unix::fs::MetadataExt, + }, +}; + +const MAX_PIDS: usize = 16384; +const MAX_FDS: usize = 65536; +const MAX_MAPS: usize = 8 * 1024 * 1024; +const PROC_MAGIC: libc::c_long = 0x9fa0; + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct Namespace { + pub device: u64, + pub inode: u64, +} +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct Stamp { + pub pid: u32, + pub birth: u64, + pub tgid: u32, + pub uid: u32, + pub gid: u32, + pub image: Option<(u64, u64, i64, i64, i64, i64)>, + pub cgroup: Vec, + pub user_ns: Namespace, + pub pid_ns: Namespace, + pub cgroup_ns: Namespace, +} +pub(crate) struct Process { + pidfd: File, + directory: File, + pub stamp: Stamp, +} +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct Hits { + pub stamp: Stamp, + pub descriptors: Vec, + pub mappings: Vec, + pub fd_count: usize, + pub task_cgroups: Vec, + pub map_count: usize, +} + +pub(crate) struct Proc { + directory: File, + user_ns: Namespace, + pid_ns: Namespace, + cgroup_ns: Namespace, +} +impl Proc { + pub fn context(&self) -> Result { + let meta = self.directory.metadata()?; + Ok(crate::census::HostContext { + proc_device: meta.dev(), + proc_inode: meta.ino(), + user_namespace_device: self.user_ns.device, + user_namespace_inode: self.user_ns.inode, + pid_namespace_device: self.pid_ns.device, + pid_namespace_inode: self.pid_ns.inode, + cgroup_namespace_device: self.cgroup_ns.device, + cgroup_namespace_inode: self.cgroup_ns.inode, + }) + } + pub fn open() -> Result { + ensure!( + unsafe { libc::geteuid() } == 0, + "UPDATE_CENSUS_HOST_ROOT_REQUIRED" + ); + let path = CString::new("/proc")?; + let fd = unsafe { + libc::open( + path.as_ptr(), + libc::O_RDONLY | libc::O_DIRECTORY | libc::O_NOFOLLOW | libc::O_CLOEXEC, + ) + }; + ensure!(fd >= 0, "UPDATE_CENSUS_PROC_OPEN"); + let directory = unsafe { File::from_raw_fd(fd) }; + let mut info = std::mem::MaybeUninit::::zeroed(); + ensure!( + unsafe { libc::fstatfs(directory.as_raw_fd(), info.as_mut_ptr()) } == 0 + && unsafe { info.assume_init() }.f_type == PROC_MAGIC, + "UPDATE_CENSUS_PROC_FILESYSTEM" + ); + ensure!( + directory.metadata()?.uid() == 0 && directory.metadata()?.mode() & 0o022 == 0, + "UPDATE_CENSUS_PROC_OWNER" + ); + let group = open_dir(&directory, &std::process::id().to_string())?; + let tasks = open_dir(&group, "task")?; + let tid = unsafe { libc::syscall(libc::SYS_gettid) }; + ensure!(tid > 0, "UPDATE_CENSUS_CURRENT_TASK"); + let own = open_dir(&tasks, &tid.to_string())?; + let own_stamp = stamp(&own, u32::try_from(tid)?)?; + ensure!( + own_stamp.tgid == std::process::id() && own_stamp.uid == 0, + "UPDATE_CENSUS_CURRENT_TASK_NOT_HOST_ROOT" + ); + let init = open_dir(&directory, "1")?; + let user_ns = namespace(&own, "user")?; + let pid_ns = namespace(&own, "pid")?; + let cgroup_ns = namespace(&own, "cgroup")?; + ensure!( + namespace(&init, "user")? == user_ns && namespace(&init, "pid")? == pid_ns, + "UPDATE_CENSUS_NAMESPACE_NOT_HOST_VIEW" + ); + // A hidden/subset proc mount cannot prove a complete PID enumeration. + // Paths are examined only in memory; no mountinfo content is exported. + let raw = read(&own, "mountinfo", 256 * 1024)?; + let text = std::str::from_utf8(&raw)?; + let mut count = 0; + for row in text.lines() { + let (left, right) = row.split_once(" - ").context("UPDATE_CENSUS_MOUNTINFO")?; + let left = left.split_ascii_whitespace().collect::>(); + let right = right.split_ascii_whitespace().collect::>(); + ensure!( + left.len() >= 6 && right.len() >= 3, + "UPDATE_CENSUS_MOUNTINFO" + ); + if left[4] == "/proc" { + count += 1; + ensure!( + left[3] == "/" + && right[0] == "proc" + && left[5] + .split(',') + .chain(right[2].split(',')) + .all(|v| matches!( + v, + "rw" | "ro" + | "nosuid" + | "nodev" + | "noexec" + | "relatime" + | "strictatime" + | "noatime" + | "nodiratime" + | "hidepid=0" + | "hidepid=off" + )), + "UPDATE_CENSUS_HIDDEN_OR_UNKNOWN_PROC_OPTIONS" + ); + } + } + ensure!(count == 1, "UPDATE_CENSUS_PROC_MOUNT_AMBIGUOUS"); + Ok(Self { + directory, + user_ns, + pid_ns, + cgroup_ns, + }) + } + pub fn pids(&self, budget: &Budget) -> Result> { + let mut pids = Vec::new(); + for entry in std::fs::read_dir(format!( + "/proc/thread-self/fd/{}", + self.directory.as_raw_fd() + ))? { + budget.check()?; + let name = entry?.file_name(); + let Some(name) = name.to_str() else { + anyhow::bail!("UPDATE_CENSUS_PROC_ENTRY") + }; + if name.bytes().all(|v| v.is_ascii_digit()) { + let pid: u32 = name.parse()?; + ensure!(pid > 0 && pids.len() < MAX_PIDS, "UPDATE_CENSUS_PID_LIMIT"); + pids.push(pid); + } + } + pids.sort_unstable(); + ensure!( + !pids.is_empty() && !pids.windows(2).any(|w| w[0] == w[1]), + "UPDATE_CENSUS_PID_SET" + ); + Ok(pids) + } + pub fn process(&self, pid: u32) -> Result { + ensure!(pid > 0, "UPDATE_CENSUS_PID"); + let fd = unsafe { libc::syscall(libc::SYS_pidfd_open, pid, 0) }; + ensure!(fd >= 0, "UPDATE_CENSUS_PIDFD_UNAVAILABLE"); + let pidfd = unsafe { File::from_raw_fd(fd as i32) }; + let directory = open_dir(&self.directory, &pid.to_string())?; + let stamp = stamp(&directory, pid)?; + let result = Process { + pidfd, + directory, + stamp, + }; + result.verify()?; + Ok(result) + } + pub fn verify_known_namespace(&self, stamp: &Stamp) -> Result<()> { + ensure!( + stamp.user_ns == self.user_ns + && stamp.pid_ns == self.pid_ns + && stamp.cgroup_ns == self.cgroup_ns, + "UPDATE_CENSUS_READER_NAMESPACE_CHANGED" + ); + Ok(()) + } +} +impl Process { + pub fn verify(&self) -> Result<()> { + let mut poll = libc::pollfd { + fd: self.pidfd.as_raw_fd(), + events: libc::POLLIN, + revents: 0, + }; + ensure!( + unsafe { libc::poll(&mut poll, 1, 0) } == 0 + && poll.revents == 0 + && stamp(&self.directory, self.stamp.pid)? == self.stamp, + "UPDATE_CENSUS_PROCESS_CHANGED" + ); + Ok(()) + } + pub fn inspect(&self, targets: &[Identity], budget: &Budget) -> Result { + self.verify()?; + let task_dir = open_dir(&self.directory, "task")?; + let tids = task_ids(&task_dir, budget)?; + let mut held_tasks = Vec::new(); + let mut descriptors = Vec::new(); + let mut fd_count = 0; + let mut task_cgroups = Vec::new(); + for tid in &tids { + self.verify()?; + let directory = open_dir(&task_dir, &tid.to_string())?; + let before = stamp(&directory, *tid)?; + ensure!( + before.tgid == self.stamp.pid, + "UPDATE_CENSUS_TASK_GROUP_CHANGED" + ); + let (hits, count) = inspect_fds(&directory, targets, budget)?; + fd_count += count; + ensure!(fd_count <= MAX_FDS, "UPDATE_CENSUS_TOTAL_FD_LIMIT"); + if !hits.is_empty() { + ensure!( + before.uid == self.stamp.uid + && before.gid == self.stamp.gid + && before.user_ns == self.stamp.user_ns + && before.pid_ns == self.stamp.pid_ns + && before.cgroup_ns == self.stamp.cgroup_ns, + "UPDATE_CENSUS_READER_TASK_CONTEXT_CHANGED" + ); + } + descriptors.extend(hits); + task_cgroups.extend(before.cgroup.iter().cloned()); + ensure!( + stamp(&directory, *tid)? == before, + "UPDATE_CENSUS_TASK_CHANGED" + ); + // Retain each actual task directory until the complete probe ends; + // a same-TID replacement cannot substitute a new task directory. + held_tasks.push((directory, before)); + } + let raw = read(&self.directory, "maps", MAX_MAPS)?; + let text = std::str::from_utf8(&raw)?; + let mut mappings = Vec::new(); + let mut map_count = 0; + for row in text.lines() { + budget.check()?; + map_count += 1; + ensure!(map_count <= 65536, "UPDATE_CENSUS_MAP_LIMIT"); + let mut fields = row.split_ascii_whitespace(); + for _ in 0..3 { + fields.next().context("UPDATE_CENSUS_MAP_FIELDS")?; + } + let (major, minor) = fields + .next() + .context("UPDATE_CENSUS_MAP_DEVICE")? + .split_once(':') + .context("UPDATE_CENSUS_MAP_DEVICE")?; + let device = libc::makedev( + u32::from_str_radix(major, 16)?, + u32::from_str_radix(minor, 16)?, + ); + let inode: u64 = fields.next().context("UPDATE_CENSUS_MAP_INODE")?.parse()?; + if inode != 0 { + for (index, target) in targets.iter().enumerate() { + if device == target.device && inode == target.inode { + mappings.push(index); + } + } + } + } + descriptors.sort_unstable(); + descriptors.dedup(); + mappings.sort_unstable(); + mappings.dedup(); + ensure!( + task_ids(&task_dir, budget)? == tids, + "UPDATE_CENSUS_TASK_SET_CHANGED" + ); + for (directory, before) in held_tasks { + ensure!( + stamp(&directory, before.pid)? == before, + "UPDATE_CENSUS_TASK_CHANGED" + ); + } + task_cgroups.sort(); + task_cgroups.dedup(); + self.verify()?; + Ok(Hits { + stamp: self.stamp.clone(), + descriptors, + mappings, + fd_count, + task_cgroups, + map_count, + }) + } +} +fn inspect_fds( + directory: &File, + targets: &[Identity], + budget: &Budget, +) -> Result<(Vec, usize)> { + let fd_dir = open_dir(directory, "fd")?; + let mut descriptors = Vec::new(); + let mut fd_count = 0; + // Keep read_dir's descriptor alive while inspecting every magic link; + // this also handles enumeration of our own descriptor without a gap. + for entry in std::fs::read_dir(format!("/proc/thread-self/fd/{}", fd_dir.as_raw_fd()))? { + budget.check()?; + fd_count += 1; + ensure!(fd_count <= MAX_FDS, "UPDATE_CENSUS_FD_LIMIT"); + let entry = entry?; + let name = entry.file_name(); + let name = name.to_str().context("UPDATE_CENSUS_FD_NAME")?; + ensure!( + !name.is_empty() && name.bytes().all(|v| v.is_ascii_digit()), + "UPDATE_CENSUS_FD_NAME" + ); + let name = CString::new(name)?; + let mut info = std::mem::MaybeUninit::::zeroed(); + ensure!( + unsafe { libc::fstatat(fd_dir.as_raw_fd(), name.as_ptr(), info.as_mut_ptr(), 0) } == 0, + "UPDATE_CENSUS_INCOMPLETE_FD" + ); + let info = unsafe { info.assume_init() }; + for (index, target) in targets.iter().enumerate() { + if info.st_dev == target.device && info.st_ino == target.inode { + descriptors.push(index); + } + } + } + Ok((descriptors, fd_count)) +} +fn task_ids(directory: &File, budget: &Budget) -> Result> { + let mut ids = Vec::new(); + for entry in std::fs::read_dir(format!("/proc/thread-self/fd/{}", directory.as_raw_fd()))? { + budget.check()?; + let name = entry?.file_name(); + let text = name.to_str().context("UPDATE_CENSUS_TASK_NAME")?; + ensure!( + !text.is_empty() && text.bytes().all(|v| v.is_ascii_digit()) && ids.len() < 4096, + "UPDATE_CENSUS_TASK_LIMIT" + ); + ids.push(text.parse()?); + } + ids.sort_unstable(); + ensure!( + !ids.is_empty() && !ids.windows(2).any(|w| w[0] == w[1]), + "UPDATE_CENSUS_TASK_SET" + ); + Ok(ids) +} + +fn open_dir(parent: &File, name: &str) -> Result { + let name = CString::new(name)?; + let fd = unsafe { + libc::openat( + parent.as_raw_fd(), + name.as_ptr(), + libc::O_RDONLY | libc::O_DIRECTORY | libc::O_NOFOLLOW | libc::O_CLOEXEC, + ) + }; + ensure!(fd >= 0, "UPDATE_CENSUS_DIRECTORY_UNAVAILABLE"); + Ok(unsafe { File::from_raw_fd(fd) }) +} +fn read(parent: &File, name: &str, max: usize) -> Result> { + let name = CString::new(name)?; + let fd = unsafe { + libc::openat( + parent.as_raw_fd(), + name.as_ptr(), + libc::O_RDONLY | libc::O_NOFOLLOW | libc::O_CLOEXEC, + ) + }; + ensure!(fd >= 0, "UPDATE_CENSUS_PROC_DATA_UNAVAILABLE"); + let mut raw = Vec::new(); + unsafe { File::from_raw_fd(fd) } + .take((max + 1) as u64) + .read_to_end(&mut raw)?; + ensure!(raw.len() <= max, "UPDATE_CENSUS_PROC_DATA_LIMIT"); + Ok(raw) +} +fn namespace(parent: &File, kind: &str) -> Result { + let name = CString::new(format!("ns/{kind}"))?; + let mut info = std::mem::MaybeUninit::::zeroed(); + ensure!( + unsafe { libc::fstatat(parent.as_raw_fd(), name.as_ptr(), info.as_mut_ptr(), 0) } == 0, + "UPDATE_CENSUS_NAMESPACE_UNAVAILABLE" + ); + let info = unsafe { info.assume_init() }; + Ok(Namespace { + device: info.st_dev, + inode: info.st_ino, + }) +} +fn stamp(parent: &File, pid: u32) -> Result { + let raw = read(parent, "stat", 65536)?; + let raw = std::str::from_utf8(&raw)?; + let (_, fields) = raw.rsplit_once(") ").context("UPDATE_CENSUS_STAT")?; + let fields = fields.split_ascii_whitespace().collect::>(); + ensure!(fields.len() >= 20, "UPDATE_CENSUS_STAT"); + let birth = fields[19].parse()?; + let flags: u64 = fields[6].parse()?; + let raw = read(parent, "status", 65536)?; + let text = std::str::from_utf8(&raw)?; + let id = |label: &str| -> Result { + let mut rows = text.lines().filter_map(|r| r.strip_prefix(label)); + let row = rows.next().context("UPDATE_CENSUS_CREDENTIALS")?; + ensure!(rows.next().is_none(), "UPDATE_CENSUS_CREDENTIALS"); + let fields = row + .split_ascii_whitespace() + .map(str::parse) + .collect::, _>>()?; + ensure!( + fields.len() == 4 && fields.iter().all(|v| *v == fields[0]), + "UPDATE_CENSUS_CHANGING_CREDENTIALS" + ); + Ok(fields[0]) + }; + let uid = id("Uid:")?; + let gid = id("Gid:")?; + let mut tgids = text.lines().filter_map(|r| r.strip_prefix("Tgid:")); + let tgid = tgids + .next() + .context("UPDATE_CENSUS_TASK_GROUP")? + .trim() + .parse()?; + ensure!(tgids.next().is_none(), "UPDATE_CENSUS_TASK_GROUP"); + let name = CString::new("exe")?; + let fd = unsafe { + libc::openat( + parent.as_raw_fd(), + name.as_ptr(), + libc::O_PATH | libc::O_CLOEXEC, + ) + }; + let image = if fd >= 0 { + let file = unsafe { File::from_raw_fd(fd) }; + let meta = file.metadata()?; + ensure!(meta.is_file(), "UPDATE_CENSUS_PROCESS_IMAGE"); + Some(( + meta.dev(), + meta.ino(), + meta.mtime(), + meta.mtime_nsec(), + meta.ctime(), + meta.ctime_nsec(), + )) + } else { + ensure!( + std::io::Error::last_os_error().raw_os_error() == Some(libc::ENOENT) + && flags & 0x0020_0000 != 0, + "UPDATE_CENSUS_PROCESS_IMAGE_UNAVAILABLE" + ); + None + }; + let raw = read(parent, "cgroup", 65536)?; + let text = std::str::from_utf8(&raw)?; + let mut cgroup = Vec::new(); + for line in text.lines() { + let mut fields = line.splitn(3, ':'); + fields.next().context("UPDATE_CENSUS_CGROUP")?; + fields.next().context("UPDATE_CENSUS_CGROUP")?; + let path = fields.next().context("UPDATE_CENSUS_CGROUP")?; + // Kernel cgroup paths are compared only as bounded opaque strings; + // they are never used as filesystem paths. Host namespace authority + // comes separately from the protected bootstrap registry. + ensure!( + path.starts_with('/') && path.len() <= 4096, + "UPDATE_CENSUS_CGROUP" + ); + cgroup.push(path.to_owned()); + } + ensure!( + !cgroup.is_empty() && cgroup.len() <= 64, + "UPDATE_CENSUS_CGROUP" + ); + Ok(Stamp { + pid, + birth, + tgid, + uid, + gid, + image, + cgroup, + user_ns: namespace(parent, "user")?, + pid_ns: namespace(parent, "pid")?, + cgroup_ns: namespace(parent, "cgroup")?, + }) +} + +#[cfg(test)] +mod tests { + use super::*; + use std::{ + fs::{self, OpenOptions}, + os::unix::fs::OpenOptionsExt, + time::Duration, + }; + #[test] + fn private_thread_fd_table_cannot_hide_a_reader_from_the_group_probe() { + assert_eq!(unsafe { libc::geteuid() }, 0); + let path = std::path::Path::new("/run") + .join(format!("rmm-census-thread-{}", uuid::Uuid::new_v4())); + let file = OpenOptions::new() + .read(true) + .write(true) + .create_new(true) + .mode(0o600) + .open(&path) + .unwrap(); + struct Cleanup(std::path::PathBuf); + impl Drop for Cleanup { + fn drop(&mut self) { + fs::remove_file(&self.0).unwrap(); + } + } + let _cleanup = Cleanup(path.clone()); + let meta = file.metadata().unwrap(); + let target = Identity { + device: meta.dev(), + inode: meta.ino(), + uid: meta.uid(), + gid: meta.gid(), + mode: meta.mode(), + links: meta.nlink(), + }; + let (ready, wait_ready) = std::sync::mpsc::channel(); + let (release, wait_release) = std::sync::mpsc::channel(); + let thread = std::thread::spawn(move || { + // Only this owned fixture thread separates its descriptor table. + // close_range(UNSHARE) is the same files-table operation without + // Docker's unrelated unshare syscall gate. UINT_MAX cannot name + // an open Linux fd, so no descriptor is closed. No namespace, + // mount, machine policy, seccomp profile or service is changed. + if unsafe { + libc::syscall( + libc::SYS_close_range, + u32::MAX, + u32::MAX, + libc::CLOSE_RANGE_UNSHARE, + ) + } != 0 + { + ready + .send(Err(std::io::Error::last_os_error().raw_os_error())) + .unwrap(); + return; + } + let private = File::open(path).unwrap(); + ready.send(Ok(())).unwrap(); + let _ = wait_release.recv(); + drop(private); + }); + struct Thread { + release: Option>, + thread: Option>, + } + impl Drop for Thread { + fn drop(&mut self) { + if let Some(tx) = self.release.take() { + let _ = tx.send(()); + } + if let Some(thread) = self.thread.take() { + thread.join().unwrap(); + } + } + } + let thread = Thread { + release: Some(release), + thread: Some(thread), + }; + assert_eq!( + wait_ready.recv().unwrap(), + Ok(()), + "fixture requires close_range private-files-table support" + ); + drop(file); + let budget = Budget::new( + fs::read_to_string("/proc/sys/kernel/random/boot_id") + .unwrap() + .trim() + .parse() + .unwrap(), + Duration::from_secs(5), + ) + .unwrap(); + let proc = Proc::open().unwrap(); + let process = proc.process(std::process::id()).unwrap(); + // Reproduces the incomplete TGID-only algorithm: no matching FD. + assert!( + inspect_fds(&process.directory, std::slice::from_ref(&target), &budget) + .unwrap() + .0 + .is_empty() + ); + // The real complete probe must still find the reader's task table. + let hits = process.inspect(&[target], &budget).unwrap(); + assert_eq!(hits.descriptors, [0]); + assert!(hits.mappings.is_empty()); + drop(thread); + } + #[test] + fn actual_proc_probe_detects_existing_descriptors_and_mapped_inode_without_exporting_paths() { + // An isolated network-none container process, not a host-wide scan, + // service/namespace qualification or admission-positive fixture. + assert_eq!(unsafe { libc::geteuid() }, 0); + let path = + std::path::Path::new("/run").join(format!("rmm-census-probe-{}", uuid::Uuid::new_v4())); + let file = OpenOptions::new() + .read(true) + .write(true) + .create_new(true) + .mode(0o600) + .open(&path) + .unwrap(); + file.set_len(4096).unwrap(); + struct Cleanup(std::path::PathBuf); + impl Drop for Cleanup { + fn drop(&mut self) { + fs::remove_file(&self.0).unwrap(); + } + } + let _cleanup = Cleanup(path); + let meta = file.metadata().unwrap(); + let target = Identity { + device: meta.dev(), + inode: meta.ino(), + uid: meta.uid(), + gid: meta.gid(), + mode: meta.mode(), + links: meta.nlink(), + }; + let budget = Budget::new( + fs::read_to_string("/proc/sys/kernel/random/boot_id") + .unwrap() + .trim() + .parse() + .unwrap(), + Duration::from_secs(5), + ) + .unwrap(); + let proc = Proc::open().unwrap(); + let process = proc.process(std::process::id()).unwrap(); + let before = process + .inspect(std::slice::from_ref(&target), &budget) + .unwrap(); + assert_eq!(before.descriptors, [0]); + assert!(before.mappings.is_empty()); + let pointer = unsafe { + libc::mmap( + std::ptr::null_mut(), + 4096, + libc::PROT_READ, + libc::MAP_PRIVATE, + file.as_raw_fd(), + 0, + ) + }; + assert_ne!(pointer, libc::MAP_FAILED); + struct Mapping(*mut libc::c_void); + impl Drop for Mapping { + fn drop(&mut self) { + assert_eq!(unsafe { libc::munmap(self.0, 4096) }, 0); + } + } + let _mapping = Mapping(pointer); + drop(file); + let mapped = process.inspect(&[target], &budget).unwrap(); + assert!(mapped.descriptors.is_empty()); + assert_eq!(mapped.mappings, [0]); + assert_eq!(before.stamp, mapped.stamp); + } +} diff --git a/crates/updater-worker/src/engine.rs b/crates/updater-worker/src/engine.rs index a6c67c3..90767ee 100644 --- a/crates/updater-worker/src/engine.rs +++ b/crates/updater-worker/src/engine.rs @@ -4,12 +4,13 @@ use crate::{ agent_startup::BoundAgentLock, bridge::{BridgeContext, FullBridge, Generation}, - bundle, + bundle, census, clock::NativeClock, fence::LedgerFence, ledger::{OwnedInputs, OwnedLedger}, original::Original, participants::{StableParticipant, verify_original_helper}, + reader_registry::QualifiedRegistry, retained::RetainedSet, returned, trust::TrustState, @@ -21,7 +22,7 @@ use rmm_agent_core::{ update_handoff::{NativeControlOperation, NativeEffect, NativeEffectClaim, NativeService}, }; use rmm_domain::{ - agent_update::{ParticipantIdentity, ParticipantRole, UpdateInflightProof}, + agent_update::{ParticipantIdentity, ParticipantRole}, agent_update_provisioning::{HealthKeyPin, InstalledReleaseRecord, LocalUpdatePolicy}, jobs::hash, }; @@ -75,6 +76,7 @@ impl Protected { pub struct Runtime { binding: Binding, policy: LocalUpdatePolicy, + registry: QualifiedRegistry, policy_sha256: String, installed: InstalledReleaseRecord, installed_sha256: String, @@ -91,12 +93,8 @@ pub struct Runtime { head: Option, } struct Queued { - agent_startup: BoundAgentLock, - original: Original, - witnesses: bundle::Loaded, - trust: TrustState, + header: bundle::Header, budget: Budget, - proof: UpdateInflightProof, } impl Runtime { pub fn new(binding: Binding) -> Result { @@ -117,6 +115,7 @@ impl Runtime { let installed = InstalledReleaseRecord::from_bytes(&raw).map_err(anyhow::Error::msg)?; let installed_sha256 = hash(&raw); let old_policies = service_policies(&policy, &installed, None)?; + let registry = QualifiedRegistry::load(&policy)?; let (health_file, raw) = Protected::read(&policy.health_pin_path, 4096)?; let health: HealthKeyPin = serde_json::from_slice(&raw)?; let health_key = health.public_key().map_err(anyhow::Error::msg)?; @@ -131,6 +130,7 @@ impl Runtime { Ok(Self { binding, policy, + registry, policy_sha256, installed, installed_sha256, @@ -150,7 +150,7 @@ impl Runtime { /// A lost activation reply disables this live runtime before any stop. /// Drive is deliberately private: it cannot run inside Engine::handle. pub fn serve_one(&mut self, listener: &ipc::Listener) -> Result<()> { - self.require_reader_registry_and_census()?; + self.registry.verify_protected()?; ensure!(!self.failed && !self.terminal, "UPDATE_ENGINE_CLOSED"); let services = Systemd::new(self.old_policies.clone())?; let budget = observation_budget()?; @@ -173,12 +173,6 @@ impl Runtime { } Ok(()) } - fn require_reader_registry_and_census(&self) -> Result<()> { - // This is an explicit source-checkpoint barrier, not a caller boolean - // or a known-unit-list substitute. Replace only with the real protected - // bootstrap registry + complete live FD/maps census and both locks. - anyhow::bail!("UPDATE_READER_CENSUS_NOT_CONFIGURED") - } fn enqueue( &mut self, peer: &ParticipantIdentity, @@ -216,17 +210,33 @@ impl Runtime { verify_original_helper(&services, &header.delegation, &budget)?; self.updater .verify_delegation(&header.delegation, &budget)?; - let mut bridge = FullBridge::original(BridgeContext { - handoff: &header.handoff, - delegation: &header.delegation, - services: &services, - updater: &self.updater, - clock: &self.clock, - budget: &budget, - health_public_key: self.health_key, - generation: Generation::Original, - })?; - let reply = bridge.call(NativeControlOperation::ReadOriginal)?; + // The original Full is still synchronously waiting for this reply. + // Do not recursively query its socket or ledger in the Activate handler. + self.queued = Some(Queued { header, budget }); + Ok(()) + } + fn drive(&mut self, queued: Queued) -> Result<()> { + let Queued { header, budget } = queued; + for file in &self.protected { + file.verify()?; + } + let services = Systemd::new(self.old_policies.clone())?; + verify_original_helper(&services, &header.delegation, &budget)?; + self.updater + .verify_delegation(&header.delegation, &budget)?; + let reply = { + let mut bridge = FullBridge::original(BridgeContext { + handoff: &header.handoff, + delegation: &header.delegation, + services: &services, + updater: &self.updater, + clock: &self.clock, + budget: &budget, + health_public_key: self.health_key, + generation: Generation::Original, + })?; + bridge.call(NativeControlOperation::ReadOriginal)? + }; let proof = reply.proof.context("UPDATE_ENGINE_ORIGINAL_PROOF")?; let original = Original::verify( &self.binding, @@ -256,32 +266,19 @@ impl Runtime { witnesses.retained.verify()?; let agent_startup = BoundAgentLock::bind(&witnesses.retained)?; self.head = Some(proof.head_sha256.clone()); - self.queued = Some(Queued { - agent_startup, - original, - witnesses, - trust, - budget, - proof, - }); - Ok(()) - } - fn drive(&mut self, queued: Queued) -> Result<()> { - let Queued { - agent_startup, - original, - witnesses, - trust, - budget, - proof, - } = queued; original.check_current(&self.binding, &self.clock, &budget)?; trust.recheck(&original, &self.clock)?; - let services = Systemd::new(self.old_policies.clone())?; - let old = [Service::Agent, Service::General, Service::Full] + self.registry.verify_admission(&self.policy, &budget)?; + let held = [Service::Agent, Service::General, Service::Full] .into_iter() - .map(|s| services.observe(s, &budget).map(|h| h.proof().clone())) + .map(|s| services.observe(s, &budget)) .collect::>>()?; + let known = vec![&held[0], &held[1], &held[2], self.updater.held_service()]; + let old = held.iter().map(|h| h.proof().clone()).collect::>(); + let targets = + census::Targets::bind(&witnesses.retained, &witnesses.ledger, &agent_startup)?; + let admission = + census::scan_admission(&targets, &known, self.registry.host_context(), &budget)?; let mut bridge = FullBridge::new( BridgeContext { handoff: original.handoff(), @@ -321,6 +318,10 @@ impl Runtime { updater: &self.updater, trust: &trust, retained: &witnesses.retained, + registry: &self.registry, + targets: &targets, + admission: &admission, + known: &known, claims, old, next: 0, @@ -331,8 +332,30 @@ impl Runtime { let claims = stop_fence.finish()?; let agent_startup = agent_startup.acquire(&stopped, &budget)?; let os = LedgerGuard::acquire(&stopped, &witnesses.ledger, &budget)?; + self.registry.verify_stopped(&self.policy, &budget)?; + let readers = census::scan_stopped( + &targets, + &admission, + &os, + &agent_startup, + &stopped, + self.updater.held_service(), + &budget, + )?; + let readers = readers.bind( + census::ClosureInputs { + targets: &targets, + root: &os, + agent: &agent_startup, + stopped: &stopped, + updater: self.updater.held_service(), + registry: &self.registry, + }, + &budget, + )?; let mut ledger = OwnedLedger::open(OwnedInputs { os: &os, + readers: &readers, original: &original, binding: &self.binding, clock: &self.clock, @@ -391,6 +414,9 @@ impl Runtime { return Err(error); } let prepared = ledger.prepare_return_and_close()?; + // The original DB is actually closed. End the continuous census/lock + // borrow before the same concrete guard can be consumed by Return. + drop(readers); let reservation = prepared.bind(returned::Inputs { original: &original, binding: &self.binding, @@ -490,6 +516,10 @@ struct StopFence<'a> { updater: &'a StableParticipant, trust: &'a TrustState, retained: &'a RetainedSet, + registry: &'a QualifiedRegistry, + targets: &'a census::Targets, + admission: &'a census::Admission, + known: &'a [&'a rmm_updater_linux::services::HeldService], claims: Vec, old: Vec, next: usize, @@ -503,6 +533,7 @@ impl StopFence<'_> { self.updater .verify_delegation(self.original.delegation(), self.budget)?; self.trust.recheck(self.original, self.clock)?; + self.registry.verify_protected()?; self.retained.verify() } fn finish(self) -> Result> { @@ -522,6 +553,10 @@ impl DurableEffectFence for StopFence<'_> { ); self.poisoned = true; self.current()?; + if self.next == 0 { + self.admission + .verify_fresh(self.targets, self.known, self.budget)?; + } let service = [Service::Agent, Service::General, Service::Full][self.next]; let native = [ NativeService::Agent, diff --git a/crates/updater-worker/src/ledger.rs b/crates/updater-worker/src/ledger.rs index ea31493..9400324 100644 --- a/crates/updater-worker/src/ledger.rs +++ b/crates/updater-worker/src/ledger.rs @@ -2,8 +2,9 @@ //! OS guard confirms every reader stopped. This module performs no bootstrap, //! consumption, schema reset, outcome healing or readiness transition. use crate::{ - clock::NativeClock, files::FileWitnesses, original::Original, participants::StableParticipant, - retained::RetainedSet, returned::PreparedReservation, trust::TrustState, + census::ClosedReaders, clock::NativeClock, files::FileWitnesses, original::Original, + participants::StableParticipant, retained::RetainedSet, returned::PreparedReservation, + trust::TrustState, }; use anyhow::{Result, ensure}; use rmm_agent_core::{ @@ -41,6 +42,7 @@ fn file_role(role: NativeFileRole) -> rmm_updater_handoff::FileRole { pub struct OwnedGuard<'a, 'stopped> { os: &'a LedgerGuard<'stopped>, + readers: &'a ClosedReaders<'a, 'stopped>, original: &'a Original, binding: &'a Binding, clock: &'a NativeClock, @@ -54,6 +56,7 @@ pub struct OwnedGuard<'a, 'stopped> { } pub struct OwnedInputs<'a, 'stopped> { pub os: &'a LedgerGuard<'stopped>, + pub readers: &'a ClosedReaders<'a, 'stopped>, pub original: &'a Original, pub binding: &'a Binding, pub clock: &'a NativeClock, @@ -70,6 +73,7 @@ pub struct OwnedLedger<'a, 'stopped> { } impl<'a, 'stopped> OwnedLedger<'a, 'stopped> { pub fn open(input: OwnedInputs<'a, 'stopped>) -> Result { + input.readers.verify(&observation_budget()?)?; input.os.verify_for_effect(&observation_budget()?)?; ensure!( input.os.identity().sha256()? == input.original.handoff().ledger_identity_sha256 @@ -92,6 +96,7 @@ impl<'a, 'stopped> OwnedLedger<'a, 'stopped> { input.files.bind(input.original.handoff())?; let guard = OwnedGuard { os: input.os, + readers: input.readers, original: input.original, binding: input.binding, clock: input.clock, @@ -290,6 +295,7 @@ impl<'a, 'stopped> OwnedLedger<'a, 'stopped> { impl ExecutorLedgerGuard for OwnedGuard<'_, '_> { fn check(&self, db: &Connection) -> Result<()> { let observation = observation_budget()?; + self.readers.verify(&observation)?; self.os.verify_for_effect(&observation)?; ensure!( unsafe { db.handle() } as usize == self.sqlite_handle, diff --git a/crates/updater-worker/src/lib.rs b/crates/updater-worker/src/lib.rs index 52a59d1..40a0cf8 100644 --- a/crates/updater-worker/src/lib.rs +++ b/crates/updater-worker/src/lib.rs @@ -4,6 +4,8 @@ pub mod agent_startup; pub mod bridge; pub mod bundle; +pub mod census; +mod census_process; pub mod clock; pub mod engine; pub mod fence; @@ -13,6 +15,7 @@ pub mod history; pub mod ledger; pub mod original; pub mod participants; +pub mod reader_registry; pub mod record; pub mod retained; pub mod returned; diff --git a/crates/updater-worker/src/participants.rs b/crates/updater-worker/src/participants.rs index 438aff5..cde921e 100644 --- a/crates/updater-worker/src/participants.rs +++ b/crates/updater-worker/src/participants.rs @@ -43,6 +43,9 @@ impl StableParticipant { ); Ok(()) } + pub fn held_service(&self) -> &HeldService { + &self.held + } pub fn identity(&self) -> &ParticipantIdentity { &self.identity } diff --git a/crates/updater-worker/src/reader_registry.rs b/crates/updater-worker/src/reader_registry.rs new file mode 100644 index 0000000..2d8d71c --- /dev/null +++ b/crates/updater-worker/src/reader_registry.rs @@ -0,0 +1,835 @@ +//! Protected compatible-reader registry plus read-only systemd closure. +//! This does not replace complete current task/FD/maps census, both real locks, +//! original authorization or live process/image proofs. No future-exec promise. +use crate::census::{HostContext, current_host_context}; +use anyhow::{Context, Result, ensure}; +use rmm_domain::{ + agent_update::digest, + agent_update_provisioning::{ActivationEvidence, LocalUpdatePolicy}, + jobs::hash, +}; +use rmm_updater_linux::{ + Budget, + files::{Directory, FileProof, HeldFile}, +}; +use serde::{Deserialize, Serialize}; +use std::{ + collections::{BTreeMap, BTreeSet}, + fs::Metadata, + io::Read, + os::{ + fd::{AsRawFd, FromRawFd}, + unix::fs::MetadataExt, + }, + path::{Path, PathBuf}, + process::{Child, Command, Stdio}, + sync::Mutex, + thread, + time::{Duration, Instant}, +}; + +pub const READER_CONTRACT: &[u8] = b"rmm.linux-shared-readers.v1\0root-helper:existing-executor.lock-before-sqlite-open-and-every-sql-or-effect-operation;agent:existing-agent.lock-before-both-agent-sqlite-opens-and-held-for-process-lifetime;all-allowed-readers:update-handoff-inflight-decoder-compatible;admission:protected-bootstrap-plus-current-complete-task-fd-maps-census-and-both-original-locks;scope:no-global-future-exec-absence-promise\n"; +pub fn reader_contract_sha256() -> String { + hash(READER_CONTRACT) +} +const REGISTRY: &str = "/etc/rmm-agent-updater/reader-registry.json"; +const MAX_BYTES: u64 = 65536; +const MAX_ROLLBACK: usize = 32; +const MAX_FILES: usize = 128; +const SERVICES: [&str; 7] = [ + "rmm-agent-remote.service", + "rmm-helper-cloud.service", + "rmm-full-maintenance-helper.service", + "rmm-agent-updater.service", + "rmm-apt-helper.service", + "rmm-agent.service", + "rmm-helper-dev-test.service", +]; +const ROLLBACK_PATTERN: &str = "rmm-general-startup-rollback-*.timer"; + +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct Registry { + schema_version: u32, + profile: String, + bootstrap_receipt_sha256: String, + reader_contract_sha256: String, + host_context: HostContext, + units: Vec, + rollback_timers: Vec, +} +#[derive(Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct Unit { + unit: String, + unit_file_state: String, + /// Exactly the Frozen OS unit_composition vector: fragment, then DropInPaths + /// in their actual order. FileProof includes original device/inode metadata. + composition: Vec<(String, FileProof)>, + triggers: Vec, + triggered_by: Vec, +} +#[derive(PartialEq, Eq)] +struct Stamp { + dev: u64, + ino: u64, + uid: u32, + gid: u32, + mode: u32, + links: u64, + bytes: u64, + mtime: i64, + mtime_ns: i64, + ctime: i64, + ctime_ns: i64, +} +impl Stamp { + fn read(path: &Path) -> Result { + let m = std::fs::symlink_metadata(path)?; + ensure!( + m.is_file() && !m.file_type().is_symlink(), + "UPDATE_REGISTRY_REGULAR_FILE" + ); + Ok(Self::of(&m)) + } + fn of(m: &Metadata) -> Self { + Self { + dev: m.dev(), + ino: m.ino(), + uid: m.uid(), + gid: m.gid(), + mode: m.mode(), + links: m.nlink(), + bytes: m.len(), + mtime: m.mtime(), + mtime_ns: m.mtime_nsec(), + ctime: m.ctime(), + ctime_ns: m.ctime_nsec(), + } + } +} +struct Protected { + directory: Directory, + file: Mutex, + path: PathBuf, + proof: FileProof, + stamp: Stamp, + raw: Vec, +} +impl Protected { + fn open(path: &Path) -> Result { + let before = Stamp::read(path)?; + let directory = + Directory::open(path.parent().context("UPDATE_REGISTRY_PARENT")?, 0, false)?; + let mut file = directory.inspect( + path.file_name().context("UPDATE_REGISTRY_FILENAME")?, + 0, + MAX_BYTES, + )?; + let raw = file.bytes(MAX_BYTES)?; + let proof = file.proof().clone(); + ensure!( + before == Stamp::read(path)? + && before.uid == 0 + && before.mode & 0o022 == 0 + && before.bytes == raw.len() as u64, + "UPDATE_REGISTRY_CHANGED_DURING_READ" + ); + let result = Self { + directory, + file: Mutex::new(file), + path: path.into(), + proof, + stamp: before, + raw, + }; + result.verify()?; + Ok(result) + } + fn verify(&self) -> Result<()> { + self.directory.verify()?; + ensure!( + Stamp::read(&self.path)? == self.stamp, + "UPDATE_REGISTRY_METADATA_CHANGED" + ); + let mut held = self + .file + .try_lock() + .map_err(|_| anyhow::anyhow!("UPDATE_REGISTRY_HELD_FILE_BUSY"))?; + held.verify(MAX_BYTES)?; + let mut named = self.directory.file( + self.path.file_name().context("UPDATE_REGISTRY_FILENAME")?, + &self.proof, + MAX_BYTES, + )?; + ensure!( + named.bytes(MAX_BYTES)? == self.raw && Stamp::read(&self.path)? == self.stamp, + "UPDATE_REGISTRY_ORIGINAL_RAW_CHANGED" + ); + Ok(()) + } +} + +/// Non-cloneable independently loaded original registry. No caller completeness +/// flag and no command/path selection is exposed by its public API. +pub struct QualifiedRegistry { + registry: Registry, + protected: Vec, + policy_sha256: String, +} +impl QualifiedRegistry { + pub fn load(policy: &LocalUpdatePolicy) -> Result { + ensure!( + policy.validate() && policy.registry_path == REGISTRY, + "UPDATE_READER_POLICY" + ); + let original = Protected::open(Path::new(REGISTRY))?; + ensure!( + original.proof.identity.links == 1 + && hash(&original.raw) == policy.reader_registry_sha256, + "UPDATE_READER_REGISTRY_PIN" + ); + let registry: Registry = serde_json::from_slice(&original.raw) + .map_err(|_| anyhow::anyhow!("UPDATE_READER_REGISTRY_CODEC"))?; + validate_registry(®istry, policy)?; + let mut protected = vec![original]; + let mut seen = BTreeMap::new(); + for unit in registry.units.iter().chain(®istry.rollback_timers) { + for (path, expected) in &unit.composition { + if let Some(existing) = seen.get(path) { + ensure!( + existing == expected, + "UPDATE_READER_SHARED_UNIT_PROOF_CONFLICT" + ); + continue; + } + ensure!(protected.len() <= MAX_FILES, "UPDATE_READER_FILE_LIMIT"); + let held = Protected::open(Path::new(path))?; + ensure!( + held.proof == *expected, + "UPDATE_READER_UNIT_ORIGINAL_CHANGED" + ); + seen.insert(path.clone(), expected.clone()); + protected.push(held); + } + } + let result = Self { + registry, + protected, + policy_sha256: hash(&serde_json::to_vec(policy)?), + }; + result.verify_protected()?; + Ok(result) + } + pub fn host_context(&self) -> &HostContext { + &self.registry.host_context + } + pub fn verify_protected(&self) -> Result<()> { + for file in &self.protected { + file.verify()?; + } + Ok(()) + } + pub fn verify_admission(&self, policy: &LocalUpdatePolicy, budget: &Budget) -> Result<()> { + self.verify_phase(policy, budget, false) + } + pub fn verify_stopped(&self, policy: &LocalUpdatePolicy, budget: &Budget) -> Result<()> { + self.verify_phase(policy, budget, true) + } + fn verify_phase( + &self, + policy: &LocalUpdatePolicy, + budget: &Budget, + stopped: bool, + ) -> Result<()> { + budget.check()?; + self.verify_protected()?; + ensure!( + hash(&serde_json::to_vec(policy)?) == self.policy_sha256, + "UPDATE_READER_POLICY_CHANGED" + ); + ensure!( + current_host_context()? == self.registry.host_context, + "UPDATE_READER_HOST_CONTEXT_CHANGED" + ); + let first_names = rollback_names(budget)?; + let allowed: BTreeSet<_> = self + .registry + .rollback_timers + .iter() + .map(|u| u.unit.as_str()) + .collect(); + ensure!( + first_names + .iter() + .all(|name| allowed.contains(name.as_str())), + "UPDATE_READER_UNKNOWN_ROLLBACK_TIMER" + ); + let mut first = BTreeMap::new(); + for (index, unit) in self.registry.units.iter().enumerate() { + let active = index < 4 && (!stopped || index == 3); + let status = observe(unit, budget)?; + status.verify(unit, active, index < 4)?; + first.insert(unit.unit.clone(), status); + } + for unit in &self.registry.rollback_timers { + let status = observe(unit, budget)?; + status.verify(unit, false, false)?; + first.insert(unit.unit.clone(), status); + } + // Structural trigger names are not an assertion that a source is live. + // Every exact registered relevant source is independently closed below. + for unit in self + .registry + .units + .iter() + .chain(&self.registry.rollback_timers) + { + if !unit.triggers.is_empty() { + ensure!( + first[&unit.unit].closed(), + "UPDATE_READER_ACTIVATION_SOURCE_OPEN" + ); + } + for name in &unit.triggered_by { + ensure!( + first.get(name).is_some_and(|source| source.closed()), + "UPDATE_READER_ACTIVATION_PATH_OPEN" + ); + } + } + ensure!( + rollback_names(budget)? == first_names, + "UPDATE_READER_ROLLBACK_TIMER_SET_CHANGED" + ); + self.verify_protected()?; + for unit in self + .registry + .units + .iter() + .chain(&self.registry.rollback_timers) + { + ensure!( + observe(unit, budget)? == first[&unit.unit], + "UPDATE_READER_STATUS_CHANGED" + ); + } + ensure!( + current_host_context()? == self.registry.host_context, + "UPDATE_READER_HOST_CONTEXT_CHANGED" + ); + self.verify_protected()?; + budget.check() + } +} +fn fixed_units() -> Vec { + let mut names = SERVICES.iter().map(|s| s.to_string()).collect::>(); + for name in SERVICES { + let base = name.strip_suffix(".service").expect("fixed service"); + for suffix in ["socket", "timer"] { + names.push(format!("{base}.{suffix}")); + } + } + names +} +fn rollback(name: &str) -> bool { + let Some(value) = name + .strip_prefix("rmm-general-startup-rollback-") + .and_then(|s| s.strip_suffix(".timer")) + else { + return false; + }; + uuid::Uuid::parse_str(value) + .is_ok_and(|id| id.get_version_num() == 4 && id.to_string() == value) +} +fn validate_registry(registry: &Registry, policy: &LocalUpdatePolicy) -> Result<()> { + ensure!( + registry.schema_version == 1 + && registry.profile == "linux_shared_readers_v1" + && registry.reader_contract_sha256 == reader_contract_sha256(), + "UPDATE_READER_REGISTRY_PROFILE" + ); + let baseline = policy + .initial_baseline + .decode() + .map_err(anyhow::Error::msg)?; + let ActivationEvidence::Bootstrap { + qualification_receipt_sha256, + } = baseline.record.activation_evidence + else { + anyhow::bail!("UPDATE_READER_INITIAL_BOOTSTRAP_REQUIRED"); + }; + ensure!( + digest(®istry.bootstrap_receipt_sha256) + && registry.bootstrap_receipt_sha256 == qualification_receipt_sha256, + "UPDATE_READER_BOOTSTRAP_RECEIPT" + ); + let host = ®istry.host_context; + ensure!( + [ + host.proc_inode, + host.user_namespace_inode, + host.pid_namespace_inode, + host.cgroup_namespace_inode + ] + .iter() + .all(|n| *n > 0), + "UPDATE_READER_HOST_CONTEXT_SHAPE" + ); + ensure!( + registry + .units + .iter() + .map(|u| u.unit.clone()) + .eq(fixed_units()) + && registry.rollback_timers.len() <= MAX_ROLLBACK, + "UPDATE_READER_CLOSED_UNIT_SET" + ); + let mut all: BTreeSet = fixed_units().into_iter().collect(); + let mut previous = None; + for unit in ®istry.rollback_timers { + ensure!( + rollback(&unit.unit) + && previous + .as_ref() + .is_none_or(|old: &String| old < &unit.unit) + && all.insert(unit.unit.clone()), + "UPDATE_READER_ROLLBACK_NAMES" + ); + previous = Some(unit.unit.clone()); + } + let mut total = 0; + for (index, unit) in registry + .units + .iter() + .chain(®istry.rollback_timers) + .enumerate() + { + let active = index < 4; + ensure!( + unit.composition.len() <= 17 + && ((!unit.composition.is_empty() + && if active { + matches!(unit.unit_file_state.as_str(), "enabled" | "disabled") + } else { + unit.unit_file_state == "disabled" + }) + || (!active && unit.composition.is_empty() && unit.unit_file_state.is_empty())), + "UPDATE_READER_UNIT_STATE_SHAPE" + ); + let mut paths = BTreeSet::new(); + for (position, (path, proof)) in unit.composition.iter().enumerate() { + let filename = Path::new(path).file_name().and_then(|name| name.to_str()); + ensure!( + if position == 0 { + filename == Some(unit.unit.as_str()) + } else { + filename.is_some_and(|name| name.ends_with(".conf")) + }, + "UPDATE_READER_UNIT_LEAF_NAME" + ); + ensure!( + unit_path(path) + && paths.insert(path) + && proof.identity.uid == 0 + && proof.identity.inode > 0 + && proof.identity.links > 0 + && proof.identity.mode & libc::S_IFMT == libc::S_IFREG + && proof.identity.mode & 0o022 == 0 + && proof.bytes <= MAX_BYTES + && digest(&proof.sha256), + "UPDATE_READER_UNIT_PROOF_SHAPE" + ); + total += 1; + } + for names in [&unit.triggers, &unit.triggered_by] { + ensure!( + names.len() <= 32 + && names.windows(2).all(|pair| pair[0] < pair[1]) + && names.iter().all(|name| all.contains(name)), + "UPDATE_READER_UNKNOWN_ACTIVATION_RELATION" + ); + } + if unit.composition.is_empty() { + ensure!( + unit.triggers.is_empty() && unit.triggered_by.is_empty(), + "UPDATE_READER_ABSENT_RELATIONS" + ); + } + let pin = if index < 3 { + Some(&policy.services[index]) + } else if index == 3 { + Some(&policy.updater_service) + } else if index == 4 { + policy.services.get(3) + } else { + None + }; + if let Some(pin) = pin { + ensure!( + pin.unit == unit.unit + && !unit.composition.is_empty() + && hash(&serde_json::to_vec(&unit.composition)?) == pin.unit_sha256, + "UPDATE_READER_POLICY_UNIT_COMPOSITION" + ); + } + if index == 4 && policy.services.len() == 3 { + ensure!( + unit.composition.is_empty(), + "UPDATE_READER_APT_NOT_IN_POLICY" + ); + } + } + ensure!(total <= MAX_FILES, "UPDATE_READER_FILE_LIMIT"); + Ok(()) +} +fn unit_path(value: &str) -> bool { + value.len() <= 4096 + && value.starts_with('/') + && value + .split('/') + .skip(1) + .all(|part| !part.is_empty() && part != "." && part != "..") + && value.bytes().all(|b| b.is_ascii_graphic() && b != b'\\') + && [ + "/etc/systemd/system/", + "/usr/lib/systemd/system/", + "/lib/systemd/system/", + "/run/systemd/system/", + "/run/systemd/transient/", + ] + .iter() + .any(|root| value.starts_with(root)) +} + +#[derive(Clone, Debug, PartialEq, Eq)] +struct Status { + fields: BTreeMap, + main_pid: Option, + control_pid: Option, + connections: Option, +} +const GENERIC: [&str; 11] = [ + "Id", + "LoadState", + "ActiveState", + "SubState", + "InvocationID", + "UnitFileState", + "FragmentPath", + "DropInPaths", + "Triggers", + "TriggeredBy", + "Job", +]; +impl Status { + fn parse(unit: &str, raw: &[u8]) -> Result { + ensure!( + raw.len() <= 16384 && raw.is_ascii(), + "UPDATE_READER_STATUS_LIMIT" + ); + let text = + std::str::from_utf8(raw).map_err(|_| anyhow::anyhow!("UPDATE_READER_STATUS_CODEC"))?; + let mut fields: BTreeMap = BTreeMap::new(); + let mut permitted = GENERIC.to_vec(); + if unit.ends_with(".service") { + permitted.extend(["MainPID", "ControlPID"]); + } else if unit.ends_with(".socket") { + permitted.extend(["ControlPID", "NConnections"]); + } + for line in text.lines() { + let (key, value) = line.split_once('=').context("UPDATE_READER_STATUS_CODEC")?; + ensure!( + permitted.contains(&key) && fields.insert(key.into(), value.into()).is_none(), + "UPDATE_READER_STATUS_FIELDS" + ); + } + ensure!( + GENERIC.iter().all(|key| fields.contains_key(*key)) && fields["Id"] == unit, + "UPDATE_READER_STATUS_INCOMPLETE" + ); + let loaded = fields["LoadState"] == "loaded"; + let number = |key: &str, required: bool| -> Result> { + match fields.get(key) { + Some(value) => { + ensure!( + !value.is_empty() && value.bytes().all(|b| b.is_ascii_digit()), + "UPDATE_READER_PID_CODEC" + ); + Ok(Some( + value + .parse() + .map_err(|_| anyhow::anyhow!("UPDATE_READER_PID_RANGE"))?, + )) + } + None => { + ensure!(!required, "UPDATE_READER_MISSING_PID_PROPERTY"); + Ok(None) + } + } + }; + let main_pid = number("MainPID", loaded && unit.ends_with(".service"))?; + let control_pid = number("ControlPID", loaded && !unit.ends_with(".timer"))?; + let connections = number("NConnections", loaded && unit.ends_with(".socket"))?; + Ok(Self { + fields, + main_pid, + control_pid, + connections, + }) + } + fn closed(&self) -> bool { + self.fields["ActiveState"] == "inactive" + && self.fields["SubState"] == "dead" + && self.main_pid.is_none_or(|n| n == 0) + && self.control_pid.is_none_or(|n| n == 0) + && self.connections.is_none_or(|n| n == 0) + && self.fields["Job"].is_empty() + } + fn verify(&self, unit: &Unit, active: bool, original_reader: bool) -> Result<()> { + let fields = &self.fields; + ensure!( + fields["UnitFileState"] == unit.unit_file_state + && relations(&fields["Triggers"])? == unit.triggers + && relations(&fields["TriggeredBy"])? == unit.triggered_by, + "UPDATE_READER_UNIT_RELATIONS_CHANGED" + ); + if unit.composition.is_empty() { + ensure!( + !active + && fields["LoadState"] == "not-found" + && fields["FragmentPath"].is_empty() + && fields["DropInPaths"].is_empty() + && self.closed(), + "UPDATE_READER_ABSENT_UNIT_CHANGED" + ); + } else { + ensure!( + fields["LoadState"] == "loaded", + "UPDATE_READER_UNIT_NOT_LOADED" + ); + let mut paths = vec![fields["FragmentPath"].as_str()]; + paths.extend(fields["DropInPaths"].split_ascii_whitespace()); + ensure!( + paths + .iter() + .copied() + .eq(unit.composition.iter().map(|(path, _)| path.as_str())), + "UPDATE_READER_UNIT_COMPOSITION_CHANGED" + ); + if active { + ensure!( + fields["ActiveState"] == "active" + && fields["SubState"] == "running" + && self.main_pid.is_some_and(|pid| pid > 1) + && self.control_pid == Some(0) + && fields["Job"].is_empty() + && fields["InvocationID"].len() == 32 + && fields["InvocationID"] + .bytes() + .all(|b| b.is_ascii_hexdigit()) + && fields["InvocationID"].bytes().any(|b| b != b'0'), + "UPDATE_READER_ACTIVE_REQUIRED" + ); + } else { + ensure!( + (original_reader || unit.unit_file_state == "disabled") && self.closed(), + "UPDATE_READER_UNIT_NOT_CLOSED" + ); + } + } + Ok(()) + } +} +fn relations(value: &str) -> Result> { + let mut names = value + .split_ascii_whitespace() + .map(str::to_owned) + .collect::>(); + ensure!(names.len() <= 32, "UPDATE_READER_RELATION_LIMIT"); + names.sort(); + ensure!( + names.windows(2).all(|pair| pair[0] < pair[1]), + "UPDATE_READER_DUPLICATE_RELATION" + ); + Ok(names) +} +fn observe(unit: &Unit, budget: &Budget) -> Result { + let mut properties = GENERIC.to_vec(); + if unit.unit.ends_with(".service") { + properties.extend(["MainPID", "ControlPID"]); + } else if unit.unit.ends_with(".socket") { + properties.extend(["ControlPID", "NConnections"]); + } + let property = format!("--property={}", properties.join(",")); + let raw = command(&["show", "--all", &property, "--", &unit.unit], budget)?; + Status::parse(&unit.unit, &raw) +} +fn rollback_names(budget: &Budget) -> Result> { + let mut names = BTreeSet::new(); + for args in [ + vec![ + "list-units", + "--all", + "--plain", + "--no-legend", + "--type=timer", + "--", + ROLLBACK_PATTERN, + ], + vec!["list-unit-files", "--no-legend", "--", ROLLBACK_PATTERN], + ] { + let raw = command(&args, budget)?; + ensure!(raw.is_ascii(), "UPDATE_READER_TIMER_LIST_CODEC"); + for line in std::str::from_utf8(&raw) + .map_err(|_| anyhow::anyhow!("UPDATE_READER_TIMER_LIST_CODEC"))? + .lines() + { + let name = line + .split_ascii_whitespace() + .next() + .context("UPDATE_READER_TIMER_LIST_CODEC")?; + ensure!( + rollback(name) && names.len() < MAX_ROLLBACK + 1, + "UPDATE_READER_TIMER_LIST_LIMIT" + ); + names.insert(name.to_owned()); + } + } + Ok(names) +} +struct OwnedCommand { + child: Child, + pidfd: std::fs::File, +} +impl Drop for OwnedCommand { + fn drop(&mut self) { + unsafe { + libc::syscall( + libc::SYS_pidfd_send_signal, + self.pidfd.as_raw_fd(), + libc::SIGKILL, + 0usize, + 0, + ) + }; + let _ = self.child.wait(); + } +} +fn drain(stream: &mut dyn Read, raw: &mut Vec) -> Result<()> { + let mut chunk = [0; 1024]; + loop { + match stream.read(&mut chunk) { + Ok(0) => break, + Ok(count) => { + ensure!( + raw.len() + count <= 16384, + "UPDATE_READER_COMMAND_OUTPUT_LIMIT" + ); + raw.extend_from_slice(&chunk[..count]); + } + Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => break, + Err(_) => anyhow::bail!("UPDATE_READER_COMMAND_READ"), + } + } + Ok(()) +} +fn command(args: &[&str], budget: &Budget) -> Result> { + budget.check()?; + let child = Command::new("/usr/bin/systemctl") + .args(["--system", "--no-ask-password", "--no-pager", "--full"]) + .args(args) + .env_clear() + .env("PATH", "/usr/bin:/bin") + .env("LC_ALL", "C") + .env("SYSTEMD_COLORS", "0") + .stdin(Stdio::null()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .map_err(|_| anyhow::anyhow!("UPDATE_READER_COMMAND_SPAWN"))?; + let mut child = child; + let pid = unsafe { libc::syscall(libc::SYS_pidfd_open, child.id(), 0) }; + if pid < 0 { + let _ = child.kill(); + let _ = child.wait(); + anyhow::bail!("UPDATE_READER_COMMAND_PIDFD"); + } + let mut owned = OwnedCommand { + child, + pidfd: unsafe { std::fs::File::from_raw_fd(pid as i32) }, + }; + let mut stdout = owned.child.stdout.take().context("UPDATE_READER_STDOUT")?; + let mut stderr = owned.child.stderr.take().context("UPDATE_READER_STDERR")?; + for fd in [stdout.as_raw_fd(), stderr.as_raw_fd()] { + ensure!( + unsafe { libc::fcntl(fd, libc::F_SETFL, libc::O_NONBLOCK) } >= 0, + "UPDATE_READER_COMMAND_NONBLOCK" + ); + } + let started = Instant::now(); + let mut out = Vec::new(); + let mut error = Vec::new(); + loop { + budget.check()?; + ensure!( + started.elapsed() < Duration::from_secs(10), + "UPDATE_READER_COMMAND_TIMEOUT" + ); + drain(&mut stdout, &mut out)?; + drain(&mut stderr, &mut error)?; + if let Some(status) = owned + .child + .try_wait() + .map_err(|_| anyhow::anyhow!("UPDATE_READER_COMMAND_WAIT"))? + { + drain(&mut stdout, &mut out)?; + drain(&mut stderr, &mut error)?; + ensure!( + status.success() && error.is_empty(), + "UPDATE_READER_SYSTEMD_FAILED" + ); + budget.check()?; + return Ok(out); + } + thread::sleep(Duration::from_millis(2)); + } +} + +#[cfg(test)] +mod tests { + use super::*; + fn timer() -> Vec { + b"Id=rmm-agent-remote.timer\nLoadState=loaded\nActiveState=inactive\nSubState=dead\nInvocationID=\nUnitFileState=disabled\nFragmentPath=/etc/systemd/system/rmm-agent-remote.timer\nDropInPaths=\nTriggers=rmm-agent-remote.service\nTriggeredBy=\nJob=\n".to_vec() + } + #[test] + fn timer_without_process_interface_is_typed_but_missing_service_pid_or_pending_job_denies() { + let raw = timer(); + let status = Status::parse("rmm-agent-remote.timer", &raw).unwrap(); + assert_eq!(status.main_pid, None); + assert_eq!(status.control_pid, None); + assert!(status.closed()); + let pending = String::from_utf8(raw.clone()) + .unwrap() + .replace("Job=\n", "Job=123\n"); + assert!( + !Status::parse("rmm-agent-remote.timer", pending.as_bytes()) + .unwrap() + .closed() + ); + let service = String::from_utf8(raw.clone()) + .unwrap() + .replace("rmm-agent-remote.timer", "rmm-agent-remote.service"); + assert!(Status::parse("rmm-agent-remote.service", service.as_bytes()).is_err()); + let mut unknown = raw.clone(); + unknown.extend_from_slice(b"MainPID=0\n"); + assert!(Status::parse("rmm-agent-remote.timer", &unknown).is_err()); + let mut duplicate = raw; + duplicate.extend_from_slice(b"Job=\n"); + assert!(Status::parse("rmm-agent-remote.timer", &duplicate).is_err()); + assert!(rollback( + "rmm-general-startup-rollback-11111111-1111-4111-8111-111111111111.timer" + )); + assert!(!rollback("rmm-general-startup-rollback-*.timer")); + } +} diff --git a/crates/updater-worker/src/trust.rs b/crates/updater-worker/src/trust.rs index ae0531f..cc15a57 100644 --- a/crates/updater-worker/src/trust.rs +++ b/crates/updater-worker/src/trust.rs @@ -89,6 +89,12 @@ impl TrustState { "UPDATE_PROTECTED_POLICY_CHANGED" ); protected.push(file); + let (file, raw) = Protected::read(Path::new(&policy.registry_path), 65536)?; + ensure!( + hash(&raw) == policy.reader_registry_sha256, + "UPDATE_PROTECTED_READER_REGISTRY_CHANGED" + ); + protected.push(file); let (file, raw) = Protected::read(Path::new(&policy.keyring_path), 16384)?; let keys: UpdateKeyringFile = serde_json::from_slice(&raw)?; ensure!( diff --git a/deploy/updater_reader_census_linux_acceptance.py b/deploy/updater_reader_census_linux_acceptance.py new file mode 100644 index 0000000..f430891 --- /dev/null +++ b/deploy/updater_reader_census_linux_acceptance.py @@ -0,0 +1,334 @@ +#!/usr/bin/env python3 +"""Frozen ten-worker list, executing exactly two process-census guards only; no Apply. + +Prepare copies the independently reviewed snapshot locally. Execute is one +root-only Cloud-VM fixture run. After any lost reply read the original case; +never execute it again or substitute another binary/source generation. +""" +import argparse +import base64 +import hashlib +import inspect +import json +import os +from pathlib import Path +import stat +import uuid + +import windows_msi_runtime_acceptance as support + +ROOT = Path(__file__).resolve().parents[1] +ACCESS_ROOT = ROOT.parent / 'rust-discovery' +QUALIFICATION = ROOT / 'devstate/agent-updater-worker/reader-census-final-da31051b-269f-4fb5-947d-94c8ad162c2a' +STATE = ROOT / 'devstate/updater-reader-census-linux' +PROFILE = 'rmm.updater.two-process-census-guards.v1' +RECEIPT_SHA = '9020992e888d0b22e71db88cab78f255e273be2a4a7856d43616b387c36c74ae' +INPUTS_SHA = '382714b09349e448441345abbac6d99c0d523e98bdabaa78290b400768bac8f7' +BINARY_SHA = 'e83fd334b005d81ac917389de2a1c7486bea3f62ae45d77bccbd331e131e4304' +BINARY_BYTES = 7888096 +CENSUS_SOURCES = {'crates/updater-worker/src/census.rs': {'bytes': 17766, 'sha256': '5bee7f835c3b3c1f7e3a6afeeb1dc1fde780f1a6ca0d09a1bc85d897249e053c'}, 'crates/updater-worker/src/census_process.rs': {'bytes': 25024, 'sha256': 'f94b3032cee983fb01bfeb97a1cfc497fddcfd1e6f00e055d87269cc3f5dad5e'}, 'crates/updater-worker/src/reader_registry.rs': {'bytes': 29064, 'sha256': 'fc013cde406f4dac96a35df3852738b0ff84d912c4eeba401609b0d2b239d1b1'}} +ALL_TESTS = ['agent_startup::tests::existing_agent_lock_blocks_aliases_and_rejects_samebyte_inode_substitution', 'census_process::tests::actual_proc_probe_detects_existing_descriptors_and_mapped_inode_without_exporting_paths', 'census_process::tests::private_thread_fd_table_cannot_hide_a_reader_from_the_group_probe', 'history::tests::completed_history_rejects_file_only_rollback_forks_and_tampered_activation_without_writes', 'history::tests::public_record_builder_binds_actual_original_key_and_exact_health_head', 'reader_registry::tests::timer_without_process_interface_is_typed_but_missing_service_pid_or_pending_job_denies', 'record::tests::same_byte_inode_substitution_and_foreign_current_block_without_resume', 'record::tests::separate_record_renames_preserve_original_inode_and_both_raw_archives', 'retained::tests::reopen_preserves_original_stamps_and_rejects_replaced_state_without_reading_keys', 'trust::tests::separately_signed_baseline_at_floor_is_historical_only_and_candidate_stays_strict'] +TESTS = ['census_process::tests::actual_proc_probe_detects_existing_descriptors_and_mapped_inode_without_exporting_paths', 'census_process::tests::private_thread_fd_table_cannot_hide_a_reader_from_the_group_probe'] +TEST_FILTER = 'census_process::tests::' +AGENT_SHA = '0a7ad6eefaefda79ee80b6a41b2df904e9e7f50ae6ebeed01b98c25b6ce5c06f' +HELPER_SHA = '79442727c3ba31cda02a8bc0e67481f14db9f39fc07520a880a90b64f10f1eaf' + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def save_local(path, value): + support.save(path, value) + fd = os.open(path.parent, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW) + try: + os.fsync(fd) + finally: + os.close(fd) + + +def copy_exact(source, destination, digest, size): + metadata = source.lstat() + support.require(stat.S_ISREG(metadata.st_mode) and metadata.st_nlink == 1 + and metadata.st_uid in (0, os.getuid()) and not metadata.st_mode & 0o002 + and metadata.st_size == size and size <= 8 * 1024 * 1024, 'bounded regular frozen input') + raw = source.read_bytes() + support.require(sha(raw) == digest, 'frozen snapshot input hash') + destination.parent.mkdir(mode=0o700, parents=True, exist_ok=True) + support.private(destination.parent, True) + fd = os.open(destination, os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW | os.O_WRONLY, 0o600) + with os.fdopen(fd, 'wb') as stream: + stream.write(raw); stream.flush(); os.fsync(stream.fileno()) + fd = os.open(destination.parent, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW) + try: + os.fsync(fd) + finally: + os.close(fd) + + +def verify_case(folder): + value = support.load(folder / 'manifest.json') + support.require(value['profile'] == PROFILE and value['tests'] == TESTS and value['all_tests'] == ALL_TESTS + and value['test_filter'] == TEST_FILTER + and value['runner_sha256'] == sha(Path(__file__).read_bytes()) + and value['receipt_sha256'] == RECEIPT_SHA and value['binary_sha256'] == BINARY_SHA + and value['binary_bytes'] == BINARY_BYTES, 'same original reviewed manifest') + support.require(sha((folder / 'receipt.json').read_bytes()) == RECEIPT_SHA + and sha((folder / 'inputs.json').read_bytes()) == INPUTS_SHA, 'original qualification provenance') + source = support.load(folder / 'inputs.json') + support.require(len(source) == 71 and source == value['source_files'], 'exact frozen 71 qualification inputs') + for item in source: + path = Path(item['path']) + support.require(not path.is_absolute() and '..' not in path.parts, 'fixed snapshot relative path') + file = folder / 'source' / path + support.private(file) + support.require(file.stat().st_size == item['bytes'] and sha(file.read_bytes()) == item['sha256'], 'retained source freeze') + support.require({item['path']: dict(bytes=item['bytes'], sha256=item['sha256']) for item in source + if item['path'] in CENSUS_SOURCES} == CENSUS_SOURCES, 'exact census and registry source snapshot') + binary = folder / 'worker-census-tests'; support.private(binary) + support.require(binary.stat().st_size == BINARY_BYTES and sha(binary.read_bytes()) == BINARY_SHA, 'original qualified test bytes') + for path, digest in value['transport_sources'].items(): + support.require(sha((ROOT / path).read_bytes()) == digest, 'original strict transport source') + return value + + +def remote(p): + import base64 + import hashlib + import json + import os + from pathlib import Path + import selectors + import signal + import stat + import subprocess + import time + import uuid + + def require(ok, message): + if not ok: + raise RuntimeError(message) + + def enc(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + def create(path, raw, mode=0o600): + fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, mode) + with os.fdopen(fd, 'wb') as stream: + stream.write(raw); stream.flush(); os.fsync(stream.fileno()) + fd = os.open(path.parent, os.O_DIRECTORY | os.O_RDONLY | os.O_NOFOLLOW) + try: + os.fsync(fd) + finally: + os.close(fd) + + def run(args, timeout=20): + # Keep the owned group leader unreaped until its entire group has been + # cleaned up. Its PID therefore cannot be recycled before killpg. + child = subprocess.Popen(args, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, + stderr=subprocess.PIPE, start_new_session=True, + env={'PATH': '/usr/bin:/bin', 'LC_ALL': 'C', 'HOME': '/nonexistent'}) + selector = selectors.DefaultSelector() + buffers = {'stdout': bytearray(), 'stderr': bytearray()} + deadline = time.monotonic() + timeout + try: + for stream, name in ((child.stdout, 'stdout'), (child.stderr, 'stderr')): + os.set_blocking(stream.fileno(), False); selector.register(stream, selectors.EVENT_READ, name) + while True: + require(time.monotonic() < deadline, 'owned native command timeout; read original case only') + for key, _ in selector.select(0.02): + raw = os.read(key.fileobj.fileno(), 4096) + if raw: + buffers[key.data].extend(raw) + require(len(buffers[key.data]) <= 65536, 'bounded native output') + else: + selector.unregister(key.fileobj) + ended = os.waitid(os.P_PID, child.pid, os.WEXITED | os.WNOHANG | os.WNOWAIT) + if ended is not None: + # Child remains a zombie until finally: no PID/group reuse. + os.killpg(child.pid, signal.SIGKILL) + for key in list(selector.get_map().values()): + while True: + try: + raw = os.read(key.fileobj.fileno(), 4096) + except BlockingIOError: + break + if not raw: + break + buffers[key.data].extend(raw) + require(len(buffers[key.data]) <= 65536, 'bounded native output') + code = ended.si_status if ended.si_code == os.CLD_EXITED else -ended.si_status + return code, bytes(buffers['stdout']), bytes(buffers['stderr']) + finally: + os.killpg(child.pid, signal.SIGKILL) + child.wait() + selector.close(); child.stdout.close(); child.stderr.close() + + def metadata_identity(value): + return (value.st_dev, value.st_ino, value.st_uid, value.st_gid, value.st_mode, + value.st_nlink, value.st_size, value.st_mtime_ns, value.st_ctime_ns) + + def hashed(path, maximum, process_image=False): + fd = os.open(path, os.O_RDONLY | os.O_CLOEXEC | (0 if process_image else os.O_NOFOLLOW)) + with os.fdopen(fd, 'rb') as stream: + before = os.fstat(stream.fileno()); require(stat.S_ISREG(before.st_mode) and before.st_size <= maximum, 'bounded witness file') + digest = hashlib.sha256(); total = 0 + while True: + raw = stream.read(32768) + if not raw: + break + total += len(raw); require(total <= maximum, 'bounded witness hash'); digest.update(raw) + after = os.fstat(stream.fileno()) + require(metadata_identity(before) == metadata_identity(after) and total == before.st_size, 'stable witness hash') + return before, digest.hexdigest() + + def witness(): + out = {'boot_id': Path('/proc/sys/kernel/random/boot_id').read_text().strip(), 'services': {}, 'files': {}} + release = dict(line.split('=', 1) for line in Path('/etc/os-release').read_text().splitlines() if '=' in line) + require(release.get('ID', '').strip('"') == 'ubuntu' and release.get('VERSION_ID', '').strip('"') == '24.04', 'fixed native Ubuntu24.04') + out['os'] = {'id': 'ubuntu', 'version': '24.04', 'machine': os.uname().machine, 'kernel': os.uname().release} + for name, uid, binary in ( + ('rmm-agent-remote.service', 993, p['agent_sha256']), + ('rmm-helper-cloud.service', 0, p['helper_sha256']), + ('rmm-full-maintenance-helper.service', 0, p['helper_sha256'])): + code, stdout, _ = run(['/usr/bin/systemctl', 'show', name, '-p', 'ActiveState', '-p', 'MainPID', '-p', 'UnitFileState', '-p', 'InvocationID']) + require(code == 0, 'existing service read') + service = dict(line.split('=', 1) for line in stdout.decode().splitlines()) + pid = int(service['MainPID']); require(service['ActiveState'] == 'active' and pid > 1, 'three existing services active') + proc = Path('/proc', str(pid)); birth = (proc / 'stat').read_text().rsplit(') ', 1)[1].split()[19] + ids = {line.split(':')[0]: line.split()[1:] for line in (proc / 'status').read_text().splitlines() if line.startswith(('Uid:', 'Gid:'))} + metadata, image = hashed(proc / 'exe', 256 * 1024 * 1024, process_image=True) + current = (proc / 'exe').stat() + require(ids['Uid'] == [str(uid)] * 4 and ids['Gid'] == ['984'] * 4 and image == binary + and (metadata.st_dev, metadata.st_ino) == (current.st_dev, current.st_ino) + and (proc / 'stat').read_text().rsplit(') ', 1)[1].split()[19] == birth, 'current generation/account/image') + out['services'][name] = dict(service, birth=birth, image=image, ids=ids) + code, stdout, _ = run(['/usr/bin/systemctl', 'show', 'rmm-apt-helper.service', '-p', 'ActiveState', '-p', 'UnitFileState']) + apt = dict(line.split('=', 1) for line in stdout.decode().splitlines()) + require(code == 0 and apt == {'ActiveState': 'inactive', 'UnitFileState': 'disabled'}, 'APT remains closed') + out['apt'] = apt + for name in ('/etc/rmm-remote/helper-general.json', '/etc/rmm-remote/helper-full-maintenance.json', + '/etc/rmm-remote/full-maintenance-helper-proof.json', '/etc/systemd/system/rmm-full-maintenance-helper.service'): + path = Path(name); metadata = path.lstat() + require(not path.is_symlink() and stat.S_ISREG(metadata.st_mode) and metadata.st_uid == 0 + and not metadata.st_mode & 0o022 and metadata.st_nlink == 1, 'protected known control') + current, digest = hashed(path, 65536) + require(metadata_identity(current) == metadata_identity(metadata), 'same known control file') + out['files'][name] = [metadata.st_dev, metadata.st_ino, metadata.st_uid, metadata.st_gid, metadata.st_mode, + metadata.st_size, metadata.st_mtime_ns, metadata.st_ctime_ns, digest] + for name in ('/var/lib/rmm-helper/consumption.sqlite', '/var/lib/rmm-helper/executor.lock', + '/var/lib/rmm-agent-remote/journal.sqlite', '/var/lib/rmm-agent-remote/consumption.sqlite', + '/var/lib/rmm-agent-remote/agent.lock'): + path = Path(name); metadata = path.lstat() + require(not path.is_symlink() and stat.S_ISREG(metadata.st_mode) and metadata.st_nlink == 1, 'existing state identity') + out['files'][name] = [metadata.st_dev, metadata.st_ino, metadata.st_uid, metadata.st_gid, metadata.st_mode] + return out + + require(os.geteuid() == 0 and os.uname().machine == 'x86_64', 'fixed Cloud Linux root process-census fixtures') + require(p['profile'] == 'rmm.updater.two-process-census-guards.v1' + and p['binary_sha256'] == 'e83fd334b005d81ac917389de2a1c7486bea3f62ae45d77bccbd331e131e4304' + and p['test_filter'] == 'census_process::tests::' + and len(p['all_tests']) == 10 and len(p['tests']) == 2 + and [name for name in p['all_tests'] if name.startswith(p['test_filter'])] == p['tests'], + 'closed two-test census scope before remote case creation') + ident = str(uuid.UUID(p['id'])); require(ident == p['id'], 'canonical original case') + folder = Path('/var/tmp') / ('rmm-updater-reader-census-linux-' + ident) + if p['action'] == 'read': + metadata = folder.lstat() + require(stat.S_ISDIR(metadata.st_mode) and not folder.is_symlink() and metadata.st_uid == 0 + and stat.S_IMODE(metadata.st_mode) == 0o700, 'own original case only') + intent = json.loads((folder / 'intent.json').read_bytes()) + require(all(intent.get(key) == value for key,value in p.items() if key != 'action'), 'same original read binding') + result = folder / 'result.json' + return {'read_only': True, 'id': ident, 'entered': (folder / 'entered.json').exists(), + 'result': json.loads(result.read_bytes()) if result.exists() else None, 'current_witness': witness()} + require(p['action'] == 'execute', 'one fixed process-census unit action') + os.umask(0o077); folder.mkdir(mode=0o700) + create(folder / 'intent.json', enc({key: value for key, value in p.items() if key != 'binary_b64'})) + require(len(p['binary_b64']) == 10517464, 'bounded binary transfer') + raw = base64.b64decode(p['binary_b64'], validate=True) + require(len(raw) == 7888096 and hashlib.sha256(raw).hexdigest() == p['binary_sha256'], 'fixed worker test binary; only the closed census filter may run') + binary = folder / 'worker-census-tests'; create(binary, raw, 0o700) + before = witness(); create(folder / 'before.json', enc(before)) + command = ['/usr/bin/setpriv', '--reuid=0', '--regid=0', '--clear-groups', '--no-new-privs', str(binary)] + code, stdout, stderr = run(command + ['--list', '--format', 'terse']) + create(folder / 'list.stdout', stdout); create(folder / 'list.stderr', stderr) + require(code == 0 and stderr == b'', 'native list succeeded') + lines = stdout.decode().splitlines() + require(len(lines) == 10 and all(line.endswith(': test') for line in lines) and sorted(line[:-6] for line in lines if line.endswith(': test')) == p['all_tests'], 'exact ten names before selecting only two census tests') + create(folder / 'entered.json', enc({'id': ident, 'run_once': True, 'time_ns': time.time_ns()})) + code, stdout, stderr = run(command + [p['test_filter'], '--test-threads=1', '--nocapture']) + create(folder / 'run.stdout', stdout); create(folder / 'run.stderr', stderr) + after = witness(); create(folder / 'after.json', enc(after)) + require(before == after and code == 0 and stderr == b'' + and b'2 passed; 0 failed; 0 ignored; 0 measured; 8 filtered out' in stdout + and all((b'test ' + name.encode() + b' ... ok') in stdout for name in p['tests']), 'two selected native census guards, eight filtered and retained target state') + receipt = dict(id=ident, profile=p['profile'], passed=2, ignored=0, filtered=8, listed=10, execution_uid=0, tests=p['tests'], + all_tests=p['all_tests'], test_filter=p['test_filter'], + before=before, after=after, binary_sha256=p['binary_sha256'], source_receipt_sha256=p['receipt_sha256'], + source_manifest_sha256=p['manifest_sha256'], stdout_sha256=hashlib.sha256(stdout).hexdigest(), + no_rmm_jobs=True, no_apply=True, no_service_control=True) + create(folder / 'result.json', enc(receipt)); return receipt + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('action', choices=('prepare', 'execute', 'read')); parser.add_argument('--case') + args = parser.parse_args(); os.umask(0o077) + STATE.mkdir(mode=0o700, parents=True, exist_ok=True); support.private(STATE, True) + if args.action == 'prepare': + support.require(args.case is None, 'prepare one new local case') + receipt_path = QUALIFICATION / 'receipt.json'; support.private(receipt_path) + support.require(sha(receipt_path.read_bytes()) == RECEIPT_SHA, 'independently reviewed source receipt') + receipt = support.load(receipt_path); original = support.load(QUALIFICATION / 'inputs.json') + support.require(sha((QUALIFICATION / 'inputs.json').read_bytes()) == INPUTS_SHA + and receipt['inputs_sha256'] == INPUTS_SHA and len(original) == 71 + and receipt['input_count'] == 71 and receipt['tests'] == dict(passed=10,failed=0,ignored=0,filtered=0,complete_names=ALL_TESTS) + and receipt['checks'] == dict(fmt=0,check=0,clippy=0,build=0,list=0,unit=0) + and receipt['native_apply_run'] is False and receipt['target_calls'] is False, + 'reviewed ten-worker qualification, only two census tests selected') + ident = str(uuid.uuid4()); folder = STATE / ident; folder.mkdir(mode=0o700) + copy_exact(receipt_path, folder / 'receipt.json', RECEIPT_SHA, receipt_path.stat().st_size) + copy_exact(QUALIFICATION / 'inputs.json', folder / 'inputs.json', INPUTS_SHA, (QUALIFICATION / 'inputs.json').stat().st_size) + paths = set() + for item in original: + path = Path(item['path']) + support.require(not path.is_absolute() and '..' not in path.parts and str(path) not in paths, 'unique fixed frozen input') + paths.add(str(path)); copy_exact(QUALIFICATION / 'source' / path, folder / 'source' / path, item['sha256'], item['bytes']) + binary = QUALIFICATION / 'qualified-worker-tests' + support.require(receipt['binary'] == dict(filename='qualified-worker-tests', bytes=BINARY_BYTES, + sha256=BINARY_SHA, mode='0500', nlink=1), 'fixed original linked artifact') + copy_exact(binary, folder / 'worker-census-tests', BINARY_SHA, BINARY_BYTES) + transports = {path: sha((ROOT / path).read_bytes()) for path in ('deploy/windows_msi_runtime_acceptance.py', 'deploy/vm_access_check.py')} + save_local(folder / 'manifest.json', dict(id=ident, profile=PROFILE, runner_sha256=sha(Path(__file__).read_bytes()), + receipt_sha256=RECEIPT_SHA, binary_sha256=BINARY_SHA, binary_bytes=BINARY_BYTES, + source_files=original, tests=TESTS, all_tests=ALL_TESTS, test_filter=TEST_FILTER, transport_sources=transports)) + verify_case(folder) + print(json.dumps({'id': ident, 'prepared_locally': True})); return + support.require(args.case is not None, 'original --case required') + ident = str(uuid.UUID(args.case)); support.require(ident == args.case, 'same canonical original case') + folder = STATE / ident; support.private(folder, True); verify_case(folder) + payload = dict(id=ident, action=args.action, profile=PROFILE, tests=TESTS, all_tests=ALL_TESTS, test_filter=TEST_FILTER, binary_sha256=BINARY_SHA, + receipt_sha256=RECEIPT_SHA, manifest_sha256=sha((folder / 'manifest.json').read_bytes()), + agent_sha256=AGENT_SHA, helper_sha256=HELPER_SHA) + if args.action == 'execute': + save_local(folder / 'execute-entered.json', {'once': True, 'no_retry': True}) + payload['binary_b64'] = base64.b64encode((folder / 'worker-census-tests').read_bytes()).decode() + code = 'import json\n' + inspect.getsource(remote) + '\nprint(json.dumps(remote(' + repr(payload) + ')))\n' + response = support.transport(support.access_settings(ACCESS_ROOT, 'linux'), 'python3 -', code.encode(), folder) + save_local(folder / (args.action + '-' + str(uuid.uuid4()) + '.json'), response) + if args.action == 'read' and response['result'] is not None: + support.require(response['result']['source_manifest_sha256'] == sha((folder / 'manifest.json').read_bytes()) + and response['result']['source_receipt_sha256'] == RECEIPT_SHA + and response['result']['binary_sha256'] == BINARY_SHA and response['result']['tests'] == TESTS + and response['result']['passed'] == 2 and response['result']['ignored'] == 0 and response['result']['filtered'] == 8 + and response['result']['listed'] == 10 and response['result']['all_tests'] == ALL_TESTS + and response['result']['test_filter'] == TEST_FILTER + and response['result']['before'] == response['result']['after'] + and response['current_witness'] == response['result']['after'], 'same-case retained native result') + print(json.dumps({'id': ident, 'action': args.action, 'passed': response.get('passed'), + 'complete': response.get('result') is not None if args.action == 'read' else True, 'read_only': args.action == 'read'})) + + +if __name__ == '__main__': + main() diff --git a/docs/agent-updater-reader-census-results.md b/docs/agent-updater-reader-census-results.md new file mode 100644 index 0000000..f03816b --- /dev/null +++ b/docs/agent-updater-reader-census-results.md @@ -0,0 +1,108 @@ +# Linux-Readercensus: lokaler Quellenstand und geplanter nativer Nachweis + +Stand2026-11-15, Spezifikation1.22. Keine Zielinstallation, Dienständerung, +RMM-Ausführung oder Applyabnahme wurde in diesem Arbeitsschritt vorgenommen. +Die WebUI-Genehmigungsgrenze bleibt unverändert. + +Registry und Census sind mit der vorhandenen Worker-Enginequelle verbunden. +Die Registry bindet Originalrohbytes, Bootstrapreceipt, Readervertrag, +Hostnamespaces und exakte Unit-/Dropinkomposition. Aktuelle TGIDs und sämtliche +Task-FD-Tabellen werden begrenzt und erneut auf Identität geprüft; auch eine +Datei mit geschlossenem FD bleibt über ihren mmap-Inode ein Reader. Unbekannte, +unlesbare, wechselnde oder unvollständige Beobachtungen verweigern. Fremde +Cmdlines, Umgebungen und map-Pfade werden nicht ausgegeben. + +Der vorhandene Root-Executorflock und die ursprüngliche Agent-Singletonsperre +bleiben beide unter dem nicht frei konstruierbaren `ClosedReaders`-Beleg gehalten, +bevor der Updater SQLite öffnet. Der Readervertrag fordert außerdem den +Roothelperflock vor seinen SQLiteöffnungen und jeder SQL-/Effektoperation und +die Agent-Sperre lebenslang vor beiden Agentdatenbanken. Dies ist kein globales +Versprechen über zukünftige privilegierte Fremdprozesse. + +## Tatsächlich lokal geprüft + +Im isolierten Offline-Rustcontainer, Quellmount read-only, unveränderte +Docker-Seccomp-Policy, eigene tmpfs für `/run`, `/tmp` und `/var/lib`: + +- Locked all-targets Check, Release-Link, Clippy `-D warnings`, Formatcheck: PASS. +- Vollständige Release-Workerliste10, tatsächlich10bestanden,0Fehler, + 0ignoriert,0gefiltert. +- Die Prozessfixtures belegen bestehende FDs, anschließend mmap nach FDclose + sowie einen Reader in einer privaten FD-Tabelle eines einzelnen Threads. + Der TGID-only-Gegenfall findet diesen Threadreader ausdrücklich nicht; + die vollständige Taskprüfung findet ihn. + +Der erste Lauf unter `reader-census-ba31b221-79c4-4702-b6d6-09bb94bba7fc` +bestand9/10. Der eigene Threadfixture wurde am Docker-Seccomp-Verbot für +`unshare(CLONE_FILES)` mit EPERM abgewiesen. Ausschließlich im Testfixture wurde +stattdessen `close_range(UINT_MAX,UINT_MAX,CLOSE_RANGE_UNSHARE)` verwendet: +die gleiche eigene FD-Tabellenseparation, ohne eine tatsächlich mögliche +FDnummer zu schließen. Keine Sandboxregel, Capability oder Produktionsprüfung +wurde gelockert. Die Produktionsbytes vor `#[cfg(test)]` blieben identisch. +Die Semantik folgt [close_range(2)](https://man7.org/linux/man-pages/man2/close_range.2.html). +Der ursprüngliche Fehlerbeleg bleibt erhalten. + +Finaler eingefrorener Privatfall: +`devstate/agent-updater-worker/reader-census-final-da31051b-269f-4fb5-947d-94c8ad162c2a/`. +Er enthält71Originalinputs mit Vor-/Nachhashprüfung, alle Logs und das tatsächlich +lokal ausgeführte Release-Test-ELF. Receipt SHA256 +`9020992e888d0b22e71db88cab78f255e273be2a4a7856d43616b387c36c74ae`, +Inputs SHA256 `382714b09349e448441345abbac6d99c0d523e98bdabaa78290b400768bac8f7`, +ELF7.888.096Bytes/SHA256 +`e83fd334b005d81ac917389de2a1c7486bea3f62ae45d77bccbd331e131e4304`. + +## Geplant, nicht ausgeführt: zwei Cloud-Linux-Prozessguards + +`deploy/updater_reader_census_linux_acceptance.py` ist lokal vorbereitet im +Originalfall `168a4171-dbe3-46ef-8978-850797d0625c`. Vor Zielausführung muss Root +seinen unabhängigen Runnerreview abschließen. Keine Zugangsdaten wurden für +Prepare gelesen, kein Zielaufruf vorgenommen. + +Der Runner prüft zuerst die vollständige Liste aller10Tests des exakt gebundenen +ELF. Anschließend läuft ausschließlich der feste Filter `census_process::tests::`: + +- `actual_proc_probe_detects_existing_descriptors_and_mapped_inode_without_exporting_paths` +- `private_thread_fd_table_cannot_hide_a_reader_from_the_group_probe` + +Erforderlich sind2bestanden und8gefiltert. Die anderen acht Tests dürfen auf der +VM nicht laufen: Einige lokale Fixtures verwenden feste Produktzustandspfade. +Die zwei ausgewählten Tests verwenden nur eigene Create-once-UUIDdateien unter +`/run`, eigene FDs, eigenen mmap und einen eigenen Fixturethread. Keine SQLopen, +Jobs oder Dienststeuerung. Der Runner läuft als Root mit NoNewPrivileges und +führt nach einmaligem Eintritt keine Wiederholung aus. Nach verlorener Antwort +ist ausschließlich Read des Originalfalls zulässig. + +Vorher/Nachher werden Boot, Ubuntu24.04/x86-64, drei bekannte Dienstgenerationen +mit Konten/Images, geschlossener APT-Helfer, vier geschützte Control-Dateien, +drei DB-Identitäten sowie ursprünglicher Root- und Agentlock verglichen. +Control-Bytes sind gehasht; bei den laufenden DBs werden Identitäten geprüft, +keine Bytegleichheit oder vollständige SQL-Historie behauptet. Der begrenzte +Prozessnachweis ersetzt weder einen kompletten Hostcensus noch native +Full-/Updaterdienstkontexte oder einen Updatejob. + +## Weiterhin offen + +Extern qualifizierte kompatible Bootstrapregistry und geschützter Hostkontext, +native Dienst-/Namespace-/Capabilitykontexte, ursprüngliche Full-Admission und +Runtimeentrypoint, Staging-/Downloadproducer, gültige passive Updatebeobachtung, +Unknown-only-Recordnamespace-Adjudikation, ein vor dem ersten Apply lesbarer +V2-Rollbackvertrag sowie tatsächlicher WebUI-genehmigter Linux-Apply mit +Health-/Erhaltungsnachweis. V1-Restore bleibt deny. Kein erfolgreicher nativer +Apply und keine fertige Updaterbereitschaft folgen aus diesen lokalen Guards. + +## Tatsächlich auf Cloud-Linux ausgeführt + +Originalfall `168a4171-dbe3-46ef-8978-850797d0625c`: vor Ausführung volle +10er-Liste verglichen, danach genau beide Prozesscensus-Guards tatsächlich +als UID0 bestanden;2PASS/0failed/ignored,8andere ausdrücklich gefiltert. +Execute-Receipt +`d6bdda0bddac74f9364fa6ec3287ed0cfa9964ae02a98cc174e95929dc94f9d5`. +Separater Originalrückabruf bestätigte das Ergebnis und erhaltene aktuelle +Runtime-/Control-/State-/Lockidentitäten, Receipt +`8cbe7f4d79c238e3ad73a9c7152dcb415decbeeb1a8a1691fcc43ae4ee6c6a47`. + +Die eigenen kurzlebigen Prozess-/Thread-/FD-/mmap-Fixtures wurden geprüft; +keine RMM-Dienste gesteuert, keine Projekt-SQLite geöffnet oder Agentdatei +ersetzt. Dieser Nachweis qualifiziert weder den vollständigen Host-/ +Dienstcensus noch Admission, Apply, Record-Unknown-Adjudikation oder Rollback. +Die zuvor genannten offenen Gates bleiben offen. diff --git a/docs/agent-updater-reader-registry.md b/docs/agent-updater-reader-registry.md new file mode 100644 index 0000000..3942d2f --- /dev/null +++ b/docs/agent-updater-reader-registry.md @@ -0,0 +1,108 @@ +# Geschützte Linux-Readerregistry: Quellenbaustein + +Stand2026-11-15, Spezifikation1.22. `worker::reader_registry` implementiert nur +Registry-/Unit-/Aktivierungspfadprüfung. Kein Bootstrap, Dienstcontrol, SQLopen, +Updaterstart, Apply oder Capability folgt daraus. Die vollständige aktuelle +Task-/FD-/maps-Census und die tatsächlich gehaltenen ursprünglichen Root- und +Agentlocks sind zusätzlich Pflicht. Die lokale Enginequelle verbindet diese +Bausteine inzwischen; ohne extern qualifizierte Bootstrapregistry, tatsächliche +Dienst-/Hostkontexte und ursprünglichen Admissionanschluss bleiben die +Produktcapabilities `not_configured`. Siehe +[aktuellen Readercensusnachweis](agent-updater-reader-census-results.md). + +Der Aufruf `QualifiedRegistry::load(&LocalUpdatePolicy)` liest ausschließlich +`/etc/rmm-agent-updater/reader-registry.json` unter root-eigener, gegen fremdes +Schreiben geschützter Ancestry. Originalrohbytes höchstens64KiB, root0, regulär, +ein Link; deren exakter SHA muss `policy.reader_registry_sha256` entsprechen. +Damit bindet der vor WebUI-Genehmigung gespeicherte Policyhash die Registry +transitiv. Gehaltene Dateien/Parent-FDs, Rawbytes und aktuelle Metadatastempel +bleiben erhalten; `verify_protected()` prüft unveränderte originale Namen, +Device/Inodes, Konten/Modi/Linkzahlen, Größe, Zeitstempel und Bytes. Kein Caller- +Boolean oder aus einem Registryfeld abgeleitetes Alleinvertrauen. + +Schema1 und Profil `linux_shared_readers_v1` besitzen exakt: + +- `bootstrap_receipt_sha256`: exakt der Bootstrap-Qualificationreceipthash aus + `policy.initial_baseline.decode().record.activation_evidence`. +- `reader_contract_sha256`: Hash der unveränderlichen öffentlichen Bytekonstante + `READER_CONTRACT`, über `reader_contract_sha256()` unabhängig berechenbar. +- `host_context`: `census::HostContext` mit extern bootstrapqualifizierten + Proc-/User-/PID-/Cgroup-Namespace-Device/Inodes; aktuelle eigene gleiche + Metadaten allein sind keine Bootstrapqualifikation. +- `units`: die unten festgelegten21 Units in dieser Reihenfolge. +- `rollback_timers`: höchstens32 weitere historisch bekannte, sortierte eindeutige + `rmm-general-startup-rollback-.timer`-Einträge. + +Jeder Uniteintrag enthält `unit`, `unit_file_state`, `composition`, `triggers` +und `triggered_by`. Beziehungen sind sortierte eindeutige bekannte Registrynamen, +keine freie Dateiauswahl oder zukünftige Readererlaubnis. `composition` ist exakt +wie im unveränderten OSport die geordnete `Vec<(path, FileProof)>`: Fragment +zuerst, dann tatsächliche DropInPaths-Reihenfolge. Der Hash derselben JSON- +Bytefolge muss bei den Policydiensten passen; FileProof enthält insbesondere +Original-Device/Inode, nicht nur ContentSHA. Geschützte systemd-Fragmente und +höchstens16 `.conf`-Dropins werden unter den bekannten systemd-Systemverzeichnissen +gebunden, insgesamt höchstens128 Blätter. Global-/Prefixdropins sind möglich, +aber kein unbekannter Zusatz wird ignoriert. Leere Komposition und leerer +UnitFileState sind ausschließlich bei einem absent/not-found-Nichtreader gültig. + +Die21 Einträge sind zunächst diese7 Services: Agentremote, Helpercloud, +Fullmaintenance, Updater, APThelper, Legacy`rmm-agent` und +Legacy`rmm-helper-dev-test`. Danach folgen für dieselben7 Basen jeweils `.socket` +und `.timer`. Vollständige feste Namen stehen in der Quellkonstante `SERVICES`. +`rmm-mvp-test.service` ist eine Wartungsfixture, kein registrierter Reader; +dieser Baustein fragt sie nicht ab und steuert sie niemals. + +Der feste Readervertrag bindet: Roothelper erwerben das bestehende +`executor.lock` vor SQLiteopen und jeder SQL-/Effektoperation; der Agent hält +die vorhandene `agent.lock` schon vor Öffnung beider Agentdatenbanken lebenslang; +alle erlaubten Reader verstehen Update-/Handoff-/Inflightdecoder. Registry- +Parsing beweist diese Code-/Bootstrapeigenschaften nicht selbst. Die tatsächliche +separat qualifizierte Baseline, Originalsignaturen und Census/Locks bleiben +Pflicht. Eine Registry oder ein flock allein verspricht keine globale Abwesenheit +zukünftiger exec-Aufrufe oder willentlicher vertrauenswürdiger Rootneustarts. + +`verify_admission` verlangt genau Agent/General/Full/Updater loaded/active/running +mit echten ServiceMainPIDs, ControlPID0, ohne ausstehenden Start-/Controljob. +`verify_stopped` verlangt Agent/General/Full inactive/dead mit tatsächlichen +Main-/ControlPIDs0; der Updater bleibt aktiv. Der originale UnitFileState bleibt +für alle vier exakt gebunden, enabled oder disabled. Ein aktivierter Full- oder +Updaterdienst muss deshalb nicht heimlich enabled werden. APT ist optional nur +als tatsächlich gebundener Policydienst vorhanden, bleibt geschlossen und +gehört niemals ins Startset. Legacyservices und Gegenstücke sind absent oder +loaded/inactive/dead/disabled; aktuelle unbekannte Rollbacktimer verweigern. + +Die read-only Systemdaufrufe sind ausschließlich `/usr/bin/systemctl --system +--no-ask-password --no-pager --full show --all` mit festen Properties/Namen und +zwei begrenzte `list-units`-/`list-unit-files`-Aufrufe mit festem historischem +Rollbacktimerpattern. Kein Shellglob, Pager, Authdialog, start/stop/enable oder +freie Commandline. Jede eigene Abfrage hat10s und das zusätzliche ursprüngliche +`Budget`; stdout/stderr je16KiB. Nur der eigene gehaltene pidfd-Prozess wird bei +Abbruch beendet, keine fremde PID übernommen. Statuswerte und fremde Prozess- +oder Mappfade werden nicht in Fehlermeldungen ausgegeben. + +Typen werden nicht erfunden: Service besitzt MainPID und ControlPID, Socket +nur ControlPID und eine tatsächliche aktuelle Verbindungsanzahl; Timer besitzt +keine PID-Eigenschaft. Fehlende anwendbare Properties verweigern. Timer/dead +bedeutet im [Systemd-Primärvertrag](https://github.com/systemd/systemd/blob/main/src/core/timer.c) +disarmierte Timereventquellen; Socket/dead ist keine Listenactivation. Es wird +kein nicht vorhandenes MainPID als gemessene0 ausgegeben. +[DBus-Typvertrag](https://www.freedesktop.org/software/systemd/man/latest/org.freedesktop.systemd1.html). +Die ausgewählte `Job`-Property muss vorhanden sein; deren leere Ausgabe mit +`--all` ist Systemctls Darstellung des tatsächlichen Nulljobs. +[Primärformatter](https://github.com/systemd/systemd/blob/main/src/systemctl/systemctl-show.c). + +`Triggers`/`TriggeredBy` sind strukturelle Beziehungen und werden exakt gegen +die Registry gebunden. Ihre Namen allein werden nicht als laufendes Ereignis +missverstanden. Alle relevanten registrierten Aktivierungsquellen müssen +unabhängig geschlossen sein; offene oder unbekannte Pfade verweigern. Allgemeine +WantedBy-Systemtargets werden damit nicht pauschal zu zu stoppenden Readern. +Alle Statusfelder werden vor und nach der Prüfung identisch erneut gelesen, +Registry/Unitblätter sowie aktueller Hostkontext erneut geprüft. Das ist eine +begrenzte Momentaufnahme unter den weiteren Originalgrenzen, kein Futureexec- +oder lückenloser Kernel-Snapshotbeweis. + +Dieser Worker hat keine Target-/SSH-/Job-/Scope-/Dienst-/Policyaktion oder +Systemdprobe ausgeführt. Compiler-/Format-/Clippyprüfung und unabhängiger +Quellenreview werden durch den koordinierenden Owner nach diesem Quellenhandoff +ausgeführt und separat berichtet. Die kleine Parserprobe verwendet ausschließlich +synthetische Statusbytes, keine tatsächliche Registry oder laufende Units. diff --git a/docs/agent-updater-runtime-source.md b/docs/agent-updater-runtime-source.md index 31eadfc..622b54d 100644 --- a/docs/agent-updater-runtime-source.md +++ b/docs/agent-updater-runtime-source.md @@ -135,9 +135,28 @@ unveröffentlicht; kein Cloud-VM-Apply, kein Produktfertig- oder Produktionsnach Nach dem gepushten gemeinsamen Checkpoint8e93c9e und dem erhaltenden Mainmerge 07d6118 ist die bisher offene Enginefolge als konkrete Workerquelle verbunden. -Ihr Eintritt bleibt explizit `UPDATE_READER_CENSUS_NOT_CONFIGURED`; weder -Daemonentrypoint noch Job-/Applycapability wird aktiviert. Die genaue +Dieser historische Stand sperrte den Eintritt explizit mit +`UPDATE_READER_CENSUS_NOT_CONFIGURED`. Die folgende lokale Fortschreibung hat +Registry und Readercensus im Quellpfad verbunden; weiterhin wird weder ein +Daemonentrypoint noch eine Job-/Applycapability aktiviert. Die genaue Queue-/Reply-/Stop-/Lock-/Swap-/Start-/Healthfolge und vorhandene separate Agent-Singletonsperre stehen in [worker](agent-updater-worker.md). Der neu geprüfte öffentliche Recordbuilder löst die zuvor dort genannte fehlende positive authentisierte Eingangsprobe. Keine reale Applyabnahme folgt daraus. + + +## Fortschreibung2026-11-15: Readerregistry und vollständige Task-FD-Prüfung + +Der gemeinsame Quellsatz verbindet Registryprüfung, ursprüngliche Agent- und +Root-Executorsperre sowie TGID-/TID-FD-/maps-Prüfung mit der bestehenden Engine. +Vor SQLiteöffnung verlangt der Ledgerport den nicht frei konstruierbaren +`ClosedReaders`-Beleg und den tatsächlich gehaltenen ursprünglichen Rootguard. +Das ist ein lokaler Quellen-/Vertragspunkt, kein gestarteter Dispatcher und +keine Zusage über zukünftige privilegierte Fremdprozesse. + +Der eingefrorene71-Input-Quellsatz besteht lokal alle10 vorhandenen Workerguards, +locked all-targets Check, Release-Link, Clippy mit `-D warnings` und Formatcheck. +Ein eigener Runner ist ausschließlich für zwei eigene native Prozessfixtures +vorbereitet; er ist noch nicht ausgeführt. Details, frühere fehlgeschlagene +Fixtureprüfung und verbleibende MVP-Gates stehen im +[Readercensusnachweis](agent-updater-reader-census-results.md). diff --git a/docs/agent-updater-worker.md b/docs/agent-updater-worker.md index c1dc025..da59072 100644 --- a/docs/agent-updater-worker.md +++ b/docs/agent-updater-worker.md @@ -186,14 +186,18 @@ DBclose/Rootlockreturn gehalten und wird vor der festen Startfolge zurückgegebe Der Agent hält schon heute seine ursprüngliche Singletondatei vor beiden Agent-SQLiteöffnungen; keine ACL, Agentdatei oder Sperrrolle wurde geändert. -**Explizite Sperre dieses Checkpoints:** `Runtime::serve_one` verweigert mit -`UPDATE_READER_CENSUS_NOT_CONFIGURED`. Geschützte kompatible Bootstrapregistry -plus vollständige aktuelle PID-/FD-/maps-Census und Nachstopbeobachtung unter -beiden tatsächlichen Sperren fehlen noch. Eine bekannte Unitliste ersetzt -keinen Census. Keine CLI oder RMM-Admission ruft diese Runtime auf; Applycaps -bleiben geschlossen. Ebenso offen: Staging-/Downloadproducer, passiver gültiger +Der ursprüngliche Quellencheckpoint verweigerte den Eintritt explizit mit +`UPDATE_READER_CENSUS_NOT_CONFIGURED`. Die Fortschreibung verbindet jetzt die +Registry sowie tatsächliche Task-/FD-/maps-Census vor den Stops und unter beiden +gehaltenen ursprünglichen Sperren danach. Diese Quellintegration ist lokal +geprüft, jedoch noch nicht als installierter Dienst-/Hostkontext qualifiziert. +Eine bekannte Unitliste allein ersetzt keinen Census. Keine CLI oder +RMM-Admission ruft diese Runtime auf; Applycaps bleiben geschlossen. Offen sind +insbesondere extern qualifizierte kompatible Bootstrapregistry und Hostkontexte, +ursprüngliche Full-Admission, Staging-/Downloadproducer, passiver gültiger Updatezustand, V2-Rollbackvertrag vor dem ersten Bootstrap, Unsicherheits- -Namespaces, qualifizierte Dienstkontexte und tatsächlicher Linux-Apply. +Namespaces und tatsächlicher Linux-Apply. Aktueller Nachweis und enger geplanter +nativer Zweierlauf: [Readercensus](agent-updater-reader-census-results.md). Lokaler Nachweis liegt unter `devstate/updater-engine-source-6a8bb902-4db4-4d93-8843-450ba1dd5622/`.