//! Administrative public metadata only. No files, keys, services or jobs written. use anyhow::{Result, ensure}; use ed25519_dalek::VerifyingKey; use rmm_domain::{ agent_update::{ReleaseEnvelope, ReleaseManifest, UpdateKeyringFile}, agent_update_provisioning::{HealthKeyPin, InstalledReleaseRecord, LocalUpdatePolicy}, jobs::hash, }; use serde::Deserialize; use std::io::Read; use uuid::Uuid; #[derive(Deserialize)] #[serde(tag = "operation", rename_all = "snake_case", deny_unknown_fields)] enum Input { RenderFull { config: Vec, pin: Vec, job_public_key_hex: String, new_helper_sha256: String, }, Registry { qualification_sha256: String, }, QualifyPair { minimum_generation: u64, expected_agent_sha256: String, expected_helper_sha256: String, unit_pins: Vec, }, ValidatePublicBundle { record: Vec, policy: Vec, keyring: Vec, health_pin: Vec, }, CanonicalRelease { manifest: ReleaseManifest, }, CanonicalRecord { record: InstalledReleaseRecord, }, CanonicalPolicy { policy: Box, }, ValidateRelease { envelope: ReleaseEnvelope, }, } /// Independent, read-only administrator sample after the coordinated pair /// bootstrap. Fresh normal server signatures are checked at the CURRENT native /// clock; neither old historical rows nor bootstrap metadata create a lease. fn qualify_pair( minimum_generation: u64, agent_sha256: &str, helper_sha256: &str, pins: &[rmm_domain::agent_update_provisioning::LocalServicePin], ) -> Result { use prost::Message; use rmm_agent_core::{ auth::Binding, auth::HelperIdentity, crypto::DalekVerifier, helper_reconcile::{SignedResponse, verify_checkpoint_repair_history_with}, reconcile::{Channel, SyncClock, verify_response_with}, }; use rmm_protocol::{SyncRequest, SyncResponse}; use rmm_updater_linux::{ Budget, services::{Service, ServicePolicy, Systemd}, }; use rusqlite::{Connection, OpenFlags}; use std::os::{fd::AsRawFd, unix::fs::MetadataExt}; ensure!( unsafe { libc::geteuid() } == 0 && minimum_generation > 0 && [agent_sha256, helper_sha256] .iter() .all(|v| rmm_domain::agent_update::digest(v)), "BOOTSTRAP_QUALIFICATION_SCOPE" ); let boot: Uuid = std::fs::read_to_string("/proc/sys/kernel/random/boot_id")? .trim() .parse()?; let budget = Budget::new(boot, std::time::Duration::from_secs(30))?; let clock = rmm_updater_worker::clock::NativeClock::new()?; let mut policies = Vec::new(); for (index, pin) in pins.iter().enumerate() { let service = match index { 0 => Service::Agent, 1 => Service::General, 2 => Service::Full, 3 => Service::Apt, _ => anyhow::bail!("BOOTSTRAP_UNIT_PIN_SET"), }; ensure!(pin.unit == service.unit(), "BOOTSTRAP_UNIT_PIN_SET"); policies.push(ServicePolicy { service, image_sha256: if index == 0 { agent_sha256 } else { helper_sha256 } .into(), unit_sha256: pin.unit_sha256.clone(), }); } let system = Systemd::new(policies)?; let held = [ system.observe(Service::Agent, &budget)?, system.observe(Service::General, &budget)?, system.observe(Service::Full, &budget)?, ]; if pins.len() == 4 { system.verify_inactive(Service::Apt, &budget)?; } let binding_path = std::path::Path::new("/var/lib/rmm-agent-remote/binding.json"); let metadata = std::fs::symlink_metadata(binding_path)?; ensure!( metadata.is_file() && !metadata.file_type().is_symlink() && metadata.uid() == 993 && metadata.nlink() == 1 && metadata.mode() & 0o077 == 0, "BOOTSTRAP_AGENT_PUBLIC_BINDING" ); let binding_raw = std::fs::read(binding_path)?; ensure!(binding_raw.len() <= 8192, "BOOTSTRAP_BINDING_LIMIT"); let mut binding: Binding = serde_json::from_slice(&binding_raw)?; #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct PublicKeyRecord { key_id:String, algorithm:String, schema_version:u32, public_key_hex:String } let mut effective = None; for (path,owner) in [("/var/lib/rmm-agent-remote/job-signing-key.json",993),("/etc/rmm-remote/helper-signing-key.json",0)] { let path=std::path::Path::new(path);let info=std::fs::symlink_metadata(path)?; ensure!(info.is_file()&&!info.file_type().is_symlink()&&info.uid()==owner&&info.nlink()==1&&info.mode()&0o022==0&&info.len()<=4096,"BOOTSTRAP_PROTECTED_PUBLIC_KEY_RECORD"); let raw=std::fs::read(path)?;let key:PublicKeyRecord=serde_json::from_slice(&raw)?;let public:[u8;32]=hex::decode(&key.public_key_hex)?.try_into().map_err(|_|anyhow::anyhow!("BOOTSTRAP_PUBLIC_KEY_SIZE"))?; ensure!(key.schema_version==1&&key.algorithm=="Ed25519"&&key.key_id==hash(&public)&&!VerifyingKey::from_bytes(&public)?.is_weak(),"BOOTSTRAP_PUBLIC_KEY_RECORD"); if let Some(old)=&effective{ensure!(old==&key.public_key_hex,"BOOTSTRAP_INDEPENDENT_KEY_PINS_DIFFER");}else{effective=Some(key.public_key_hex);} ensure!(std::fs::read(path)?==raw,"BOOTSTRAP_PUBLIC_KEY_RECORD_CHANGED"); } let effective=effective.ok_or_else(||anyhow::anyhow!("BOOTSTRAP_PUBLIC_KEY_REQUIRED"))?; ensure!(binding.public_key_hex.is_empty()||binding.public_key_hex==effective,"BOOTSTRAP_BINDING_PUBLIC_KEY");binding.public_key_hex=effective; let lock = std::fs::File::open("/var/lib/rmm-helper/executor.lock")?; ensure!( unsafe { libc::flock(lock.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } == 0, "BOOTSTRAP_HELPER_BUSY" ); let open = |path: &str| -> Result { ensure!( !std::path::Path::new(&format!("{path}-wal")).exists() && !std::path::Path::new(&format!("{path}-shm")).exists(), "BOOTSTRAP_DELETE_JOURNAL_REQUIRED" ); let db = Connection::open_with_flags( path, OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_NO_MUTEX, )?; db.busy_timeout(std::time::Duration::from_millis(250))?; db.execute_batch("PRAGMA query_only=ON;")?; ensure!( db.query_row("PRAGMA journal_mode", [], |r| r.get::<_, String>(0))? == "delete" && db.query_row("PRAGMA integrity_check", [], |r| r.get::<_, String>(0))? == "ok", "BOOTSTRAP_JOURNAL_INTEGRITY" ); Ok(db) }; let agent = open("/var/lib/rmm-agent-remote/journal.sqlite")?; let consumption = open("/var/lib/rmm-agent-remote/consumption.sqlite")?; let helper = open("/var/lib/rmm-helper/consumption.sqlite")?; ensure!(agent.query_row("SELECT count(*) FROM job_attempts WHERE state NOT IN ('succeeded','failed','cancelled','expired')",[],|r|r.get::<_,u64>(0))?==0,"BOOTSTRAP_OPEN_AGENT_JOB"); for db in [&consumption, &helper] { ensure!( db.query_row( "SELECT count(*) FROM consumed WHERE result IS NULL", [], |r| r.get::<_, u64>(0) )? == 0, "BOOTSTRAP_UNRESOLVED_CONSUMPTION" ); } let (generation,decision):(u64,String)=agent.query_row("SELECT generation,last_decision FROM reconcile_meta WHERE id=1 AND fault IS NULL AND pending_request IS NULL",[],|r|Ok((r.get(0)?,r.get(1)?)))?; ensure!( generation > minimum_generation, "BOOTSTRAP_NEW_GENERATION_REQUIRED" ); let (h_generation, h_decision): (u64, String) = helper.query_row( "SELECT generation,last_decision FROM helper_sync_meta WHERE id=1 AND fault IS NULL", [], |r| Ok((r.get(0)?, r.get(1)?)), )?; ensure!( generation == h_generation && decision == h_decision, "BOOTSTRAP_PAIR_NORMAL_SYNC_NOT_ALIGNED" ); let (hrequest, hresponse): (Vec, Vec) = helper.query_row( "SELECT request,response FROM helper_sync_decisions WHERE decision_id=?1", [&decision], |r| Ok((r.get(0)?, r.get(1)?)), )?; let signed: SignedResponse = serde_json::from_slice(&hresponse)?; let request = SyncRequest::decode(hrequest.as_slice())?; ensure!( request.encode_to_vec() == hrequest, "BOOTSTRAP_SYNC_REQUEST_CANONICAL" ); let response = SyncResponse { decision_bytes: signed.decision_bytes.clone(), signature: signed.signature.clone(), }; let applied = verify_response_with( &DalekVerifier, &binding, &request, &Channel { connection_generation: generation, boot_id: boot, }, &response, clock.now()?, )?; ensure!( applied.decision_id.to_string() == decision && applied.ready && applied.helper_ready && applied .attempts .iter() .all(|a| a.update_inflight.is_none() && a.outcome_state != "unknown"), "BOOTSTRAP_FRESH_NORMAL_SYNC_REQUIRED" ); let stored: Vec = agent.query_row( "SELECT response FROM reconcile_requests WHERE id=?1 AND generation=?2", rusqlite::params![request.request_id, generation], |r| r.get(0), )?; ensure!( SyncResponse::decode(stored.as_slice())? == response, "BOOTSTRAP_BOTH_NORMAL_ORIGINAL_RESPONSES" ); verify_checkpoint_repair_history_with( &helper, &binding, None, HelperIdentity::Root, &DalekVerifier, )?; for service in &held { service.verify(&budget)?; } ensure!( std::fs::read(binding_path)? == binding_raw, "BOOTSTRAP_BINDING_CHANGED" ); clock.now()?; budget.check()?; Ok( serde_json::json!({"schema_version":1,"profile":"linux_compatible_baseline_qualification_v1","boot_id":boot,"tenant_id":binding.tenant_id,"asset_id":binding.asset_id,"agent_id":binding.agent_id,"enrollment_generation":binding.enrollment_generation,"assignment_version":binding.assignment_version, "services":held.iter().map(|v|v.proof()).collect::>(),"normal_signed_sync_observed":true,"generation":generation,"decision_id":decision,"request_sha256":hash(&hrequest),"decision_sha256":hash(&signed.decision_bytes),"signature_sha256":hash(&signed.signature),"observed_at":clock.now()?,"ready":false,"helper_ready":false,"unlock":false,"job_authority":false,"apt_native_runtime_qualified":false}), ) } fn run() -> Result<()> { ensure!(std::env::args().count() == 1, "BOOTSTRAP_NO_ARGUMENTS"); let mut raw = Vec::new(); std::io::stdin() .take(512 * 1024 + 1) .read_to_end(&mut raw)?; ensure!(raw.len() <= 512 * 1024, "BOOTSTRAP_INPUT_LIMIT"); let output = match serde_json::from_slice::(&raw)? { Input::RenderFull { config, pin, job_public_key_hex, new_helper_sha256, } => { let key: [u8; 32] = hex::decode(job_public_key_hex)? .try_into() .map_err(|_| anyhow::anyhow!("BOOTSTRAP_PUBLIC_KEY_SIZE"))?; let key = VerifyingKey::from_bytes(&key)?; let value = rmm_updater_handoff::render_linux_full(&config, &pin, &new_helper_sha256, &key)?; serde_json::json!({"proof":value.proof(),"config":value.new_config_bytes(),"pin":value.new_pin_bytes()}) } Input::QualifyPair { minimum_generation, expected_agent_sha256, expected_helper_sha256, unit_pins, } => qualify_pair( minimum_generation, &expected_agent_sha256, &expected_helper_sha256, &unit_pins, )?, Input::Registry { qualification_sha256, } => { let boot: Uuid = std::fs::read_to_string("/proc/sys/kernel/random/boot_id")? .trim() .parse()?; let budget = rmm_updater_linux::Budget::new(boot, std::time::Duration::from_secs(30))?; serde_json::to_value(rmm_updater_worker::reader_registry::bootstrap_metadata( &qualification_sha256, &budget, )?)? } Input::CanonicalRelease { manifest } => { ensure!(manifest.validate(), "BOOTSTRAP_RELEASE_SHAPE"); let bytes = serde_json::to_vec(&manifest)?; serde_json::json!({"bytes":bytes,"sha256":hash(&bytes)}) } Input::CanonicalRecord { record } => { let bytes = record.bytes().map_err(anyhow::Error::msg)?; serde_json::json!({"bytes":bytes,"sha256":hash(&bytes)}) } Input::CanonicalPolicy { policy } => { ensure!(policy.validate(), "BOOTSTRAP_POLICY_SHAPE"); let bytes = serde_json::to_vec(&policy)?; serde_json::json!({"bytes":bytes,"sha256":hash(&bytes)}) } Input::ValidateRelease { envelope } => { let decoded = envelope.decode().map_err(anyhow::Error::msg)?; serde_json::json!({"manifest":decoded.manifest,"manifest_sha256":hash(&decoded.payload_bytes),"shape_only_not_signature_verified":true}) } Input::ValidatePublicBundle { record, policy, keyring, health_pin, } => { let installed = InstalledReleaseRecord::from_bytes(&record).map_err(anyhow::Error::msg)?; let (local, policy_sha256) = LocalUpdatePolicy::from_bytes(&policy).map_err(anyhow::Error::msg)?; let keys: UpdateKeyringFile = serde_json::from_slice(&keyring)?; let health: HealthKeyPin = serde_json::from_slice(&health_pin)?; ensure!( keys.validate() && health.validate() && local.initial_record_sha256 == hash(&record) && local.initial_activation_floor == installed.activation_floor, "BOOTSTRAP_PUBLIC_BUNDLE_SHAPE" ); serde_json::json!({"record_sha256":hash(&record),"policy_sha256":policy_sha256,"keyring_sha256":hash(&keyring),"health_pin_sha256":hash(&health_pin),"shape_only_not_signature_verified":true}) } }; println!("{}", serde_json::to_string(&output)?); Ok(()) } fn main() { if run().is_err() { eprintln!("LINUX_BOOTSTRAP_METADATA_FAILED"); std::process::exit(1) } }