Add gated agent update planning, preserved handoff and Linux worker ports
Rust development slice / linux (push) Failing after 6s
Rust development slice / linux (push) Failing after 6s
This commit is contained in:
@@ -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());
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user