Connect passive signed release checks to compatible Linux inventory
Rust development slice / linux (push) Failing after 6s
Rust development slice / linux (push) Failing after 6s
This commit is contained in:
@@ -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()
|
||||
);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user