//! Typed, root-peer authenticated synchronization/policy IPC. No action or //! readiness flag supplied by the network process grants root authority. use crate::{ Binding, readiness::Identity, reconcile::{SignedResponse, Snapshot}, }; use anyhow::{Context, Result, ensure}; use serde::{Deserialize, Serialize, de::DeserializeOwned}; use std::{ fs, io::{Read, Write}, os::{ fd::AsRawFd, unix::{ fs::{FileTypeExt, MetadataExt}, net::UnixStream, }, }, path::Path, time::Duration, }; use uuid::Uuid; #[derive(Clone, Serialize, Deserialize)] #[serde(tag = "operation", deny_unknown_fields)] pub enum Request { #[serde(rename = "sync_snapshot_v1")] Snapshot { challenge: Uuid, identity: Identity, generation: u64, }, #[serde(rename = "sync_apply_v1")] Apply { challenge: Uuid, identity: Identity, response: SignedResponse, request_bytes: Vec, }, #[serde(rename = "general_policy_v1")] Policy { challenge: Uuid, identity: Identity }, } impl Request { pub fn binding(&self) -> (Uuid, &Identity) { match self { Self::Snapshot { challenge, identity, .. } | Self::Apply { challenge, identity, .. } | Self::Policy { challenge, identity, } => (*challenge, identity), } } } #[derive(Clone, Debug, Serialize, Deserialize)] #[serde(deny_unknown_fields)] pub struct Policy { pub schema_version: u32, pub profile: String, pub identity: Identity, pub allowed_services: Vec, pub allow_root_scripts: bool, pub allow_reboot: bool, #[serde( default, skip_serializing_if = "Option::is_none", deserialize_with = "rmm_domain::jobs::deserialize_script_profiles" )] pub allowed_script_profiles: Option>, #[serde( default, skip_serializing_if = "Option::is_none", deserialize_with = "rmm_domain::jobs::deserialize_optional_sha256" )] pub helper_binary_sha256: Option, } impl Policy { pub fn sha256(&self) -> Result { Ok(rmm_domain::jobs::hash(&serde_json::to_vec(self)?)) } } #[derive(Clone, Debug, Serialize, Deserialize)] #[serde(deny_unknown_fields)] pub struct Response { pub schema_version: u32, pub challenge: Uuid, pub identity: Identity, pub profile: String, pub policy_sha256: String, pub policy: Option, pub snapshot: Option, pub unlocked_grants: Vec, pub ledger_device: u64, pub ledger_inode: u64, pub lock_device: u64, pub lock_inode: u64, #[serde( default, skip_serializing_if = "Option::is_none", deserialize_with = "rmm_domain::jobs::deserialize_optional_sha256" )] pub helper_binary_sha256: Option, } #[derive(Clone, Debug, Serialize, Deserialize)] #[serde(deny_unknown_fields)] pub struct GeneralPin { pub schema_version: u32, pub profile: String, pub identity: Identity, pub policy_sha256: String, #[serde( default, skip_serializing_if = "Option::is_none", deserialize_with = "rmm_domain::jobs::deserialize_optional_sha256" )] pub helper_binary_sha256: Option, } impl GeneralPin { pub fn read(path: &Path, binding: &Binding) -> Result { trusted(path, false)?; ensure!(fs::metadata(path)?.len() <= 8192, "POLICY_PIN_LIMIT"); let pin: Self = serde_json::from_slice(&fs::read(path)?)?; ensure!( ((pin.schema_version == 1 && pin.profile == "general" && pin.helper_binary_sha256.is_none()) || (pin.schema_version == 2 && pin.profile == "full_maintenance_v1" && pin.helper_binary_sha256.as_ref().is_some_and(|h| digest(h)))) && pin.identity == Identity::from_binding(binding)? && digest(&pin.policy_sha256), "POLICY_PIN_BINDING" ); Ok(pin) } } fn digest(s: &str) -> bool { s.len() == 64 && s.bytes() .all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)) } pub fn trusted(path: &Path, socket: bool) -> Result<()> { ensure!(path.is_absolute(), "HELPER_ABSOLUTE_PATH"); for (index, parent) in path.ancestors().enumerate() { let m = fs::symlink_metadata(parent)?; ensure!( !m.file_type().is_symlink() && m.uid() == 0 && (m.mode() & 0o022 == 0 || (socket && index == 0 && m.mode() & 0o007 == 0)), "UNTRUSTED_HELPER_PATH" ); } ensure!( if socket { fs::symlink_metadata(path)?.file_type().is_socket() } else { fs::metadata(path)?.is_file() }, "HELPER_PATH_TYPE" ); Ok(()) } pub fn exchange( socket: &Path, request: &Q, timeout: Duration, max_response: usize, ) -> Result { trusted(socket, true)?; let mut stream = UnixStream::connect(socket)?; let mut credentials = std::mem::MaybeUninit::::uninit(); let mut size = std::mem::size_of::() as libc::socklen_t; // SAFETY: live socket and correctly aligned writable credentials storage. ensure!( unsafe { libc::getsockopt( stream.as_raw_fd(), libc::SOL_SOCKET, libc::SO_PEERCRED, credentials.as_mut_ptr().cast(), &mut size, ) } == 0 && size as usize == std::mem::size_of::(), "HELPER_PEER_CREDENTIALS" ); // SAFETY: successful getsockopt initialized the full credentials. ensure!( unsafe { credentials.assume_init() }.uid == 0, "HELPER_PEER_NOT_ROOT" ); stream.set_read_timeout(Some(timeout))?; stream.set_write_timeout(Some(Duration::from_secs(5)))?; let bytes = serde_json::to_vec(request)?; ensure!( bytes.len() <= 8 * 1024 * 1024, "HELPER_CONTROL_REQUEST_LIMIT" ); stream.write_all(&u32::try_from(bytes.len())?.to_be_bytes())?; stream.write_all(&bytes)?; let mut length = [0; 4]; stream.read_exact(&mut length)?; let length = u32::from_be_bytes(length) as usize; ensure!(length <= max_response, "HELPER_CONTROL_RESPONSE_LIMIT"); let mut bytes = vec![0; length]; stream.read_exact(&mut bytes)?; Ok(serde_json::from_slice(&bytes)?) } pub fn call(socket: &Path, binding: &Binding, request: &Request) -> Result { let response: Response = exchange(socket, request, Duration::from_secs(10), 8 * 1024 * 1024)?; validate_response(request, &response, binding)?; Ok(response) } pub fn validate_response(request: &Request, response: &Response, binding: &Binding) -> Result<()> { let (challenge, identity) = request.binding(); ensure!( !challenge.is_nil() && response.schema_version == 1 && response.challenge == challenge && &response.identity == identity && response.identity == Identity::from_binding(binding)? && matches!( response.profile.as_str(), "general" | "apt_only" | "full_maintenance_v1" ) && response.ledger_inode != 0 && response.lock_inode != 0 && if response.profile == "full_maintenance_v1" { response .helper_binary_sha256 .as_ref() .is_some_and(|h| digest(h)) } else { response.helper_binary_sha256.is_none() }, "HELPER_CONTROL_RESPONSE_BINDING" ); Ok(()) } pub fn general_probe(socket: &Path, binding: &Binding, pin: &GeneralPin) -> Result { let request = Request::Policy { challenge: Uuid::new_v4(), identity: Identity::from_binding(binding)?, }; let response = call(socket, binding, &request)?; let policy = response.policy.as_ref().context("GENERAL_POLICY_MISSING")?; ensure!( response.profile == pin.profile && policy.profile == pin.profile && ((policy.schema_version == 1 && policy.profile == "general" && policy.allowed_script_profiles.is_none() && policy.helper_binary_sha256.is_none() && pin.helper_binary_sha256.is_none()) || (policy.schema_version == 2 && policy.profile == "full_maintenance_v1" && policy.allowed_script_profiles.as_deref() == Some(&[rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1]) && policy.helper_binary_sha256 == pin.helper_binary_sha256 && response.helper_binary_sha256 == pin.helper_binary_sha256 && pin.helper_binary_sha256.is_some() && policy.allow_root_scripts && !policy.allow_reboot && policy.allowed_services.is_empty())) && response.policy_sha256 == pin.policy_sha256 && policy.sha256()? == pin.policy_sha256 && policy.identity == pin.identity, "GENERAL_POLICY_PROOF_MISMATCH" ); Ok(response) } #[cfg(test)] mod tests { use super::*; fn binding() -> Binding { Binding { tenant_id: Uuid::new_v4(), asset_id: Uuid::new_v4(), agent_id: Uuid::new_v4(), enrollment_generation: 1, assignment_version: 1, public_key_hex: hex::encode( openssl::pkey::PKey::generate_ed25519() .unwrap() .raw_public_key() .unwrap(), ), } } #[test] fn control_nonce_identity_and_profile_are_not_unsigned_readiness() { let b = binding(); let identity = Identity::from_binding(&b).unwrap(); let challenge = Uuid::new_v4(); let q = Request::Policy { challenge, identity: identity.clone(), }; let mut r = Response { schema_version: 1, challenge, identity, profile: "general".into(), policy_sha256: "ab".repeat(32), policy: None, snapshot: None, unlocked_grants: vec![], ledger_device: 1, ledger_inode: 2, lock_device: 1, lock_inode: 3, helper_binary_sha256: None, }; validate_response(&q, &r, &b).unwrap(); let legacy = serde_json::to_value(&r).unwrap(); assert!(legacy.get("helper_binary_sha256").is_none()); let mut null = legacy.clone(); null["helper_binary_sha256"] = serde_json::Value::Null; assert!(serde_json::from_value::(null).is_err()); r.profile = "full_maintenance_v1".into(); assert!(validate_response(&q, &r, &b).is_err()); r.helper_binary_sha256 = Some("ab".repeat(32)); validate_response(&q, &r, &b).unwrap(); r.profile = "general".into(); assert!(validate_response(&q, &r, &b).is_err()); r.helper_binary_sha256 = None; r.challenge = Uuid::new_v4(); assert!(validate_response(&q, &r, &b).is_err()); r.challenge = challenge; r.identity.assignment_version = 2; assert!(validate_response(&q, &r, &b).is_err()); r.identity = Identity::from_binding(&b).unwrap(); r.profile = "fake_root".into(); assert!(validate_response(&q, &r, &b).is_err()); } #[test] fn apply_preserves_original_signed_bytes_and_rejects_unlock_additions() { let b = binding(); let q = Request::Apply { challenge: Uuid::new_v4(), identity: Identity::from_binding(&b).unwrap(), response: SignedResponse { decision_bytes: b" exact signed bytes\n".to_vec(), signature: vec![7; 64], }, request_bytes: vec![10, 3, 1, 2, 3], }; let bytes = serde_json::to_vec(&q).unwrap(); let roundtrip: Request = serde_json::from_slice(&bytes).unwrap(); let Request::Apply { response, request_bytes, .. } = roundtrip else { panic!("wrong operation") }; assert_eq!(response.decision_bytes, b" exact signed bytes\n"); assert_eq!(request_bytes, vec![10, 3, 1, 2, 3]); let mut value = serde_json::to_value(q).unwrap(); value["unlock"] = serde_json::json!(true); assert!(serde_json::from_value::(value).is_err()); } #[test] fn general_policy_hash_binds_identity_units_and_broad_admin_flags() { let b = binding(); let p = Policy { schema_version: 1, profile: "general".into(), identity: Identity::from_binding(&b).unwrap(), allowed_services: vec!["rmm-acceptance.service".into()], allow_root_scripts: false, allow_reboot: false, allowed_script_profiles: None, helper_binary_sha256: None, }; let old = p.sha256().unwrap(); let mut changed = p.clone(); changed.allow_root_scripts = true; assert_ne!(old, changed.sha256().unwrap()); changed = p.clone(); changed.allowed_services.push("other.service".into()); assert_ne!(old, changed.sha256().unwrap()); changed = p; changed.identity.assignment_version += 1; assert_ne!(old, changed.sha256().unwrap()); } }