diff --git a/Cargo.lock b/Cargo.lock index 7520d86..5f5b312 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2191,6 +2191,7 @@ dependencies = [ "rmm-domain", "rmm-privileged-helper", "rmm-protocol", + "rmm-updater", "rmm-updater-handoff", "rusqlite", "rustls", diff --git a/crates/agent/Cargo.toml b/crates/agent/Cargo.toml index 7027701..3c892e2 100644 --- a/crates/agent/Cargo.toml +++ b/crates/agent/Cargo.toml @@ -32,3 +32,5 @@ libc = "0.2.177" rmm-updater-handoff = { path = "../updater-handoff" } base64 = "=0.22.1" hex.workspace = true + +rmm-updater = { path = "../updater" } diff --git a/crates/agent/src/agent_update_catalog.rs b/crates/agent/src/agent_update_catalog.rs new file mode 100644 index 0000000..4d2bea6 --- /dev/null +++ b/crates/agent/src/agent_update_catalog.rs @@ -0,0 +1,966 @@ +//! 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, Platform as ReleasePlatform, 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, + task: tokio::task::JoinHandle<()>, +} +impl Drop for Pending { + fn drop(&mut self) { + self.task.abort(); + } +} +#[derive(Default)] +pub struct Checker { + report: Option, + started: Option, + pending: Option, +} +impl Checker { + 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, + client: impl FnOnce() -> Result, + ) -> Report { + if let Some(pending) = &mut self.pending { + match pending.receiver.try_recv() { + Ok(report) => { + self.report = Some(report); + self.pending.take(); + } + Err(oneshot::error::TryRecvError::Empty) => {} + Err(oneshot::error::TryRecvError::Closed) => { + self.report = Some(empty(Status::Unavailable)); + 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), + ) + }) + .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)); + 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) -> 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)?; + 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 { + 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::LinuxX64 && key.public_key_hex != binding.public_key_hex, + "UPDATE_CATALOG_KEY_SEPARATION" + ); + trusted.push(TrustedUpdateKey::new( + public, + ReleasePlatform::LinuxX64, + 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)?; + // Only the independently signed bootstrap can currently authenticate + // the floor here. Later Updated records require the separate guarded + // Full history observer; do not guess a floor from parsed root JSON. + ensure!( + baseline.payload_bytes == record_raw + && hash(record_raw) == policy.initial_record_sha256, + "UPDATE_CATALOG_GUARDED_HISTORY_REQUIRED" + ); + 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 = baseline + .record + .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: baseline.record, + }; + 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: ReleasePlatform::LinuxX64, + 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 { + 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()?; + } + trust.response(&bytes, Utc::now()) +} + +async fn fetch(client: &reqwest::Client, address: SocketAddr) -> Result> { + let response = client + .get(format!( + "https://{}:{}/agent/v1/releases/current?platform=x86_64-unknown-linux-gnu", + crate::https_channel::server_name()?, + address.port() + )) + .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(), + || 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(), + || 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() + ); + } +} diff --git a/crates/agent/src/main.rs b/crates/agent/src/main.rs index 79c1c3a..8927de3 100644 --- a/crates/agent/src/main.rs +++ b/crates/agent/src/main.rs @@ -1,3 +1,4 @@ +mod agent_update_catalog; mod agent_update_health; mod apt; mod bootstrap; @@ -60,6 +61,7 @@ struct Agent { mode: wire_channel::Mode, certificates: certificate_rotation::RotationStore, rotation_policy: certificate_rotation::RotationPolicy, + catalog: agent_update_catalog::Checker, } #[derive(Default)] struct EffectFence { @@ -495,7 +497,9 @@ impl Agent { let sender = self.inventory_tx.clone(); let extended = env::var("RMM_EXTENDED_INVENTORY").unwrap_or_else(|_| "1".into()) == "1"; let binding = self.binding.clone(); + let catalog = self.catalog.cached(Utc::now()); tokio::task::spawn_blocking(move || { + let collected_at = Utc::now(); let result = rmm_agent_linux::wire::snapshot(extended).and_then(|mut inventory| { if extended { inventory["observations"] @@ -504,6 +508,17 @@ impl Agent { .push(apt::planning_observation(binding.as_ref())); inventory["collection_completed_at"] = serde_json::json!(Utc::now()); } + if let Some(report) = catalog { + if inventory.get("observations").is_none() { + inventory["observations"] = serde_json::json!([]); + inventory["collection_started_at"] = serde_json::json!(collected_at); + } + inventory["observations"] + .as_array_mut() + .context("INVENTORY_OBSERVATIONS")? + .push(agent_update_catalog::observation(report, Utc::now())); + inventory["collection_completed_at"] = serde_json::json!(Utc::now()); + } let bytes = serde_json::to_vec(&inventory)?; ensure!(bytes.len() <= 512 * 1024, "INVENTORY_WIRE_LIMIT"); Ok((bytes, Utc::now().timestamp_millis())) @@ -522,6 +537,19 @@ impl Agent { rmm_domain::agent_update::Platform::LinuxX64, Utc::now(), ); + let address = self.address; + let ca = &self.ca; + let certificates = &self.certificates; + self.catalog + .poll(self.binding.as_ref(), self.clock.clone(), address, || { + let identity = certificates.current(Utc::now().timestamp())?; + https_channel::mtls_client( + address, + ca, + &identity.certificate_pem, + &identity.private_key_pem, + ) + }); let data = serde_json::to_vec(&serde_json::json!({"agent_update":observation}))?; let envelope = self.envelope( generation, @@ -988,6 +1016,7 @@ async fn main() -> Result<()> { mode, certificates, rotation_policy, + catalog: agent_update_catalog::Checker::default(), }; agent.recover_interrupted()?; let mut backoff = 1_u64; diff --git a/crates/agent/src/runtime_tests.rs b/crates/agent/src/runtime_tests.rs index f17a2c3..2c1a0ab 100644 --- a/crates/agent/src/runtime_tests.rs +++ b/crates/agent/src/runtime_tests.rs @@ -150,6 +150,7 @@ fn new_process_persists_interruption_before_helper_io_without_unlock_or_repeat() mode: wire_channel::Mode::Wss, certificates, rotation_policy: certificate_rotation::RotationPolicy::default(), + catalog: agent_update_catalog::Checker::default(), }; // A forged local consumption/start cannot become a purported grant result. agent @@ -219,7 +220,7 @@ impl reconcile::SyncClock for Clock { Ok(Utc::now()) } } -fn certificate( +pub(super) fn certificate( name: &str, issuer: Option<(&X509, &PKey)>, server: bool, @@ -537,6 +538,7 @@ async fn run(mode: wire_channel::Mode, trusted: bool, forged: bool, rounds: u64) mode, certificates, rotation_policy: certificate_rotation::RotationPolicy::default(), + catalog: agent_update_catalog::Checker::default(), }; for _ in 0..rounds { assert!( diff --git a/crates/domain/src/agent_update.rs b/crates/domain/src/agent_update.rs index f8ed398..2ab33d1 100644 --- a/crates/domain/src/agent_update.rs +++ b/crates/domain/src/agent_update.rs @@ -780,3 +780,63 @@ pub fn job_health_public_key(job: &crate::jobs::JobPayload) -> Result<[u8; 32], .try_into() .map_err(|_| "UPDATE_HEALTH_KEY") } + +/// Diagnostic catalog metadata inside the existing linux.base observations +/// vector. This is never an AgentUpdateObservation/CandidatePreview or authority. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)] +#[serde(rename_all = "snake_case")] +pub enum CatalogCheckStatus { + NotConfigured, + Unavailable, + Available, + Current, +} +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)] +#[serde(deny_unknown_fields)] +pub struct CatalogCandidate { + pub release_id: Uuid, + pub release_sequence: u64, + pub version: String, + pub manifest_sha256: String, + pub keyring_generation: u64, +} +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)] +#[serde(deny_unknown_fields)] +pub struct CatalogCheckReport { + pub schema_version: u32, + pub source_id: String, + /// Actual authenticated check, not the later cache/inventory collection. + pub checked_at: chrono::DateTime, + pub status: CatalogCheckStatus, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub candidate: Option, +} +impl CatalogCheckReport { + pub fn validate( + &self, + collected_at: chrono::DateTime, + now: chrono::DateTime, + ) -> bool { + self.schema_version == 1 + && self.source_id == "mtls:release-catalog-v1" + && self.checked_at <= collected_at + chrono::Duration::seconds(1) + && self.checked_at <= now + chrono::Duration::seconds(45) + && self.checked_at >= now - chrono::Duration::hours(72) + && match (&self.status, &self.candidate) { + (CatalogCheckStatus::Available | CatalogCheckStatus::Current, Some(candidate)) => { + !candidate.release_id.is_nil() + && candidate.release_sequence > 0 + && candidate.keyring_generation > 0 + && digest(&candidate.manifest_sha256) + && !candidate.version.is_empty() + && candidate.version.len() <= 64 + && candidate + .version + .bytes() + .all(|b| b.is_ascii_alphanumeric() || b".-+_".contains(&b)) + } + (CatalogCheckStatus::NotConfigured | CatalogCheckStatus::Unavailable, None) => true, + _ => false, + } + } +} diff --git a/crates/domain/src/inventory_document.rs b/crates/domain/src/inventory_document.rs index d37e43c..76775af 100644 --- a/crates/domain/src/inventory_document.rs +++ b/crates/domain/src/inventory_document.rs @@ -150,6 +150,26 @@ pub fn validate_for_scope( .data .get("host_reboot_required") .is_some_and(|v| !v.is_boolean()); + if o.scope == "linux.agent_update.catalog" { + let report: crate::agent_update::CatalogCheckReport = + serde_json::from_value(o.data.clone()) + .map_err(|_| "INVALID_AGENT_UPDATE_CATALOG_REPORT")?; + let quality = match report.status { + crate::agent_update::CatalogCheckStatus::Available + | crate::agent_update::CatalogCheckStatus::Current => "valid", + crate::agent_update::CatalogCheckStatus::NotConfigured => "unknown", + crate::agent_update::CatalogCheckStatus::Unavailable => "error", + }; + if scope != "linux.base" + || o.source_id != "agent:cached-release-catalog-v1" + || o.quality != quality + || o.completeness != "complete" + || o.truncated + || !report.validate(o.observed_at, now) + { + return Err("INVALID_AGENT_UPDATE_CATALOG_REPORT"); + } + } if !o.scope.starts_with(prefix) || o.scope.len() > 64 || !(o diff --git a/docs/agent-updater-passive-catalog.md b/docs/agent-updater-passive-catalog.md new file mode 100644 index 0000000..85c2d1a --- /dev/null +++ b/docs/agent-updater-passive-catalog.md @@ -0,0 +1,125 @@ +# Normaler passiver Releasekatalogcheck + +Stand2026-11-15. Der Linux-Agent ruft den vorhandenen Releasekatalog jetzt aus +seinem normalen `queue_update_observation`-Pfad auf. Dies ist ein passiver +Metadatencheck, kein Artefaktbezug, Staging, Job oder ausgeführtes Selbstupdate. + +## Aufruf, Vertrauen und Grenzen + +Der Collector startet höchstens einen Hintergrundrequest. Erfolgreiche Checks +werden nach24h erneuert; fehlende Konfiguration oder Fehler frühestens nach60s. +35s Gesamtfrist und64KiB Antwortlimit gelten zusätzlich zu den vorhandenen +mTLS-/HTTPgrenzen. Heartbeats, Cancel und SignedSync warten nicht auf HTTP. +Die URL bleibt `/agent/v1/releases/current` am bereits konfigurierten TLSnamen; +der vorhandene Connectoverride ändert ausschließlich das TCPziel. Keine +Weiterleitung, Umgebungsproxy-, System-CA- oder Jobsigner-Ersatzannahme. + +Verwendet werden ausschließlich die bereits vorgesehenen geschützten öffentlichen +Dateien `/etc/rmm-agent-updater/policy.json`, `keyring.json` und +`/var/lib/rmm-agent-updater/installed-record.json`. Eigentümer/Eltern sindRoot, +keine Symlinks oder gruppen-/weltbeschreibbaren Pfade; reguläre Dateien, +ein Hardlink, feste Größenlimits. Gehaltene FD-/Inode-/Metadaten-/Rawbytezeugen +werden nach dem Request erneut geprüft. Es entstehen keine lokalen Dateien, +keine Schlüsselprovisionierung und keine geänderten Dateirechte. + +Policyidentität muss zum vorhandenen Gerätebinding passen. Separater +Releasekeyring, aktuelle Widerrufe/Sequenzbereiche, echte Baseline- und +Releasesignaturen, Linuxplattform, qualifizierter Protokoll-/Statevertrag, +Updaterversion, Fristen und unveränderter Floor werden unabhängig geprüft. +Serverzeit und die zusätzliche unsignierte Manifestansicht ersetzen keine +lokale TrustedClock oder signierten Originalbytes; beide Manifestansichten +müssen übereinstimmen. Fehlende Anker ergeben `not_configured`, Transport-/TLS-/ +Prüfprobleme `unavailable`; gültige Metadaten ergeben `available` oder `current`. + +Dieser enge Erstanschluss akzeptiert als Flooranker ausschließlich die exakten +separat signierten Bootstrap-InstalledRecordbytes. Ein späterer `Updated`-Record +benötigt die noch fehlende unabhängig authentisierte read-only Fullhelper- +Historybeobachtung; bloßes Parsen der neueren Recorddatei erzeugt keine +Vertrauens- oder Floorfreigabe. Eine tatsächliche geschützte Konfiguration muss +für den unprivilegierten Agent lesbar provisioniert sein. Unlesbare Dateien +bleiben ehrlich unavailable; dieser Code lockert keine ACL. + +## Übertragung und Darstellung mit älteren Servern + +Der unveränderte `agent.update`-Snapshot erhält **kein zusätzliches Top-Level- +Feld**. Seine qualifizierte Vorgänger-/Fullpreview bleibt `not_configured`; +Katalogmetadaten sind keine `CandidatePreview` und eröffnen keine Check-/Applycap. + +Der gespeicherte Katalogbericht wird ausschließlich beim ohnehin geplanten +normalen Linuxinventar als begrenzte bestehende Unterbeobachtung +`linux.agent_update.catalog` übertragen. Kein zusätzlicher Basiscollect wird +angefordert. Dieser `linux.base`-/`observations`-Vertrag wird bereits von älteren +Servern angenommen; kein neues Protobuftag und keine neue Servercap sind nötig. +Die äußere Beobachtungszeit bezeichnet das Lesen des Caches. Das innere +`checked_at` bleibt die tatsächliche ursprüngliche Checkzeit und wird beim +Übertragen nicht erneuert. Über72h alte Cachewerte werden nicht neu angehängt. + +Der aktuelle Domain-Ingest validiert zusätzlich den bekannten Berichtstyp, +Qualität, Zeit, Kandidatenform und geschlossene Feldmenge. Altclients ohne diese +Beobachtung bleiben gültig. Die bestehende tenantgebundene Inventoryspeicherung +und Geräte-API transportieren dieselben geprüften Daten. Die WebUI zeigt Status, +echten Checkzeitpunkt, spätere Cachelesezeit und gegebenenfalls Version/Hash als +Text. Sie erzeugt keine Requests oder Bedienung zur Ausführung aus dem Bericht. +Gemeinsame synthetische Codecfixture: +`tests/agent_update/catalog-check-inventory.json`. + +## Tatsächliche lokale Prüfungen + +Im vorhandenen isolierten Rust1.99.1-Buildcontainer, Netzwerk aus: + +```text +cargo test --release --locked --offline -p rmm-agent -p rmm-domain --all-targets +cargo clippy --locked --offline -p rmm-agent -p rmm-domain --all-targets -- -D warnings +cargo fmt -p rmm-agent -p rmm-domain --check +``` + +Abschließend89Tests bestanden,0Fehler/ignorierte/gefilterte im gesamten Lauf +(Agentbinary32, weitere Agentintegration34, Domain23). Clippy und Formatcheck +bestanden. Web55/55 und Typecheck bestanden. Die sechs gezielten neuen Fälle +enthalten echte synthetische Ed25519-Baseline-/Releasebytes und einen tatsächlich +laufenden lokalen mTLS-Testserver mit eigener CA/Geräteidentität: fester Pfad, +Clientzertifikat, Antwort-/Redirect-/Größenverweigerung, Floor/Protokoll/Schema/ +Ablauf/Keywiderruf, fehlender Anker, falsche Baseline und unzulässige Recordbytes. +Der Wirefall durchläuft echte Protobufbytes bis zum tatsächlichen +`validate_for_scope`; UI und Rust benutzen dieselbe statische Datenfixture. + +Zusätzlich wurde exakt der positive Kompatibilitätsfall mit dem ursprünglich +unveränderten Ingestvalidator aus `c1d8eea` als privatem Datei-Mount ausgeführt: +1/1 bestanden. Nach diesem Altvalidatorlauf schlug ein nachfolgender Negativfall +zunächst fehl. Nach gezieltem Bereinigen der beiden betroffenen Pakete im eigenen +Buildcache und vollständigem Neubuild bestand der gesamte89er-Lauf. Die +Altvalidator-, erste Fehler- und abschließenden Logs bleiben getrennt erhalten; +der fehlgeschlagene Lauf ist kein Erfolgsbeleg. Ein erster unbenutzter Import +wurde ohne Warnungsunterdrückung korrigiert. + +Der öffentliche Datei-Guardtest benötigt keinRoot: Unprivilegiert beweist er die +Verweigerung des eigenen unprivilegierten/beschreibbaren Pfads. Nur der gesonderte +lokale Rootlauf prüft zusätzlich ein eigenes geschütztes positives Dateifixture. +Keine ungekennzeichnete Rootpflicht im neuen Test. Lokale Belege: +`devstate/updater-passive-catalog-d86dc473-3e5f-48d4-a196-3a0d618a8e4e/`. + +## Tatsächliche Cloud-Linux-Qualifikation + +Root führte auf der festgelegten Cloud-Linux-Test-VM am2026-11-15 um13:07:09UTC +exakt die sechs `agent_update_catalog::`-Fälle alsUID65534 aufx86-64 aus: +6bestanden,0Fehler,0ignorierte,26übrige Tests bewusst gefiltert, Exit0, +0stderr-Bytes. Der unprivilegierte Datei-Verweigerungszweig ist hierbei geprüft; +der privilegierte positive Dateizweig stammt ausschließlich aus dem lokalen +Rootlauf. mTLS verwendet auch auf der VM nur den eigenen Loopback-Testserver. +Dies ist kein Katalogabruf durch den installierten Produktagenten gegen den +Internetserver, keine Clock-/Fullhelper-/Applyqualifikation und kein Windowsbeleg. + +Exakte Testbinary-SHA256: +`e8fc4249db06510b6b680f5ddf7e1d539305c54741d1dea2fdc348883f205956`. +Erhaltener privater nativer Beleg: +`devstate/updater-passive-catalog-linux/4f3e5a4b-98a9-4acf-9106-dcdd4d5d1823/result.json`, +SHA256 `332c8903506bf17fa8c9a9a0f512bb64ad82867513d2885359a54a80e4750e6d`. + +## Nächster tatsächlicher Lieferweg + +Noch offen sind der qualifizierte read-only Fullobserver für aktuelle +Vorgänger-/Pin-/Historypreview, die normale unverbrauchte Fulladmission, +Agent-/Helper-Artefaktstaging vor Handoff, stabiler Updaterbootstrap und der +vollständige dauerhafte Rückweg. Agent `supported/accept` und Fullpolicy geben +weiterhin keinen Updatejob frei. Es wurde kein Agent installiert, Dienst +geändert, Code getauscht, Job angelegt oder genehmigt. Notebook nur Entwicklung. diff --git a/tests/agent_update/catalog-check-inventory.json b/tests/agent_update/catalog-check-inventory.json new file mode 100644 index 0000000..898ca44 --- /dev/null +++ b/tests/agent_update/catalog-check-inventory.json @@ -0,0 +1,34 @@ +{ + "os": "Linux", + "hostname": "synthetic-codec-only", + "architecture": "x86_64", + "root_total_bytes": 2, + "root_available_bytes": 1, + "root_available_inodes": 1, + "collection_started_at": "2026-11-15T12:00:00Z", + "collection_completed_at": "2026-11-15T12:00:00Z", + "observations": [ + { + "scope": "linux.agent_update.catalog", + "source_id": "agent:cached-release-catalog-v1", + "observed_at": "2026-11-15T12:00:00Z", + "quality": "valid", + "completeness": "complete", + "truncated": false, + "error_code": null, + "data": { + "schema_version": 1, + "source_id": "mtls:release-catalog-v1", + "checked_at": "2026-11-15T10:00:00Z", + "status": "available", + "candidate": { + "release_id": "11111111-1111-4111-8111-111111111111", + "release_sequence": 8, + "version": "0.1.8", + "manifest_sha256": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "keyring_generation": 4 + } + } + } + ] +} diff --git a/web/src/catalog-check.test.tsx b/web/src/catalog-check.test.tsx new file mode 100644 index 0000000..ccb5942 --- /dev/null +++ b/web/src/catalog-check.test.tsx @@ -0,0 +1,17 @@ +import { readFileSync } from 'node:fs'; +import { expect, it, vi } from 'vitest'; +import { renderToStaticMarkup } from 'react-dom/server'; +import { CatalogCheckNotice } from './catalog-check'; + +it('shows actual check time separately from later inventory cache reading without actions or requests', () => { + const fetch = vi.fn(); vi.stubGlobal('fetch', fetch); + try { + const device = { inventory: JSON.parse(readFileSync(new URL('../../tests/agent_update/catalog-check-inventory.json', import.meta.url),'utf8')) }; + const html = renderToStaticMarkup(); + for (const expected of ['2026-11-15T10:00:00Z', '2026-11-15T12:00:00Z', '0.1.8', 'available', 'keine Installation']) expect(html).toContain(expected); + expect(html).not.toMatch(/<(button|form|input|script)\b/); expect(fetch).not.toHaveBeenCalled(); + device.inventory.observations[0]!.data.candidate.version = ''; + expect(renderToStaticMarkup()).toContain('role="alert"'); + expect(renderToStaticMarkup()).toBe(''); + } finally { vi.unstubAllGlobals(); } +}); diff --git a/web/src/catalog-check.tsx b/web/src/catalog-check.tsx new file mode 100644 index 0000000..b6ec05c --- /dev/null +++ b/web/src/catalog-check.tsx @@ -0,0 +1,28 @@ +import type { RecordValue } from './api'; + +function object(value: unknown): RecordValue | null { return value !== null && typeof value === 'object' && !Array.isArray(value) ? value as RecordValue : null; } +const exact = (value: RecordValue, keys: string[]) => Object.keys(value).every(key => keys.includes(key)); +const date = (value: unknown): value is string => typeof value === 'string' && value.length <= 40 && Number.isFinite(Date.parse(value)); +const positive = (value: unknown) => Number.isSafeInteger(value) && Number(value) > 0; +export function CatalogCheckNotice({ device }: { device: unknown }) { + const inventory = object(object(device)?.inventory), entries = inventory?.observations; + if (!Array.isArray(entries)) return null; + const matches = entries.map(object).filter(entry => entry?.scope === 'linux.agent_update.catalog'); + if (!matches.length) return null; + const invalid =

Gespeicherter Releasekatalogcheck ist ungültig; kein Updatebeleg.

; + if (matches.length !== 1) return invalid; + const entry = matches[0]!, report = object(entry.data); + if (!report || entry.source_id !== 'agent:cached-release-catalog-v1' || entry.completeness !== 'complete' || entry.truncated !== false || !date(entry.observed_at) + || !exact(report, ['schema_version', 'source_id', 'checked_at', 'status', 'candidate']) || report.schema_version !== 1 || report.source_id !== 'mtls:release-catalog-v1' + || !date(report.checked_at) || Date.parse(report.checked_at) > Date.parse(entry.observed_at) + 1000) return invalid; + const status = report.status, candidate = object(report.candidate), available = status === 'available' || status === 'current'; + if (!(available || status === 'not_configured' || status === 'unavailable') || entry.quality !== (available ? 'valid' : status === 'not_configured' ? 'unknown' : 'error')) return invalid; + if (available ? !candidate || !exact(candidate, ['release_id', 'release_sequence', 'version', 'manifest_sha256', 'keyring_generation']) + || typeof candidate.release_id !== 'string' || !/^[a-f0-9]{8}(-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(candidate.release_id) + || !positive(candidate.release_sequence) || !positive(candidate.keyring_generation) || typeof candidate.version !== 'string' || !/^[A-Za-z0-9.+_-]{1,64}$/.test(candidate.version) + || typeof candidate.manifest_sha256 !== 'string' || !/^[a-f0-9]{64}$/.test(candidate.manifest_sha256) : Object.hasOwn(report, 'candidate')) return invalid; + return ; +} diff --git a/web/src/main.tsx b/web/src/main.tsx index 2aa2e24..e3b4144 100644 --- a/web/src/main.tsx +++ b/web/src/main.tsx @@ -1,3 +1,4 @@ +import { CatalogCheckNotice } from './catalog-check'; import React, { useEffect, useState } from 'react'; import { createRoot } from 'react-dom/client'; import { actions, Action, ApiError, authConfig, approvalBlockers, expectedStdout, objectId, page, Page, PlanInput, pretty, record, RecordValue, request, session, Session, stringField, tenant, tenantPath, validateInput, windowsPowerShellRemoteSignedProfile, fullMaintenanceScriptProfile } from './api'; @@ -97,7 +98,7 @@ function Devices({ tenantId, auth, selected, setSelected }: { tenantId: string; return

Geräte und gespeichertes Inventar

Präsenz, Datenfrische und fachliche Gesundheit sind unabhängig. „unreachable“ bedeutet nicht „ausgeschaltet“.

{!list.data ?

Lade Geräte …

: <>
{list.data.items.map(d => { const id = objectId(d, 'asset'); return ; })}
Fest auswählenGerät / Asset-IDPräsenz / GesundheitQuelle / QualitätErhebung / Alter / Empfang
setSelected(e.target.checked ? [...selected, id] : selected.filter(v => v !== id))}/>{id}{stringField(d, 'presence')} / {stringField(d, 'health')}Kontakt: {stringField(d, 'last_contact_at')}{stringField(d, 'source_id')} / {stringField(d, 'quality')}{stringField(d, 'completeness')}{stringField(d, 'observed_at')}Alter: · empfangen: {stringField(d, 'received_at')}
{!list.data.items.length &&

Keine sichtbaren Geräte in diesem Listenabschnitt.

} }

Fester Auswahlsnapshot ({selected.length}): {selected.join(', ') || 'keine Ziele'}

- {asset &&

Inventardetail {asset}

{detail.data && }
} + {asset &&

Inventardetail {asset}

{detail.data && <>}
}
; } const initialParameters: Record = {