//! Passive authenticated catalog metadata only. No artifact request, preview, //! approval, staging, consumption, capability, service or filesystem write. use anyhow::{Context, Result, ensure}; use chrono::{DateTime, Utc}; use openssl::{ pkey::{Id, PKey}, sign::Verifier, }; use rmm_domain::{ agent_update::{Platform, ReleaseEnvelope, ReleaseManifest, UpdateKeyringFile}, agent_update_provisioning::{ BASELINE_SIGNATURE_DOMAIN, InstalledReleaseRecord, LocalUpdatePolicy, }, jobs::hash, }; use rmm_privileged_helper::{Binding, TrustedClock}; use rmm_updater::{ ActiveRelease, ReleaseRelation, SignedRelease, TrustedContext, TrustedUpdateKey, UpdateKeyring, verify_release, }; use serde::Deserialize; use std::{ fs::{File, OpenOptions}, io::Read, net::SocketAddr, os::unix::fs::{MetadataExt, OpenOptionsExt}, path::{Path, PathBuf}, time::{Duration, Instant}, }; use tokio::sync::oneshot; #[cfg(test)] use uuid::Uuid; const POLICY: &str = "/etc/rmm-agent-updater/policy.json"; const KEYRING: &str = "/etc/rmm-agent-updater/keyring.json"; const RECORD: &str = "/var/lib/rmm-agent-updater/installed-record.json"; const RESPONSE_LIMIT: usize = 64 * 1024; const DAY: Duration = Duration::from_secs(24 * 60 * 60); use rmm_domain::agent_update::{ CatalogCandidate as Candidate, CatalogCheckReport as Report, CatalogCheckStatus as Status, }; fn empty(status: Status) -> Report { Report { schema_version: 1, source_id: "mtls:release-catalog-v1".into(), checked_at: Utc::now(), status, candidate: None, } } /// Old servers already accept this ordinary bounded Linux observation shape. /// The outer timestamp says when the cache was read; checked_at is not restamped. pub fn observation(report: Report, collected_at: DateTime) -> serde_json::Value { let (quality, error) = match report.status { Status::Available | Status::Current => ("valid", None), Status::NotConfigured => ("unknown", Some("UPDATE_CATALOG_NOT_CONFIGURED")), Status::Unavailable => ("error", Some("UPDATE_CATALOG_CHECK_UNAVAILABLE")), }; serde_json::json!({"scope":"linux.agent_update.catalog","source_id":"agent:cached-release-catalog-v1", "observed_at":collected_at,"quality":quality,"completeness":"complete","truncated":false, "error_code":error,"data":report}) } struct Pending { receiver: oneshot::Receiver<(Report, Option)>, task: tokio::task::JoinHandle<()>, } impl Drop for Pending { fn drop(&mut self) { self.task.abort(); } } #[derive(Default)] pub struct Checker { report: Option, release: Option, started: Option, pending: Option, } impl Checker { /// Exact authenticated envelope, for the independent read-only Full /// verifier. This cache never confers admission or a capability itself. pub fn candidate_envelope(&self, now: DateTime) -> Option<(ReleaseEnvelope, u64)> { let report = self.cached(now)?; let candidate = report.candidate?; let envelope = self.release.as_ref()?; let decoded = envelope.decode().ok()?; (hash(&decoded.payload_bytes) == candidate.manifest_sha256) .then(|| (envelope.clone(), candidate.keyring_generation)) } pub fn cached(&self, now: DateTime) -> Option { self.report .as_ref() .filter(|report| report.validate(now, now)) .cloned() } /// Called by the normal passive update collector. IO runs in a background /// task; a slow HTTPS peer never blocks heartbeat/cancel/control dispatch. pub fn poll( &mut self, binding: Option<&Binding>, clock: TrustedClock, address: SocketAddr, guarded: Option, client: impl FnOnce() -> Result, ) -> Report { if let Some(pending) = &mut self.pending { match pending.receiver.try_recv() { Ok((report, release)) => { self.report = Some(report); self.release = release; self.pending.take(); } Err(oneshot::error::TryRecvError::Empty) => {} Err(oneshot::error::TryRecvError::Closed) => { self.report = Some(empty(Status::Unavailable)); self.release = None; self.pending.take(); } } } let interval = if self .report .as_ref() .is_some_and(|r| matches!(r.status, Status::Available | Status::Current)) { DAY } else { Duration::from_secs(60) }; if self.pending.is_none() && self.started.is_none_or(|t| t.elapsed() >= interval) { self.started = Some(Instant::now()); let prepared = binding .map(|binding| { Trust::load( binding, Path::new(POLICY), Path::new(KEYRING), Path::new(RECORD), guarded.as_ref(), ) }) .transpose(); match prepared { Ok(None | Some(None)) => self.report = Some(empty(Status::NotConfigured)), Err(_) => self.report = Some(empty(Status::Unavailable)), Ok(Some(Some(trust))) => { let transport = if clock.trusted() { client() } else { Err(anyhow::anyhow!("UPDATE_CATALOG_CLOCK_UNTRUSTED")) }; match transport { Err(_) => self.report = Some(empty(Status::Unavailable)), Ok(client) => { let (sender, receiver) = oneshot::channel(); let task = tokio::spawn(async move { let result = tokio::time::timeout( Duration::from_secs(35), request(&client, address, &trust, &clock), ) .await; let report = result .ok() .and_then(Result::ok) .unwrap_or_else(|| (empty(Status::Unavailable), None)); let _ = sender.send(report); }); self.pending = Some(Pending { receiver, task }); } } } } } self.report .clone() .unwrap_or_else(|| empty(Status::Unavailable)) } } /// Protected, public local records only. Missing provisioning is not an invitation /// to bootstrap trust from the HTTP response, current job or a writable file. struct Protected { path: PathBuf, file: File, stamp: [u64; 10], raw: Vec, limit: usize, } fn stamp(m: &std::fs::Metadata) -> [u64; 10] { [ m.dev(), m.ino(), m.uid().into(), m.gid().into(), m.mode().into(), m.len(), m.mtime() as u64, m.ctime() as u64, m.mtime_nsec() as u64, m.ctime_nsec() as u64, ] } fn parents(path: &Path) -> Result<()> { ensure!(path.is_absolute(), "UPDATE_CATALOG_ANCHOR_PATH"); for parent in path.ancestors().skip(1) { let m = std::fs::symlink_metadata(parent)?; ensure!( m.is_dir() && !m.file_type().is_symlink() && m.uid() == 0 && m.mode() & 0o022 == 0, "UPDATE_CATALOG_ANCHOR_PARENT" ); } Ok(()) } impl Protected { fn read(path: &Path, limit: usize) -> Result { parents(path)?; let mut file = OpenOptions::new() .read(true) .custom_flags(libc::O_NOFOLLOW | libc::O_NONBLOCK | libc::O_CLOEXEC) .open(path)?; let m = file.metadata()?; ensure!( m.is_file() && m.uid() == 0 && m.mode() & 0o022 == 0 && m.nlink() == 1 && m.len() > 0 && m.len() <= limit as u64, "UPDATE_CATALOG_ANCHOR_FILE" ); let before = stamp(&m); let mut raw = Vec::new(); (&mut file).take(limit as u64 + 1).read_to_end(&mut raw)?; ensure!( raw.len() as u64 == m.len() && stamp(&file.metadata()?) == before, "UPDATE_CATALOG_ANCHOR_CHANGED" ); let result = Self { path: path.to_owned(), file, stamp: before, raw, limit, }; ensure!( stamp(&std::fs::symlink_metadata(path)?) == result.stamp, "UPDATE_CATALOG_ANCHOR_REPLACED" ); Ok(result) } fn recheck(&self) -> Result<()> { let current = Self::read(&self.path, self.limit)?; ensure!( stamp(&self.file.metadata()?) == self.stamp && current.stamp == self.stamp && current.raw == self.raw, "UPDATE_CATALOG_ANCHOR_REPLACED" ); Ok(()) } } struct Trust { files: Vec, keys: UpdateKeyring, record: InstalledReleaseRecord, protocol: u32, state: u32, generation: u64, } impl Trust { fn load( binding: &Binding, policy: &Path, keys: &Path, record: &Path, guarded: Option<&crate::agent_update_apply::GuardedRecord>, ) -> Result> { let result = (|| -> Result { let policy = Protected::read(policy, 65536)?; let (local, _) = LocalUpdatePolicy::from_bytes(&policy.raw).map_err(anyhow::Error::msg)?; ensure!( local.keyring_path == KEYRING && local.installed_record_path == RECORD, "UPDATE_CATALOG_FIXED_ANCHOR_PATHS" ); let keys = Protected::read(keys, 16384)?; if let Some(guarded) = guarded { let raw = guarded.bytes(&policy.raw, &keys.raw)?; let result = Self::verify_guarded(binding, &policy.raw, &keys.raw, raw, Some(guarded))?; Ok(Self { files: vec![policy, keys], ..result }) } else { let record = Protected::read(record, 32768)?; let result = Self::verify(binding, &policy.raw, &keys.raw, &record.raw)?; Ok(Self { files: vec![policy, keys, record], ..result }) } })(); match result { Ok(value) => Ok(Some(value)), Err(error) if error .downcast_ref::() .is_some_and(|e| e.kind() == std::io::ErrorKind::NotFound) => { Ok(None) } Err(error) => Err(error), } } fn verify( binding: &Binding, policy_raw: &[u8], keys_raw: &[u8], record_raw: &[u8], ) -> Result { Self::verify_guarded(binding, policy_raw, keys_raw, record_raw, None) } fn verify_guarded( binding: &Binding, policy_raw: &[u8], keys_raw: &[u8], record_raw: &[u8], guarded: Option<&crate::agent_update_apply::GuardedRecord>, ) -> Result { let (policy, _) = LocalUpdatePolicy::from_bytes(policy_raw).map_err(anyhow::Error::msg)?; ensure!( policy.tenant_id == binding.tenant_id && policy.asset_id == binding.asset_id && policy.agent_id == binding.agent_id && policy.enrollment_generation == binding.enrollment_generation && policy.assignment_version == binding.assignment_version, "UPDATE_CATALOG_LOCAL_IDENTITY" ); let keys: UpdateKeyringFile = serde_json::from_slice(keys_raw)?; ensure!(keys.validate(), "UPDATE_CATALOG_KEYRING"); let mut trusted = Vec::new(); for key in &keys.keys { let public: [u8; 32] = hex::decode(&key.public_key_hex)? .try_into() .map_err(|_| anyhow::anyhow!("UPDATE_CATALOG_KEY_SIZE"))?; ensure!( key.platform == Platform::NATIVE_LINUX && key.public_key_hex != binding.public_key_hex, "UPDATE_CATALOG_KEY_SEPARATION" ); trusted.push(TrustedUpdateKey::new( public, Platform::NATIVE_LINUX.into(), key.first_sequence, key.last_sequence, key.revoked, )?); } let keyring = UpdateKeyring::new(keys.generation, trusted)?; let baseline = policy .initial_baseline .decode() .map_err(anyhow::Error::msg)?; ensure!( hash(&baseline.payload_bytes) == policy.initial_record_sha256, "UPDATE_CATALOG_BASELINE_BYTES" ); if let Some(guarded) = guarded { ensure!( guarded.bytes(policy_raw, keys_raw)? == record_raw, "UPDATE_CATALOG_GUARDED_HISTORY_REQUIRED" ); } else { ensure!( baseline.payload_bytes == record_raw, "UPDATE_CATALOG_GUARDED_HISTORY_REQUIRED" ); } let installed = InstalledReleaseRecord::from_bytes(record_raw).map_err(anyhow::Error::msg)?; let signer = keys .keys .iter() .find(|key| { hash(&hex::decode(&key.public_key_hex).unwrap_or_default()) == policy.initial_baseline.key_id }) .context("UPDATE_CATALOG_BASELINE_KEY")?; ensure!(!signer.revoked, "UPDATE_CATALOG_BASELINE_REVOKED"); let public = PKey::public_key_from_raw_bytes(&hex::decode(&signer.public_key_hex)?, Id::ED25519)?; let mut signed = BASELINE_SIGNATURE_DOMAIN.to_vec(); signed.extend_from_slice(&baseline.payload_bytes); ensure!( Verifier::new_without_digest(&public)?.verify_oneshot(&baseline.signature, &signed)?, "UPDATE_CATALOG_BASELINE_SIGNATURE" ); let decoded = installed .release_envelope .decode() .map_err(anyhow::Error::msg)?; let result = Self { files: vec![], keys: keyring, protocol: decoded.manifest.protocol_major, state: decoded.manifest.state_schema, generation: keys.generation, record: installed, }; result.release(&result.record.release_envelope, result.record.activated_at)?; Ok(result) } fn release( &self, envelope: &ReleaseEnvelope, now: u64, ) -> Result { let decoded = envelope.decode().map_err(anyhow::Error::msg)?; verify_release( SignedRelease { schema_version: envelope.schema_version, key_id: &envelope.key_id, payload_bytes: &decoded.payload_bytes, signature: &decoded.signature, }, &self.keys, &TrustedContext { platform: Platform::NATIVE_LINUX.into(), now_utc_seconds: now, keyring_generation: self.generation, protocol_major: self.protocol, state_schema: self.state, updater_version: 1, minimum_release_sequence: self.record.activation_floor, active_release: Some(ActiveRelease { sequence: self.record.activation_floor, manifest_sha256: self.record.manifest_sha256.clone(), }), }, ) } fn response(&self, bytes: &[u8], now: DateTime) -> Result { ensure!( !bytes.is_empty() && bytes.len() <= RESPONSE_LIMIT, "UPDATE_CATALOG_RESPONSE_LIMIT" ); let response: CatalogResponse = serde_json::from_slice(bytes)?; ensure!(!response.job_created, "UPDATE_CATALOG_UNEXPECTED_JOB"); match (response.status.as_str(), response.release) { ("not_configured", None) => Ok(empty(Status::NotConfigured)), ("available", Some(release)) => { ensure!( release .release_envelope .decode() .map_err(anyhow::Error::msg)? .manifest == release.manifest, "UPDATE_CATALOG_UNSIGNED_VIEW_CHANGED" ); let verified = self.release(&release.release_envelope, u64::try_from(now.timestamp())?)?; let manifest = verified.manifest(); Ok(Report { schema_version: 1, source_id: "mtls:release-catalog-v1".into(), checked_at: now, status: if verified.relation() == ReleaseRelation::SameActiveManifest { Status::Current } else { Status::Available }, candidate: Some(Candidate { release_id: manifest.release_id, release_sequence: manifest.release_sequence, version: manifest.version.clone(), manifest_sha256: verified.manifest_sha256().into(), keyring_generation: verified.keyring_generation(), }), }) } _ => anyhow::bail!("UPDATE_CATALOG_RESPONSE_SHAPE"), } } } #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct CatalogResponse { status: String, release: Option, #[serde(rename = "observed_at")] _observed_at: DateTime, #[serde(rename = "server_time")] _server_time: DateTime, job_created: bool, } #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct CatalogRelease { release_envelope: ReleaseEnvelope, manifest: ReleaseManifest, } async fn request( client: &reqwest::Client, address: SocketAddr, trust: &Trust, clock: &TrustedClock, ) -> Result<(Report, Option)> { ensure!(clock.trusted(), "UPDATE_CATALOG_CLOCK_UNTRUSTED"); let bytes = fetch(client, address).await?; ensure!(clock.trusted(), "UPDATE_CATALOG_CLOCK_UNTRUSTED"); for file in &trust.files { file.recheck()?; } let report = trust.response(&bytes, Utc::now())?; let response: CatalogResponse = serde_json::from_slice(&bytes)?; let release = response.release.map(|r| r.release_envelope); Ok((report, release)) } async fn fetch(client: &reqwest::Client, address: SocketAddr) -> Result> { let response = client .get(format!( "https://{}:{}/agent/v1/releases/current?platform={}", crate::https_channel::server_name()?, address.port(), Platform::NATIVE_LINUX.target_triple() )) .send() .await?; crate::https_channel::bounded_body(response, RESPONSE_LIMIT, "application/json").await } #[cfg(test)] mod tests { use super::*; use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD}; use openssl::{ pkey::Private, sign::Signer, ssl::{SslAcceptor, SslMethod, SslVerifyMode}, }; use rmm_domain::{ agent_update::{ArtifactDescriptor, ArtifactRole}, agent_update_provisioning::{ActivationEvidence, SignedBaselineRecord}, }; use serde_json::json; use std::{ io::Write, net::TcpListener, os::unix::fs::{PermissionsExt, symlink}, }; fn envelope( key: &PKey, sequence: u64, protocol: u32, state: u32, expires: u64, ) -> ReleaseEnvelope { let manifest = ReleaseManifest { schema_version: 1, release_id: Uuid::from_u128(sequence.into()), release_sequence: sequence, version: format!("test-{sequence}"), platform: Platform::LinuxX64, published_at: 1, expires_at: expires, protocol_major: protocol, state_schema: state, minimum_updater_version: 1, artifacts: [ ArtifactDescriptor { role: ArtifactRole::Agent, artifact_id: Uuid::from_u128(100), sha256: hash(b"test agent"), bytes: 10, }, ArtifactDescriptor { role: ArtifactRole::Helper, artifact_id: Uuid::from_u128(101), sha256: hash(b"test helper"), bytes: 11, }, ], }; let raw = serde_json::to_vec(&manifest).unwrap(); let mut signed = rmm_updater::RELEASE_SIGNATURE_DOMAIN.to_vec(); signed.extend_from_slice(&raw); ReleaseEnvelope { schema_version: 1, key_id: hash(&key.raw_public_key().unwrap()), payload_bytes: URL_SAFE_NO_PAD.encode(raw), signature: URL_SAFE_NO_PAD.encode( Signer::new_without_digest(key) .unwrap() .sign_oneshot_to_vec(&signed) .unwrap(), ), } } struct Fixture { trust: Trust, key: PKey, binding: Binding, policy: Vec, keys: Vec, record: Vec, } fn fixture() -> Fixture { let key = PKey::generate_ed25519().unwrap(); let binding = Binding { tenant_id: Uuid::new_v4(), asset_id: Uuid::new_v4(), agent_id: Uuid::new_v4(), enrollment_generation: 1, assignment_version: 2, public_key_hex: hex::encode( PKey::generate_ed25519().unwrap().raw_public_key().unwrap(), ), }; let release = envelope(&key, 7, 1, 1, u64::MAX); let record = InstalledReleaseRecord { schema_version: 1, profile: "decoder_compatible_handoff_v1".into(), platform: Platform::LinuxX64, manifest_sha256: hash(&release.decode().unwrap().payload_bytes), release_envelope: release, activation_floor: 7, activated_at: 2, previous_record_sha256: None, activation_evidence: ActivationEvidence::Bootstrap { qualification_receipt_sha256: hash(b"synthetic qualification"), }, rolled_back: false, } .bytes() .unwrap(); let mut signed = BASELINE_SIGNATURE_DOMAIN.to_vec(); signed.extend_from_slice(&record); let baseline = SignedBaselineRecord { schema_version: 1, key_id: hash(&key.raw_public_key().unwrap()), payload_bytes: URL_SAFE_NO_PAD.encode(&record), signature: URL_SAFE_NO_PAD.encode( Signer::new_without_digest(&key) .unwrap() .sign_oneshot_to_vec(&signed) .unwrap(), ), }; let keys = serde_json::to_vec(&json!({"schema_version":1,"generation":4,"keys":[{"public_key_hex":hex::encode(key.raw_public_key().unwrap()),"platform":"x86_64-unknown-linux-gnu","first_sequence":1,"last_sequence":20,"revoked":false}]})).unwrap(); let policy = serde_json::to_vec(&json!({"schema_version":1,"profile":"linux_general_full_v1","tenant_id":binding.tenant_id,"asset_id":binding.asset_id,"agent_id":binding.agent_id,"enrollment_generation":1,"assignment_version":2, "ledger_path":"/var/lib/rmm-helper/consumption.sqlite","lock_path":"/var/lib/rmm-helper/executor.lock","installed_record_path":RECORD,"keyring_path":KEYRING,"health_pin_path":"/etc/rmm-agent-updater/health-key.json","registry_path":"/etc/rmm-agent-updater/reader-registry.json","reader_registry_sha256":hash(b"fixture registry"), "services":[{"unit":"rmm-agent-remote.service","unit_sha256":hash(b"agent")},{"unit":"rmm-helper-cloud.service","unit_sha256":hash(b"general")},{"unit":"rmm-full-maintenance-helper.service","unit_sha256":hash(b"full")}],"updater_service":{"unit":"rmm-agent-updater.service","unit_sha256":hash(b"updater unit")},"updater_binary_sha256":hash(b"updater"),"initial_baseline":baseline,"initial_record_sha256":hash(&record),"initial_manifest_sha256":InstalledReleaseRecord::from_bytes(&record).unwrap().manifest_sha256,"initial_activation_floor":7})).unwrap(); let trust = Trust::verify(&binding, &policy, &keys, &record).unwrap(); Fixture { trust, key, binding, policy, keys, record, } } fn response(envelope: ReleaseEnvelope) -> Vec { serde_json::to_vec(&json!({"status":"available","release":{"manifest":envelope.decode().unwrap().manifest,"release_envelope":envelope},"observed_at":Utc::now(),"server_time":Utc::now(),"job_created":false})).unwrap() } #[test] fn catalog_binds_real_release_signatures_floor_protocol_expiry_and_separate_baseline() { let f = fixture(); let now = Utc::now(); assert_eq!( f.trust .response(&response(envelope(&f.key, 8, 1, 1, u64::MAX)), now) .unwrap() .status, Status::Available ); assert_eq!( f.trust .response(&response(envelope(&f.key, 7, 1, 1, u64::MAX)), now) .unwrap() .status, Status::Current ); for release in [ envelope(&f.key, 6, 1, 1, u64::MAX), envelope(&f.key, 8, 2, 1, u64::MAX), envelope(&f.key, 8, 1, 2, u64::MAX), envelope(&f.key, 8, 1, 1, 10), ] { assert!(f.trust.response(&response(release), now).is_err()); } let mut bad = envelope(&f.key, 8, 1, 1, u64::MAX); let mut signature = URL_SAFE_NO_PAD.decode(&bad.signature).unwrap(); signature[0] ^= 1; bad.signature = URL_SAFE_NO_PAD.encode(signature); assert!(f.trust.response(&response(bad), now).is_err()); let mut keys: serde_json::Value = serde_json::from_slice(&f.keys).unwrap(); keys["keys"][0]["revoked"] = json!(true); assert!( Trust::verify( &f.binding, &f.policy, &serde_json::to_vec(&keys).unwrap(), &f.record ) .is_err() ); let mut policy: serde_json::Value = serde_json::from_slice(&f.policy).unwrap(); policy["initial_baseline"]["signature"] = json!("A".repeat(86)); assert!( Trust::verify( &f.binding, &serde_json::to_vec(&policy).unwrap(), &f.keys, &f.record ) .is_err() ); let mut binding = f.binding.clone(); binding.public_key_hex = hex::encode(f.key.raw_public_key().unwrap()); assert!(Trust::verify(&binding, &f.policy, &f.keys, &f.record).is_err()); } #[test] fn catalog_rejects_unsigned_view_extra_fields_and_unqualified_record_floor() { let f = fixture(); let now = Utc::now(); let raw = response(envelope(&f.key, 8, 1, 1, u64::MAX)); for field in ["job", "view", "unknown", "missing"] { let mut changed: serde_json::Value = serde_json::from_slice(&raw).unwrap(); match field { "job" => changed["job_created"] = json!(true), "view" => changed["release"]["manifest"]["version"] = json!("unsigned"), "unknown" => changed["trusted"] = json!(true), _ => changed["release"] = serde_json::Value::Null, } assert!( f.trust .response(&serde_json::to_vec(&changed).unwrap(), now) .is_err() ); } assert!( f.trust .response(&vec![b' '; RESPONSE_LIMIT + 1], now) .is_err() ); let mut record = InstalledReleaseRecord::from_bytes(&f.record).unwrap(); record.activated_at += 1; assert!(Trust::verify(&f.binding, &f.policy, &f.keys, &record.bytes().unwrap()).is_err()); let mut binding = f.binding.clone(); binding.assignment_version += 1; assert!(Trust::verify(&binding, &f.policy, &f.keys, &f.record).is_err()); let empty = serde_json::to_vec(&json!({"status":"not_configured","release":null,"observed_at":now,"server_time":now,"job_created":false})).unwrap(); assert_eq!( f.trust.response(&empty, now).unwrap().status, Status::NotConfigured ); } #[test] fn public_anchors_are_read_only_protected_and_missing_configuration_never_builds_client() { // Normal unprivileged cargo test exercises rejection without requiring // chown/sudo. An isolated root run additionally covers the genuine // protected positive file/recheck branch; report that coverage separately. let root_fixture = unsafe { libc::geteuid() } == 0; let root = if root_fixture { PathBuf::from("/run") } else { std::env::temp_dir() } .join(format!("rmm-catalog-test-{}", Uuid::new_v4())); std::fs::create_dir(&root).unwrap(); std::fs::set_permissions(&root, std::fs::Permissions::from_mode(0o700)).unwrap(); let path = root.join("public.json"); std::fs::write(&path, b"public synthetic trust bytes").unwrap(); std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600)).unwrap(); let before = std::fs::metadata(&path).unwrap(); if !root_fixture { assert!(Protected::read(&path, 128).is_err()); assert_eq!(before.ino(), std::fs::metadata(&path).unwrap().ino()); std::fs::remove_dir_all(&root).unwrap(); } else { let held = Protected::read(&path, 128).unwrap(); held.recheck().unwrap(); assert_eq!(before.ino(), std::fs::metadata(&path).unwrap().ino()); let alias = root.join("alias"); symlink(&path, &alias).unwrap(); assert!(Protected::read(&alias, 128).is_err()); std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o622)).unwrap(); assert!(Protected::read(&path, 128).is_err()); std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600)).unwrap(); std::fs::write(&path, b"different synthetic public bytes").unwrap(); assert!(held.recheck().is_err()); drop(held); std::fs::remove_dir_all(&root).unwrap(); } let mut checker = Checker::default(); let report = checker.poll( None, TrustedClock::new(), "127.0.0.1:1".parse().unwrap(), None, || panic!("missing anchor must not load device TLS keys"), ); assert_eq!(report.status, Status::NotConfigured); let again = checker.poll( None, TrustedClock::new(), "127.0.0.1:1".parse().unwrap(), None, || panic!("cadence must not create client"), ); assert_eq!(report.checked_at, again.checked_at); } #[tokio::test] async fn actual_mtls_catalog_fetch_keeps_fixed_route_and_bounds_untrusted_http() { let f = fixture(); let name = crate::https_channel::server_name().unwrap(); let (ca, ca_key) = crate::runtime_tests::certificate("catalog test CA", None, false); let (server, server_key) = crate::runtime_tests::certificate(&name, Some((&ca, &ca_key)), true); let (device, device_key) = crate::runtime_tests::certificate("catalog test device", Some((&ca, &ca_key)), false); let cases = [ ("200 OK", response(envelope(&f.key, 8, 1, 1, u64::MAX))), ("302 Found", b"no redirect".to_vec()), ("200 OK", vec![b'x'; RESPONSE_LIMIT + 1]), ]; for (index, (status, body)) in cases.into_iter().enumerate() { let mut acceptor = SslAcceptor::mozilla_intermediate(SslMethod::tls_server()).unwrap(); acceptor.set_certificate(&server).unwrap(); acceptor.set_private_key(&server_key).unwrap(); acceptor.cert_store_mut().add_cert(ca.clone()).unwrap(); acceptor.set_verify(SslVerifyMode::PEER | SslVerifyMode::FAIL_IF_NO_PEER_CERT); let acceptor = acceptor.build(); let listener = TcpListener::bind("127.0.0.1:0").unwrap(); let address = listener.local_addr().unwrap(); let worker = std::thread::spawn(move || { let (socket, _) = listener.accept().unwrap(); socket .set_read_timeout(Some(Duration::from_secs(5))) .unwrap(); let mut tls = acceptor.accept(socket).unwrap(); assert!(tls.ssl().peer_certificate().is_some()); let mut request = Vec::new(); let mut byte = [0]; while !request.ends_with(b"\r\n\r\n") { tls.read_exact(&mut byte).unwrap(); request.push(byte[0]); assert!(request.len() < 8192); } let headers = String::from_utf8(request).unwrap(); assert!(headers.starts_with( "GET /agent/v1/releases/current?platform=x86_64-unknown-linux-gnu HTTP/1.1\r\n" )); assert!(!headers.to_ascii_lowercase().contains("authorization:")); let wire = format!( "HTTP/1.1 {status}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nLocation: https://unexpected.invalid/\r\nConnection: close\r\n\r\n", body.len() ); tls.write_all(wire.as_bytes()).unwrap(); let _ = tls.write_all(&body); }); let client = crate::https_channel::mtls_client( address, &ca.to_pem().unwrap(), &device.to_pem().unwrap(), &device_key.private_key_to_pem_pkcs8().unwrap(), ) .unwrap(); let result = fetch(&client, address).await; if index == 0 { assert_eq!( f.trust .response(&result.unwrap(), Utc::now()) .unwrap() .status, Status::Available ); } else { assert!(result.is_err()); } worker.join().unwrap(); } } } #[cfg(test)] mod wire_tests { use super::*; use prost::Message; use rmm_protocol::{Envelope, InventorySnapshot, Payload}; use serde_json::json; use sha2::Digest; #[test] fn catalog_wire_shape_is_accepted_by_original_linux_observation_contract() { let original = include_bytes!("../../../tests/agent_update/catalog-check-inventory.json"); let now = "2026-11-15T12:00:00Z".parse().unwrap(); let stored = rmm_domain::inventory_document::validate_for_scope(original, now, "linux.base") .unwrap(); assert_eq!( stored, serde_json::from_slice::(original).unwrap() ); let report: Report = serde_json::from_value(stored["observations"][0]["data"].clone()).unwrap(); let document = serde_json::to_vec(&report).unwrap(); assert_eq!(serde_json::from_slice::(&document).unwrap(), report); assert!(report.validate(now, now)); } #[test] fn normal_linux_snapshot_carries_cached_check_through_existing_scope_without_restamping_it() { let now = Utc::now(); let report = Report { schema_version: 1, source_id: "mtls:release-catalog-v1".into(), checked_at: now - chrono::Duration::hours(2), status: Status::Unavailable, candidate: None, }; let base = json!({"os":"Linux","hostname":"synthetic-codec","architecture":"x86_64","root_total_bytes":2,"root_available_bytes":1,"root_available_inodes":1, "collection_started_at":now,"collection_completed_at":now,"observations":[observation(report.clone(),now)]}); let data = serde_json::to_vec(&base).unwrap(); let envelope = Envelope { protocol_major: 1, protocol_minor: 0, message_id: Uuid::new_v4().to_string(), agent_id: Uuid::new_v4().to_string(), enrollment_generation: 1, connection_generation: 1, boot_id: Uuid::new_v4().to_string(), sequence: 1, observed_at: now.timestamp_millis(), payload: Some(Payload::InventorySnapshot(InventorySnapshot { snapshot_id: Uuid::new_v4().to_string(), scope: "linux.base".into(), schema_version: 1, chunk_index: 0, chunk_count: 1, sha256: sha2::Sha256::digest(&data).to_vec(), data, completeness: "partial".into(), })), }; let decoded = Envelope::decode(envelope.encode_to_vec().as_slice()).unwrap(); let Some(Payload::InventorySnapshot(snapshot)) = decoded.payload else { panic!("snapshot") }; let stored = rmm_domain::inventory_document::validate_for_scope( &snapshot.data, now, &snapshot.scope, ) .unwrap(); assert_eq!(stored, base); assert_eq!( stored["observations"][0]["data"]["checked_at"], json!(report.checked_at) ); // Exact pre-existing outer keys/scopes: old validators already support // bounded generic linux.* observations; no agent.update extension is sent. assert!(!stored.as_object().unwrap().contains_key("catalog_check")); assert_eq!( stored["observations"][0]["scope"], "linux.agent_update.catalog" ); for field in ["candidate", "schema", "time", "unknown"] { let mut bad = base.clone(); match field { "candidate" => bad["observations"][0]["data"]["candidate"] = json!({}), "schema" => bad["observations"][0]["data"]["schema_version"] = json!(2), "time" => { bad["observations"][0]["data"]["checked_at"] = json!(now + chrono::Duration::seconds(2)) } _ => bad["observations"][0]["data"]["ready"] = json!(true), } assert!( rmm_domain::inventory_document::validate_for_scope( &serde_json::to_vec(&bad).unwrap(), now, "linux.base" ) .is_err(), "catalog field must be denied: {field}" ); } let original = json!({"agent_update":rmm_domain::agent_update::AgentUpdateObservation::not_configured(Platform::LinuxX64,now)}); assert!( rmm_domain::inventory_document::validate_for_scope( &serde_json::to_vec(&original).unwrap(), now, "agent.update" ) .is_ok() ); let mut no_catalog = base; no_catalog.as_object_mut().unwrap().remove("observations"); no_catalog .as_object_mut() .unwrap() .remove("collection_started_at"); no_catalog .as_object_mut() .unwrap() .remove("collection_completed_at"); assert!( rmm_domain::inventory_document::validate_for_scope( &serde_json::to_vec(&no_catalog).unwrap(), now, "linux.base" ) .is_ok() ); } }