//! FreeBSD peer credentials, boot identity and executor lock around the same //! independent HelperSync and consumption ledger used by the Linux root helper. use anyhow::{Context, Result, bail, ensure}; use prost::Message; use rmm_agent_core::{ auth::{Binding, Outcome, Request}, freebsd_clock::NativeClock, helper_reconcile::{self as h, BootSource, ExecutorLedgerGuard}, ledger, reconcile::{HelperSnapshot, SyncClock}, }; use rmm_agent_linux::actions::{Interpreter, ScriptRequest, run_script_controlled}; use rmm_domain::jobs::{Action, FULL_MAINTENANCE_CAPABILITY, JobPayload, hash}; use rmm_protocol::{SyncAttempt, SyncRequest, SyncResponse}; use rusqlite::{Connection, OptionalExtension}; use serde::{Deserialize, Serialize, de::DeserializeOwned}; use sha1::{Digest, Sha1}; use std::{ fs::{self, File, OpenOptions, Permissions}, io::{Read, Write}, os::{ fd::AsRawFd, unix::{ fs::{FileTypeExt, MetadataExt, OpenOptionsExt, PermissionsExt}, net::{UnixListener, UnixStream}, }, }, path::{Path, PathBuf}, process::Command, sync::atomic::{AtomicBool, Ordering}, time::Duration, }; use uuid::Uuid; const DIR: &str = "/var/db/discovery-root-jobs"; const SOCK: &str = "/var/run/discovery-root-jobs/control.sock"; pub const POLICY: &str = "/usr/local/etc/discovery-agent/root-policy.json"; const BINDING: &str = "/usr/local/etc/discovery-agent/job-binding.json"; const LIMIT: usize = 8 * 1024 * 1024; #[derive(Serialize, Deserialize)] #[serde(deny_unknown_fields)] struct Policy { schema_version: u8, profile: String, agent_uid: u32, agent_gid: u32, binding_sha256: String, helper_binary_sha256: String, } fn protected(path: &Path) -> Result<()> { for p in path.ancestors() { let m = fs::symlink_metadata(p)?; ensure!( m.uid() == 0 && m.mode() & 0o022 == 0 && !m.is_symlink() && (if p == path { m.is_file() || m.is_dir() } else { m.is_dir() }), "UNPROTECTED_ROOT_PATH" ); } Ok(()) } fn config() -> Result<(Policy, Binding, String)> { protected(Path::new(POLICY))?; protected(Path::new(BINDING))?; let raw = fs::read(POLICY)?; ensure!(raw.len() <= 8192, "POLICY_SIZE"); let p: Policy = serde_json::from_slice(&raw)?; let bytes = fs::read(BINDING)?; ensure!( p.schema_version == 1 && p.profile == "full_maintenance_v1" && p.agent_uid > 0 && p.agent_gid > 0 && p.binding_sha256 == hash(&bytes) && rmm_domain::agent_update::digest(&p.helper_binary_sha256), "POLICY_INVALID" ); Ok((p, serde_json::from_slice(&bytes)?, hash(&raw))) } struct Boot(Uuid); impl BootSource for Boot { fn current_boot(&self) -> Result { // Same UUIDv5 derivation as the already enrolled Python agent. Obtain // boottime independently, never trust a value supplied on the socket. let r = Command::new("/sbin/sysctl") .args(["-n", "kern.boottime"]) .env_clear() .output()?; ensure!(r.status.success(), "BOOT_UNAVAILABLE"); let s = std::str::from_utf8(&r.stdout)? .split_once('}') .context("BOOT_FORMAT")? .0; let mut sha = Sha1::new(); sha.update(self.0.as_bytes()); sha.update(s.as_bytes()); let mut b: [u8; 16] = sha.finalize()[..16].try_into()?; b[6] = (b[6] & 15) | 0x50; b[8] = (b[8] & 63) | 0x80; Ok(Uuid::from_bytes(b)) } } struct Guard { _lock: File, db_file: File, } impl ExecutorLedgerGuard for Guard { fn check(&self, db: &Connection) -> Result<()> { let path: String = db.query_row( "SELECT file FROM pragma_database_list WHERE name='main'", [], |r| r.get(0), )?; ensure!( Path::new(&path) == Path::new(DIR).join("consumption.sqlite"), "WRONG_HELPER_LEDGER" ); let m = fs::symlink_metadata(path)?; let f = self.db_file.metadata()?; ensure!( m.uid() == 0 && m.mode() & 0o077 == 0 && m.is_file() && (m.dev(), m.ino()) == (f.dev(), f.ino()), "HELPER_LEDGER_REPLACED" ); Ok(()) } } fn peer(s: &UnixStream) -> Result { let (mut uid, mut gid) = (u32::MAX, u32::MAX); ensure!( unsafe { libc::getpeereid(s.as_raw_fd(), &mut uid, &mut gid) } == 0, "PEER_IDENTITY" ); Ok(uid) } fn frame(s: &mut UnixStream, value: &T) -> Result<()> { let bytes = serde_json::to_vec(value)?; ensure!(bytes.len() <= LIMIT, "IPC_SIZE"); s.write_all(&(bytes.len() as u32).to_be_bytes())?; s.write_all(&bytes)?; Ok(()) } fn read(s: &mut UnixStream) -> Result { let mut len = [0; 4]; s.read_exact(&mut len)?; let n = u32::from_be_bytes(len) as usize; ensure!((1..=LIMIT).contains(&n), "IPC_SIZE"); let mut b = vec![0; n]; s.read_exact(&mut b)?; Ok(serde_json::from_slice(&b)?) } #[derive(Serialize, Deserialize)] enum Op { Probe, Snapshot(u64), Apply(Vec, h::SignedResponse), Execute(u64, Request), } #[derive(Serialize, Deserialize)] struct Call { nonce: Uuid, policy: String, image: String, op: Op, } #[derive(Serialize, Deserialize)] enum Data { Pins, Snapshot(h::Snapshot), Outcome(Outcome), } #[derive(Serialize, Deserialize)] struct Reply { nonce: Uuid, data: Data, } fn connect(op: Op) -> Result<(UnixStream, Uuid)> { let (p, _, policy) = config()?; let s = Path::new(SOCK); protected(s.parent().unwrap())?; let m = fs::symlink_metadata(s)?; ensure!( m.file_type().is_socket() && m.uid() == 0 && m.gid() == p.agent_gid && m.mode() & 7 == 0, "HELPER_SOCKET_MODE" ); let mut s = UnixStream::connect(s)?; ensure!(peer(&s)? == 0, "HELPER_NOT_ROOT"); s.set_read_timeout(Some(Duration::from_secs(12)))?; s.set_write_timeout(Some(Duration::from_secs(5)))?; let nonce = Uuid::new_v4(); frame( &mut s, &Call { nonce, policy, image: p.helper_binary_sha256, op, }, )?; Ok((s, nonce)) } fn call(op: Op) -> Result { let (mut s, n) = connect(op)?; let r: Reply = read(&mut s)?; ensure!(r.nonce == n, "HELPER_CHALLENGE"); Ok(r.data) } pub fn caps() -> Result> { let (p, _, policy) = config()?; ensure!(matches!(call(Op::Probe)?, Data::Pins), "HELPER_PROBE"); Ok(vec![ "opnsense.root.posix/1".into(), "helper.root.v1".into(), "root:run_script".into(), FULL_MAINTENANCE_CAPABILITY.into(), format!("helper.binary.sha256:{}", p.helper_binary_sha256), format!("helper.policy.sha256:{policy}"), ]) } fn mapped(data: Data) -> Result { let Data::Snapshot(s) = data else { bail!("HELPER_SNAPSHOT") }; Ok(HelperSnapshot { journal_id: s.journal_id, checkpoint: s.checkpoint, previous_decision_id: s.previous_decision_id, attempts: s .attempts .into_iter() .map(|a| SyncAttempt { job_id: a.job_id.to_string(), attempt_id: a.attempt_id.to_string(), job_payload_hash: a.job_payload_hash, grant_id: a.grant_id.to_string(), consumption: a.consumption, state: a.state, revision: a.revision, original_boot_id: a.original_boot_id.to_string(), outcome_sha256: a.outcome_sha256, outcome_bytes: a.outcome_bytes, ..Default::default() }) .collect(), }) } pub fn snapshot(g: u64) -> Result { mapped(call(Op::Snapshot(g))?) } pub fn apply(q: &SyncRequest, s: &SyncResponse) -> Result { mapped(call(Op::Apply( q.encode_to_vec(), h::SignedResponse { decision_bytes: s.decision_bytes.clone(), signature: s.signature.clone(), }, ))?) } pub fn execute(g: u64, req: Request, cancel: &AtomicBool, seconds: u32) -> Result { let (mut s, n) = connect(Op::Execute(g, req))?; let started = std::time::Instant::now(); // Poll only for response availability. On cancellation dropping the stream // fences the root executor, which records the actual result in its own DB. loop { ensure!( !cancel.load(Ordering::Acquire) && started.elapsed() < Duration::from_secs(u64::from(seconds) + 12), "CALLER_FENCED" ); let mut fd = libc::pollfd { fd: s.as_raw_fd(), events: libc::POLLIN, revents: 0, }; let r = unsafe { libc::poll(&mut fd, 1, 100) }; if r < 0 { return Err(std::io::Error::last_os_error().into()); } if r != 0 { break; } } let r: Reply = read(&mut s)?; ensure!(r.nonce == n, "HELPER_CHALLENGE"); let Data::Outcome(o) = r.data else { bail!("HELPER_RESULT") }; Ok(o) } pub fn supported(j: &JobPayload) -> bool { j.execution_identity == "root" && j.action.opnsense_root_script() && j.action .valid_job_limits(j.max_runtime_seconds, j.max_output_bytes) } struct Helper { db: Connection, guard: Guard, b: Binding, clock: NativeClock, boot: Boot, sync: h::HelperSync, p: Policy, policy: String, image: PathBuf, } impl Helper { fn invoke(&mut self, s: &mut UnixStream) -> Result<()> { ensure!(peer(s)? == self.p.agent_uid, "AGENT_PEER_DENIED"); s.set_read_timeout(Some(Duration::from_secs(5)))?; s.set_write_timeout(Some(Duration::from_secs(5)))?; let Call { nonce, policy, image, op, } = read(s)?; ensure!( !nonce.is_nil() && policy == self.policy && image == self.p.helper_binary_sha256, "PIN_MISMATCH" ); let data = match op { Op::Probe => Data::Pins, Op::Snapshot(g) => Data::Snapshot(self.sync.snapshot( &mut self.db, &self.guard, g, &self.clock, &self.boot, )?), Op::Apply(q, r) => Data::Snapshot( self.sync .apply(&mut self.db, &self.guard, &r, &q, &self.clock, &self.boot)? .snapshot, ), Op::Execute(g, req) => { let (lo, hi) = self.clock.bounds()?; let (job, grant) = self.b.verify(&req, lo)?; self.b.verify(&req, hi)?; ensure!(supported(&job), "ROOT_PROFILE_REQUIRED"); self.guard.check(&self.db)?; let prior:Option>>=self.db.query_row("SELECT COALESCE(result,(SELECT outcome FROM execution_evidence e WHERE e.grant_id=c.grant_id)) FROM consumed c WHERE grant_id=?1", [grant.grant_id.to_string()],|r|r.get(0)).optional()?; if let Some(old) = prior { Data::Outcome(match old { Some(bytes) => serde_json::from_slice(&bytes)?, None => Outcome::unknown("PREVIOUS_EFFECT_UNRESOLVED"), }) } else { let Action::RunScript { script_utf8, arguments, expected_stdout, .. } = &job.action else { bail!("SCRIPT_REQUIRED") }; let script = ScriptRequest::new( script_utf8.as_bytes().to_vec(), Interpreter::PosixSh, arguments.clone(), Duration::from_secs(job.max_runtime_seconds.into()), job.max_output_bytes as usize, )?; ensure!( self.sync .can_start(&self.db, &self.guard, g, &self.clock, &self.boot), "HELPER_SYNC_REQUIRED" ); let until = self.sync.validity_deadline().context("HELPER_LEASE")?; ensure!( hash(&fs::read(&self.image)?) == image && config()?.2 == policy, "HELPER_POLICY_CHANGED" ); ledger::begin_execution( &mut self.db, &grant, &req, self.boot.current_boot()?, self.clock.now()?, )?; let mut first = true; let res = run_script_controlled(&script, || { let (lo, hi) = self.clock.bounds()?; if first { ensure!(hi < until, "HELPER_LEASE_EXPIRED"); self.b.verify(&req, lo)?; self.b.verify(&req, hi)?; first = false; } let mut byte = 0u8; let rc = unsafe { libc::recv( s.as_raw_fd(), (&mut byte as *mut u8).cast(), 1, libc::MSG_PEEK | libc::MSG_DONTWAIT, ) }; ensure!( rc < 0 && std::io::Error::last_os_error().kind() == std::io::ErrorKind::WouldBlock, "CALLER_FENCED" ); Ok(()) }); let out = match res { Err(_) => Outcome::unknown("HELPER_SCRIPT_EFFECT_UNKNOWN"), Ok(o) => { let unknown = o.interrupted || o.timed_out || o.code.is_none(); let ok = !unknown && o.code == Some(0) && expected_stdout .as_ref() .is_none_or(|v| !o.truncated && o.stdout == v.as_bytes()); Outcome { state: if unknown { "unknown" } else if ok { "succeeded" } else { "failed" } .into(), stdout: o.stdout, stderr: o.stderr, output_truncated: o.truncated, reboot_required: false, exit_code: o.code, evidence: serde_json::json!({ "postconditions_passed":ok,"script_sha256":hash(script_utf8.as_bytes()),"execution_uid":unsafe{libc::geteuid()}, "privileged_script_profile":"full_maintenance_v1","output_encoding":"raw_native_bytes","termination_does_not_prove_absence_of_effects":unknown}), error_code: if unknown { "HELPER_SCRIPT_EFFECT_UNKNOWN" } else if ok { "" } else { "SCRIPT_POSTCONDITION_FAILED" } .into(), } } }; ledger::finish(&self.db, &grant, &out)?; Data::Outcome(out) } } }; frame(s, &Reply { nonce, data }) } } pub fn serve() -> Result<()> { ensure!( unsafe { libc::geteuid() } == 0 && unsafe { libc::getuid() } == 0, "ROOT_REQUIRED" ); unsafe { libc::umask(0o077) }; let (p, b, policy) = config()?; let image = std::env::current_exe()?; protected(&image)?; ensure!( hash(&fs::read(&image)?) == p.helper_binary_sha256, "RUNNING_IMAGE_PIN" ); let directory = Path::new(DIR); protected(directory)?; ensure!( fs::metadata(directory)?.mode() & 0o077 == 0, "ROOT_STATE_NOT_PRIVATE" ); let open = |name: &str| { OpenOptions::new() .read(true) .write(true) .create(true) .truncate(false) .mode(0o600) .custom_flags(libc::O_NOFOLLOW) .open(directory.join(name)) }; let lock = open("executor.lock")?; ensure!( unsafe { libc::flock(lock.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } == 0, "HELPER_BUSY" ); let guard = Guard { _lock: lock, db_file: open("consumption.sqlite")?, }; let db = Connection::open(directory.join("consumption.sqlite"))?; guard.check(&db)?; ledger::initialize_ledger(&db)?; let clock = NativeClock::default(); let sync = h::HelperSync::new(b.clone(), &clock)?; let boot = Boot(b.agent_id); let path = Path::new(SOCK); protected(path.parent().unwrap())?; if let Ok(m) = fs::symlink_metadata(path) { ensure!( m.uid() == 0 && m.file_type().is_socket(), "UNEXPECTED_SOCKET" ); fs::remove_file(path)?; } let listener = UnixListener::bind(path)?; std::os::unix::fs::chown(path, Some(0), Some(p.agent_gid))?; fs::set_permissions(path, Permissions::from_mode(0o660))?; let mut helper = Helper { db, guard, b, p, policy, image, clock, boot, sync, }; for s in listener.incoming() { if let Err(e) = helper.invoke(&mut s?) { let code = e.to_string(); eprintln!( "root helper: {}", if code.len() < 80 && code.bytes().all(|v| v.is_ascii_uppercase() || v == b'_') { &code } else { "REJECTED" } ); } } Ok(()) }