Connect passive signed release checks to compatible Linux inventory
Rust development slice / linux (push) Failing after 6s

This commit is contained in:
2026-11-15 14:11:06 +01:00
parent c1d8eea6b8
commit 098f32e24f
12 changed files with 1287 additions and 2 deletions
Generated
+1
View File
@@ -2191,6 +2191,7 @@ dependencies = [
"rmm-domain",
"rmm-privileged-helper",
"rmm-protocol",
"rmm-updater",
"rmm-updater-handoff",
"rusqlite",
"rustls",
+2
View File
@@ -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" }
+966
View File
@@ -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<Utc>) -> 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>,
task: tokio::task::JoinHandle<()>,
}
impl Drop for Pending {
fn drop(&mut self) {
self.task.abort();
}
}
#[derive(Default)]
pub struct Checker {
report: Option<Report>,
started: Option<Instant>,
pending: Option<Pending>,
}
impl Checker {
pub fn cached(&self, now: DateTime<Utc>) -> Option<Report> {
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<reqwest::Client>,
) -> 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<u8>,
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<Self> {
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<Protected>,
keys: UpdateKeyring,
record: InstalledReleaseRecord,
protocol: u32,
state: u32,
generation: u64,
}
impl Trust {
fn load(binding: &Binding, policy: &Path, keys: &Path, record: &Path) -> Result<Option<Self>> {
let result = (|| -> Result<Self> {
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::<std::io::Error>()
.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> {
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<rmm_updater::VerifiedRelease> {
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<Utc>) -> Result<Report> {
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<CatalogRelease>,
#[serde(rename = "observed_at")]
_observed_at: DateTime<Utc>,
#[serde(rename = "server_time")]
_server_time: DateTime<Utc>,
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> {
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<Vec<u8>> {
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<Private>,
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<Private>,
binding: Binding,
policy: Vec<u8>,
keys: Vec<u8>,
record: Vec<u8>,
}
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<u8> {
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::<serde_json::Value>(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::<Report>(&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()
);
}
}
+29
View File
@@ -1,3 +1,4 @@
mod agent_update_catalog;
mod agent_update_health;
mod apt;
mod bootstrap;
@@ -60,6 +61,7 @@ struct Agent<C: reconcile::SyncClock = reconcile::NativeClock> {
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<C: reconcile::SyncClock> Agent<C> {
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<C: reconcile::SyncClock> Agent<C> {
.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<C: reconcile::SyncClock> Agent<C> {
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;
+3 -1
View File
@@ -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<openssl::pkey::Private>)>,
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!(
+60
View File
@@ -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<chrono::Utc>,
pub status: CatalogCheckStatus,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub candidate: Option<CatalogCandidate>,
}
impl CatalogCheckReport {
pub fn validate(
&self,
collected_at: chrono::DateTime<chrono::Utc>,
now: chrono::DateTime<chrono::Utc>,
) -> 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,
}
}
}
+20
View File
@@ -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
+125
View File
@@ -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.
@@ -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
}
}
}
]
}
+17
View File
@@ -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(<CatalogCheckNotice device={device}/>);
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 = '<script>approve()</script>';
expect(renderToStaticMarkup(<CatalogCheckNotice device={device}/>)).toContain('role="alert"');
expect(renderToStaticMarkup(<CatalogCheckNotice device={{inventory:{}}}/>)).toBe('');
} finally { vi.unstubAllGlobals(); }
});
+28
View File
@@ -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 = <p role="alert">Gespeicherter Releasekatalogcheck ist ungültig; kein Updatebeleg.</p>;
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 <aside aria-label="Gespeicherter Releasekatalogcheck"><h4>Passiver Releasekatalogcheck</h4>
<p>Status: {String(status)} · geprüft: <time>{report.checked_at}</time></p><p>Cache im Inventar gelesen: <time>{entry.observed_at}</time></p>
{candidate && <p>Release: {String(candidate.version)} · Sequenz {String(candidate.release_sequence)}<br/>Manifest SHA-256: <code>{String(candidate.manifest_sha256)}</code></p>}
<p>Katalogmetadaten; keine Installation oder Ausführungserlaubnis.</p></aside>;
}
+2 -1
View File
@@ -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 <section><h2>Geräte und gespeichertes Inventar</h2><p>Präsenz, Datenfrische und fachliche Gesundheit sind unabhängig. „unreachable“ bedeutet nicht „ausgeschaltet“.</p><ErrorBox error={list.error}/>
{!list.data ? <p>Lade Geräte …</p> : <><PageStatus data={list.data}/><div className="table"><table><thead><tr><th>Fest auswählen</th><th>Gerät / Asset-ID</th><th>Präsenz / Gesundheit</th><th>Quelle / Qualität</th><th>Erhebung / Alter / Empfang</th></tr></thead><tbody>{list.data.items.map(d => { const id = objectId(d, 'asset'); return <tr key={id}><td><input aria-label={`Ziel ${id}`} type="checkbox" checked={selected.includes(id)} onChange={e => setSelected(e.target.checked ? [...selected, id] : selected.filter(v => v !== id))}/></td><td><button className="link" onClick={() => setAsset(id)}>{typeof d.hostname === 'string' ? d.hostname : id}</button><small>{id}</small></td><td>{stringField(d, 'presence')} / {stringField(d, 'health')}<small>Kontakt: {stringField(d, 'last_contact_at')}</small></td><td>{stringField(d, 'source_id')} / {stringField(d, 'quality')}<small>{stringField(d, 'completeness')}</small></td><td>{stringField(d, 'observed_at')}<small>Alter: <Age value={d.observed_at}/> · empfangen: {stringField(d, 'received_at')}</small></td></tr>; })}</tbody></table></div>{!list.data.items.length && <p>Keine sichtbaren Geräte in diesem Listenabschnitt.</p>}<button disabled={!cursor} onClick={() => setCursor(null)}>Erste Seite</button> <button disabled={!list.data.next_cursor} onClick={() => setCursor(list.data?.next_cursor ?? null)}>Nächste Seite</button></>}
<p>Fester Auswahlsnapshot ({selected.length}): {selected.join(', ') || 'keine Ziele'}</p>
{asset && <article><h3>Inventardetail {asset}</h3><ErrorBox error={detail.error}/>{detail.data && <JsonView value={detail.data} label="Inventar, Capabilities, Metriken, Dienste, Software, Updates, Logs und Quellen (soweit geliefert)"/>}<AdminControl auth={auth} path={tenantPath(tenantId, `/devices/${encodeURIComponent(asset)}/revocation`)} permission="devices:revoke" title="Geräteidentität widerrufen" warning="ACHTUNG: Widerruf unterbricht die Geräteverwaltung und sperrt neue Starts. Kein Entfernen aus einer Liste, kein Rollback. Wiederaufnahme erfordert einen gesonderten sicheren Enrollment-/Recoveryprozess." done={detail.reload}/></article>}
{asset && <article><h3>Inventardetail {asset}</h3><ErrorBox error={detail.error}/>{detail.data && <><CatalogCheckNotice device={detail.data}/><JsonView value={detail.data} label="Inventar, Capabilities, Metriken, Dienste, Software, Updates, Logs und Quellen (soweit geliefert)"/></>}<AdminControl auth={auth} path={tenantPath(tenantId, `/devices/${encodeURIComponent(asset)}/revocation`)} permission="devices:revoke" title="Geräteidentität widerrufen" warning="ACHTUNG: Widerruf unterbricht die Geräteverwaltung und sperrt neue Starts. Kein Entfernen aus einer Liste, kein Rollback. Wiederaufnahme erfordert einen gesonderten sicheren Enrollment-/Recoveryprozess." done={detail.reload}/></article>}
</section>;
}
const initialParameters: Record<Action, RecordValue> = {