Add gated agent update planning, preserved handoff and Linux worker ports
Rust development slice / linux (push) Failing after 6s

This commit is contained in:
2026-11-14 21:48:21 +01:00
parent dc9cb1b096
commit 1e89c4577f
82 changed files with 25052 additions and 69 deletions
+428
View File
@@ -0,0 +1,428 @@
//! Actual protected local policy/keyring/health/baseline verification. No key
//! returned in a job/manifest is promoted to trust and no floor is guessed.
use crate::{clock::NativeClock, original::Original};
use anyhow::{Context, Result, ensure};
use ed25519_dalek::{Signature, VerifyingKey};
use rmm_agent_core::{auth::Binding, reconcile::SyncClock};
use rmm_domain::{
agent_update::{Platform, UpdateKeyringFile},
agent_update_provisioning::{
ActivationEvidence, BASELINE_SIGNATURE_DOMAIN, HealthKeyPin, InstalledReleaseRecord,
LocalUpdatePolicy,
},
jobs::hash,
};
use rmm_updater::{
ActiveRelease, Platform as ReleasePlatform, SignedRelease, TrustedContext, TrustedUpdateKey,
UpdateKeyring, verify_release,
};
use rmm_updater_linux::files::{Directory, HeldFile};
use std::{ffi::OsStr, path::Path};
struct Protected {
dir: Directory,
file: HeldFile,
name: String,
max: u64,
}
impl Protected {
fn read(path: &Path, max: u64) -> Result<(Self, Vec<u8>)> {
let dir = Directory::open(path.parent().context("UPDATE_TRUST_PARENT")?, 0, false)?;
let name = path
.file_name()
.context("UPDATE_TRUST_NAME")?
.to_str()
.context("UPDATE_TRUST_NAME")?
.to_owned();
let mut file = dir.inspect(OsStr::new(&name), 0, max)?;
let raw = file.bytes(max)?;
Ok((
Self {
dir,
file,
name,
max,
},
raw,
))
}
fn verify(&self) -> Result<()> {
self.dir
.file(OsStr::new(&self.name), self.file.proof(), self.max)?;
Ok(())
}
}
pub struct TrustState {
protected: Vec<Protected>,
policy: LocalUpdatePolicy,
installed: InstalledReleaseRecord,
keyring: UpdateKeyring,
health_public_key: [u8; 32],
}
impl TrustState {
pub fn load(original: &Original, binding: &Binding, clock: &NativeClock) -> Result<Self> {
let update = original.update();
let mut protected = Vec::new();
let (file, raw) = Protected::read(Path::new("/etc/rmm-agent-updater/policy.json"), 65536)?;
let (policy, policy_hash) =
LocalUpdatePolicy::from_bytes(&raw).map_err(anyhow::Error::msg)?;
ensure!(
policy_hash == update.updater.policy_sha256
&& 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
&& policy.updater_binary_sha256 == update.updater.binary_sha256,
"UPDATE_PROTECTED_POLICY_CHANGED"
);
protected.push(file);
let (file, raw) = Protected::read(Path::new(&policy.keyring_path), 16384)?;
let keys: UpdateKeyringFile = serde_json::from_slice(&raw)?;
ensure!(
keys.validate()
&& keys.generation == update.updater.keyring_generation
&& hash(&raw) == update.updater.keyring_sha256,
"UPDATE_PROTECTED_KEYRING_CHANGED"
);
protected.push(file);
let job_key = hex::decode(&binding.public_key_hex)?;
let mut trusted = Vec::new();
let mut baseline_key = None;
for entry in &keys.keys {
ensure!(entry.platform == Platform::LinuxX64, "UPDATE_KEY_PLATFORM");
let public: [u8; 32] = hex::decode(&entry.public_key_hex)?
.try_into()
.map_err(|_| anyhow::anyhow!("UPDATE_KEY_SIZE"))?;
ensure!(
public.as_slice() != job_key,
"UPDATE_JOB_RELEASE_KEYS_NOT_SEPARATE"
);
if hash(&public) == policy.initial_baseline.key_id {
baseline_key = Some((entry, public));
}
trusted.push(TrustedUpdateKey::new(
public,
ReleasePlatform::LinuxX64,
entry.first_sequence,
entry.last_sequence,
entry.revoked,
)?);
}
let keyring = UpdateKeyring::new(keys.generation, trusted)?;
let baseline = policy
.initial_baseline
.decode()
.map_err(anyhow::Error::msg)?;
let (baseline_entry, public) = baseline_key.context("UPDATE_BASELINE_KEY_NOT_TRUSTED")?;
ensure!(
!baseline_entry.revoked
&& baseline
.record
.release_envelope
.decode()
.map_err(anyhow::Error::msg)?
.manifest
.release_sequence
>= baseline_entry.first_sequence
&& baseline
.record
.release_envelope
.decode()
.map_err(anyhow::Error::msg)?
.manifest
.release_sequence
<= baseline_entry.last_sequence,
"UPDATE_BASELINE_KEY_REVOKED_OR_RANGE"
);
let public = VerifyingKey::from_bytes(&public)?;
ensure!(!public.is_weak(), "UPDATE_BASELINE_WEAK_KEY");
let mut message = BASELINE_SIGNATURE_DOMAIN.to_vec();
message.extend_from_slice(&baseline.payload_bytes);
public.verify_strict(&message, &Signature::from_bytes(&baseline.signature))?;
let (file, raw) = Protected::read(Path::new(&policy.health_pin_path), 4096)?;
let health: HealthKeyPin = serde_json::from_slice(&raw)?;
let health_public_key = health.public_key().map_err(anyhow::Error::msg)?;
ensure!(
!VerifyingKey::from_bytes(&health_public_key)?.is_weak()
&& hash(&raw) == update.updater.health_key_pin_sha256
&& hex::encode(health_public_key) == update.updater.health_public_key_hex
&& health_public_key.as_slice() != job_key
&& keys
.keys
.iter()
.all(|key| key.public_key_hex != hex::encode(health_public_key)),
"UPDATE_HEALTH_KEY_NOT_SEPARATE_OR_CHANGED"
);
protected.push(file);
let (file, raw) = Protected::read(Path::new(&policy.installed_record_path), 32768)?;
ensure!(
hash(&raw) == update.predecessor.installed_record_sha256,
"UPDATE_INSTALLED_RECORD_CHANGED"
);
let installed = InstalledReleaseRecord::from_bytes(&raw).map_err(anyhow::Error::msg)?;
// This first concrete activation is bootstrap-bound. A future Updated
// predecessor must have its complete guarded Health/record chain proved;
// never accept its mutable fields merely because parsing succeeded.
ensure!(
matches!(
installed.activation_evidence,
ActivationEvidence::Bootstrap { .. }
) && raw == baseline.payload_bytes
&& hash(&raw) == policy.initial_record_sha256
&& installed.activation_floor == policy.initial_activation_floor,
"UPDATE_INSTALLED_CHAIN_NOT_QUALIFIED"
);
let active = installed
.release_envelope
.decode()
.map_err(anyhow::Error::msg)?;
ensure!(
active.manifest.release_id == update.predecessor.release_id
&& active.manifest.release_sequence == update.predecessor.release_sequence
&& installed.manifest_sha256 == update.predecessor.manifest_sha256
&& active.manifest.artifacts[0].sha256 == update.predecessor.agent_sha256
&& active.manifest.artifacts[1].sha256 == update.predecessor.helper_sha256,
"UPDATE_INSTALLED_PREDECESSOR_BINDING"
);
verify_installed_release(&keyring, &installed, keys.generation)?;
verify(
&keyring,
&update.release_envelope,
&TrustedContext {
platform: ReleasePlatform::LinuxX64,
now_utc_seconds: u64::try_from(clock.now()?.timestamp())?,
keyring_generation: keys.generation,
protocol_major: active.manifest.protocol_major,
state_schema: active.manifest.state_schema,
updater_version: 1,
minimum_release_sequence: installed.activation_floor,
active_release: Some(ActiveRelease {
sequence: active.manifest.release_sequence,
manifest_sha256: installed.manifest_sha256.clone(),
}),
},
)?;
protected.push(file);
Ok(Self {
protected,
policy,
installed,
keyring,
health_public_key,
})
}
pub fn recheck(&self, original: &Original, clock: &NativeClock) -> Result<()> {
for file in &self.protected {
file.verify()?;
}
let active = self
.installed
.release_envelope
.decode()
.map_err(anyhow::Error::msg)?;
verify(
&self.keyring,
&original.update().release_envelope,
&TrustedContext {
platform: ReleasePlatform::LinuxX64,
now_utc_seconds: u64::try_from(clock.now()?.timestamp())?,
keyring_generation: original.update().updater.keyring_generation,
protocol_major: active.manifest.protocol_major,
state_schema: active.manifest.state_schema,
updater_version: 1,
minimum_release_sequence: self.installed.activation_floor,
active_release: Some(ActiveRelease {
sequence: active.manifest.release_sequence,
manifest_sha256: self.installed.manifest_sha256.clone(),
}),
},
)
}
pub fn policy(&self) -> &LocalUpdatePolicy {
&self.policy
}
pub fn health_public_key(&self) -> [u8; 32] {
self.health_public_key
}
}
fn verify(
keyring: &UpdateKeyring,
envelope: &rmm_domain::agent_update::ReleaseEnvelope,
context: &TrustedContext,
) -> Result<()> {
let decoded = envelope.decode().map_err(anyhow::Error::msg)?;
verify_release(
SignedRelease {
schema_version: envelope.schema_version,
key_id: &envelope.key_id,
payload_bytes: &decoded.payload_bytes,
signature: &decoded.signature,
},
keyring,
context,
)?;
Ok(())
}
fn verify_installed_release(
keyring: &UpdateKeyring,
installed: &InstalledReleaseRecord,
generation: u64,
) -> Result<()> {
let active = installed
.release_envelope
.decode()
.map_err(anyhow::Error::msg)?;
verify(
keyring,
&installed.release_envelope,
&TrustedContext {
platform: ReleasePlatform::LinuxX64,
now_utc_seconds: installed.activated_at,
keyring_generation: generation,
protocol_major: active.manifest.protocol_major,
state_schema: active.manifest.state_schema,
updater_version: 1,
minimum_release_sequence: installed.activation_floor,
active_release: Some(ActiveRelease {
sequence: active.manifest.release_sequence,
manifest_sha256: installed.manifest_sha256.clone(),
}),
},
)
}
#[cfg(test)]
mod tests {
use super::*;
use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
use ed25519_dalek::{Signer, SigningKey};
use rmm_domain::agent_update::{
ArtifactDescriptor, ArtifactRole, ReleaseEnvelope, ReleaseManifest,
};
use rmm_domain::agent_update_provisioning::SignedBaselineRecord;
use uuid::Uuid;
fn release(sequence: u64, published: u64, expires: u64) -> ReleaseEnvelope {
let signer = SigningKey::from_bytes(&[83; 32]); // public TEST fixture only
let manifest = ReleaseManifest {
schema_version: 1,
release_id: Uuid::from_u128(u128::from(sequence)),
release_sequence: sequence,
version: format!("test-{sequence}"),
platform: Platform::LinuxX64,
published_at: published,
expires_at: expires,
protocol_major: 1,
state_schema: 1,
minimum_updater_version: 1,
artifacts: [
ArtifactDescriptor {
role: ArtifactRole::Agent,
artifact_id: Uuid::from_u128(101),
sha256: hash(b"test agent"),
bytes: 10,
},
ArtifactDescriptor {
role: ArtifactRole::Helper,
artifact_id: Uuid::from_u128(102),
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(signer.verifying_key().as_bytes()),
payload_bytes: URL_SAFE_NO_PAD.encode(raw),
signature: URL_SAFE_NO_PAD.encode(signer.sign(&signed).to_bytes()),
}
}
#[test]
fn separately_signed_baseline_at_floor_is_historical_only_and_candidate_stays_strict() {
let signer = SigningKey::from_bytes(&[83; 32]);
let keyring = UpdateKeyring::new(
7,
vec![
TrustedUpdateKey::new(
signer.verifying_key().to_bytes(),
ReleasePlatform::LinuxX64,
1,
20,
false,
)
.unwrap(),
],
)
.unwrap();
let envelope = release(7, 90, 110);
let record = InstalledReleaseRecord {
schema_version: 1,
profile: "decoder_compatible_handoff_v1".into(),
platform: Platform::LinuxX64,
manifest_sha256: hash(&envelope.decode().unwrap().payload_bytes),
release_envelope: envelope,
activation_floor: 7,
activated_at: 95,
previous_record_sha256: None,
activation_evidence: ActivationEvidence::Bootstrap {
qualification_receipt_sha256: hash(b"local synthetic qualification receipt"),
},
rolled_back: false,
};
let raw = record.bytes().unwrap();
let mut message = BASELINE_SIGNATURE_DOMAIN.to_vec();
message.extend_from_slice(&raw);
let baseline = SignedBaselineRecord {
schema_version: 1,
key_id: hash(signer.verifying_key().as_bytes()),
payload_bytes: URL_SAFE_NO_PAD.encode(&raw),
signature: URL_SAFE_NO_PAD.encode(signer.sign(&message).to_bytes()),
};
let decoded = baseline.decode().unwrap();
signer
.verifying_key()
.verify_strict(&message, &Signature::from_bytes(&decoded.signature))
.unwrap();
assert_eq!(decoded.payload_bytes, raw);
// Exercise the ACTUAL production context builder, where None at the
// confirmed floor previously rejected every legitimate initial record.
verify_installed_release(&keyring, &decoded.record, 7).unwrap();
let candidate_context = TrustedContext {
platform: ReleasePlatform::LinuxX64,
now_utc_seconds: 200,
keyring_generation: 7,
protocol_major: 1,
state_schema: 1,
updater_version: 1,
minimum_release_sequence: 7,
active_release: Some(ActiveRelease {
sequence: 7,
manifest_sha256: record.manifest_sha256.clone(),
}),
};
verify(&keyring, &release(8, 190, 210), &candidate_context).unwrap();
assert!(verify(&keyring, &release(7, 190, 210), &candidate_context).is_err());
assert!(verify(&keyring, &record.release_envelope, &candidate_context).is_err());
assert!(verify(&keyring, &release(6, 190, 210), &candidate_context).is_err());
let revoked = UpdateKeyring::new(
7,
vec![
TrustedUpdateKey::new(
signer.verifying_key().to_bytes(),
ReleasePlatform::LinuxX64,
1,
20,
true,
)
.unwrap(),
],
)
.unwrap();
assert!(verify_installed_release(&revoked, &record, 7).is_err());
}
}