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
+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()
);
}
}