Integrate passive release checking and its inventory view
Rust development slice / linux (push) Failing after 7s
Rust development slice / linux (push) Failing after 7s
This commit is contained in:
Generated
+1
@@ -2191,6 +2191,7 @@ dependencies = [
|
|||||||
"rmm-domain",
|
"rmm-domain",
|
||||||
"rmm-privileged-helper",
|
"rmm-privileged-helper",
|
||||||
"rmm-protocol",
|
"rmm-protocol",
|
||||||
|
"rmm-updater",
|
||||||
"rmm-updater-handoff",
|
"rmm-updater-handoff",
|
||||||
"rusqlite",
|
"rusqlite",
|
||||||
"rustls",
|
"rustls",
|
||||||
|
|||||||
@@ -32,3 +32,5 @@ libc = "0.2.177"
|
|||||||
rmm-updater-handoff = { path = "../updater-handoff" }
|
rmm-updater-handoff = { path = "../updater-handoff" }
|
||||||
base64 = "=0.22.1"
|
base64 = "=0.22.1"
|
||||||
hex.workspace = true
|
hex.workspace = true
|
||||||
|
|
||||||
|
rmm-updater = { path = "../updater" }
|
||||||
|
|||||||
@@ -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()
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -1,3 +1,4 @@
|
|||||||
|
mod agent_update_catalog;
|
||||||
mod agent_update_health;
|
mod agent_update_health;
|
||||||
mod apt;
|
mod apt;
|
||||||
mod bootstrap;
|
mod bootstrap;
|
||||||
@@ -60,6 +61,7 @@ struct Agent<C: reconcile::SyncClock = reconcile::NativeClock> {
|
|||||||
mode: wire_channel::Mode,
|
mode: wire_channel::Mode,
|
||||||
certificates: certificate_rotation::RotationStore,
|
certificates: certificate_rotation::RotationStore,
|
||||||
rotation_policy: certificate_rotation::RotationPolicy,
|
rotation_policy: certificate_rotation::RotationPolicy,
|
||||||
|
catalog: agent_update_catalog::Checker,
|
||||||
}
|
}
|
||||||
#[derive(Default)]
|
#[derive(Default)]
|
||||||
struct EffectFence {
|
struct EffectFence {
|
||||||
@@ -495,7 +497,9 @@ impl<C: reconcile::SyncClock> Agent<C> {
|
|||||||
let sender = self.inventory_tx.clone();
|
let sender = self.inventory_tx.clone();
|
||||||
let extended = env::var("RMM_EXTENDED_INVENTORY").unwrap_or_else(|_| "1".into()) == "1";
|
let extended = env::var("RMM_EXTENDED_INVENTORY").unwrap_or_else(|_| "1".into()) == "1";
|
||||||
let binding = self.binding.clone();
|
let binding = self.binding.clone();
|
||||||
|
let catalog = self.catalog.cached(Utc::now());
|
||||||
tokio::task::spawn_blocking(move || {
|
tokio::task::spawn_blocking(move || {
|
||||||
|
let collected_at = Utc::now();
|
||||||
let result = rmm_agent_linux::wire::snapshot(extended).and_then(|mut inventory| {
|
let result = rmm_agent_linux::wire::snapshot(extended).and_then(|mut inventory| {
|
||||||
if extended {
|
if extended {
|
||||||
inventory["observations"]
|
inventory["observations"]
|
||||||
@@ -504,6 +508,17 @@ impl<C: reconcile::SyncClock> Agent<C> {
|
|||||||
.push(apt::planning_observation(binding.as_ref()));
|
.push(apt::planning_observation(binding.as_ref()));
|
||||||
inventory["collection_completed_at"] = serde_json::json!(Utc::now());
|
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)?;
|
let bytes = serde_json::to_vec(&inventory)?;
|
||||||
ensure!(bytes.len() <= 512 * 1024, "INVENTORY_WIRE_LIMIT");
|
ensure!(bytes.len() <= 512 * 1024, "INVENTORY_WIRE_LIMIT");
|
||||||
Ok((bytes, Utc::now().timestamp_millis()))
|
Ok((bytes, Utc::now().timestamp_millis()))
|
||||||
@@ -522,6 +537,19 @@ impl<C: reconcile::SyncClock> Agent<C> {
|
|||||||
rmm_domain::agent_update::Platform::LinuxX64,
|
rmm_domain::agent_update::Platform::LinuxX64,
|
||||||
Utc::now(),
|
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 data = serde_json::to_vec(&serde_json::json!({"agent_update":observation}))?;
|
||||||
let envelope = self.envelope(
|
let envelope = self.envelope(
|
||||||
generation,
|
generation,
|
||||||
@@ -988,6 +1016,7 @@ async fn main() -> Result<()> {
|
|||||||
mode,
|
mode,
|
||||||
certificates,
|
certificates,
|
||||||
rotation_policy,
|
rotation_policy,
|
||||||
|
catalog: agent_update_catalog::Checker::default(),
|
||||||
};
|
};
|
||||||
agent.recover_interrupted()?;
|
agent.recover_interrupted()?;
|
||||||
let mut backoff = 1_u64;
|
let mut backoff = 1_u64;
|
||||||
|
|||||||
@@ -150,6 +150,7 @@ fn new_process_persists_interruption_before_helper_io_without_unlock_or_repeat()
|
|||||||
mode: wire_channel::Mode::Wss,
|
mode: wire_channel::Mode::Wss,
|
||||||
certificates,
|
certificates,
|
||||||
rotation_policy: certificate_rotation::RotationPolicy::default(),
|
rotation_policy: certificate_rotation::RotationPolicy::default(),
|
||||||
|
catalog: agent_update_catalog::Checker::default(),
|
||||||
};
|
};
|
||||||
// A forged local consumption/start cannot become a purported grant result.
|
// A forged local consumption/start cannot become a purported grant result.
|
||||||
agent
|
agent
|
||||||
@@ -219,7 +220,7 @@ impl reconcile::SyncClock for Clock {
|
|||||||
Ok(Utc::now())
|
Ok(Utc::now())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
fn certificate(
|
pub(super) fn certificate(
|
||||||
name: &str,
|
name: &str,
|
||||||
issuer: Option<(&X509, &PKey<openssl::pkey::Private>)>,
|
issuer: Option<(&X509, &PKey<openssl::pkey::Private>)>,
|
||||||
server: bool,
|
server: bool,
|
||||||
@@ -537,6 +538,7 @@ async fn run(mode: wire_channel::Mode, trusted: bool, forged: bool, rounds: u64)
|
|||||||
mode,
|
mode,
|
||||||
certificates,
|
certificates,
|
||||||
rotation_policy: certificate_rotation::RotationPolicy::default(),
|
rotation_policy: certificate_rotation::RotationPolicy::default(),
|
||||||
|
catalog: agent_update_catalog::Checker::default(),
|
||||||
};
|
};
|
||||||
for _ in 0..rounds {
|
for _ in 0..rounds {
|
||||||
assert!(
|
assert!(
|
||||||
|
|||||||
@@ -780,3 +780,63 @@ pub fn job_health_public_key(job: &crate::jobs::JobPayload) -> Result<[u8; 32],
|
|||||||
.try_into()
|
.try_into()
|
||||||
.map_err(|_| "UPDATE_HEALTH_KEY")
|
.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,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|||||||
@@ -150,6 +150,26 @@ pub fn validate_for_scope(
|
|||||||
.data
|
.data
|
||||||
.get("host_reboot_required")
|
.get("host_reboot_required")
|
||||||
.is_some_and(|v| !v.is_boolean());
|
.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)
|
if !o.scope.starts_with(prefix)
|
||||||
|| o.scope.len() > 64
|
|| o.scope.len() > 64
|
||||||
|| !(o
|
|| !(o
|
||||||
|
|||||||
@@ -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
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
]
|
||||||
|
}
|
||||||
@@ -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(); }
|
||||||
|
});
|
||||||
@@ -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
@@ -1,3 +1,4 @@
|
|||||||
|
import { CatalogCheckNotice } from './catalog-check';
|
||||||
import React, { useEffect, useState } from 'react';
|
import React, { useEffect, useState } from 'react';
|
||||||
import { createRoot } from 'react-dom/client';
|
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';
|
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}/>
|
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></>}
|
{!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>
|
<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>;
|
</section>;
|
||||||
}
|
}
|
||||||
const initialParameters: Record<Action, RecordValue> = {
|
const initialParameters: Record<Action, RecordValue> = {
|
||||||
|
|||||||
Reference in New Issue
Block a user