diff --git a/Cargo.lock b/Cargo.lock index 324cbb3..ca7463a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2301,7 +2301,9 @@ dependencies = [ "rmm-domain", "rmm-protocol", "rusqlite", + "serde", "serde_json", + "sha1", "uuid", ] diff --git a/Rust_RMM_Implementierungsspezifikation.md b/Rust_RMM_Implementierungsspezifikation.md index 8f1f828..ccf3b7d 100644 --- a/Rust_RMM_Implementierungsspezifikation.md +++ b/Rust_RMM_Implementierungsspezifikation.md @@ -24,7 +24,7 @@ Die Spalte **Zweck** und das Gerätedetail zeigen optionalen Freitext. Unter **Z ## Vom Skript zum Ergebnis -**OPNsense-Testprofil:** Das Gerätegateway akzeptiert `opnsense.base/1` als eigene Inventarplattform. Im Gerätedetail erscheinen aktive PF-Filterregeln sowie getrennte Listen für konfigurierte VPNs und native Laufzeitbefunde. Fehlende Berechtigung bzw. ausgefallene Quellen sind kein Nachweis einer leeren Liste. Nur mit ausdrücklich eingerichteter Capability `opnsense.uname/1`, `run_script` und signiertem Abgleich kann die feste POSIX-Kernelabfrage auf dem Dienstkonto angefordert werden. Sie nutzt die reguläre persönliche Genehmigung und genau einen gebundenen Versuch. [OPNsense-Betrieb](deploy/opnsense/README.md) +**OPNsense:** Das Gerätegateway akzeptiert `opnsense.base/1` als eigene Inventarplattform. Im Gerätedetail erscheinen aktive PF-Filterregeln sowie getrennte Listen für konfigurierte VPNs und native Laufzeitbefunde. Fehlende Berechtigung bzw. ausgefallene Quellen sind kein Nachweis einer leeren Liste. Skriptaufträge gehören wie bei Linux und Windows unter **Aufträge**. Die WebUI bindet eine Bibliotheksrevision oder ein einmaliges POSIX-Skript an die ausgewählten OPNsense-Geräte. Für die Ausführung als `root` gelten zusätzlich zum normalen signierten Abgleich und persönlichen Freigabeverfahren `root:execute`, die zentrale Geräte- und Principalbindung sowie die unabhängige Prüfung durch den lokal provisionierten FreeBSD-Helper. [OPNsense-Betrieb](deploy/opnsense/README.md) | Schritt | Verhalten | | --- | --- | diff --git a/crates/agent-core/src/freebsd_clock.rs b/crates/agent-core/src/freebsd_clock.rs index 87edf56..660633b 100644 --- a/crates/agent-core/src/freebsd_clock.rs +++ b/crates/agent-core/src/freebsd_clock.rs @@ -5,6 +5,7 @@ use anyhow::{Context, Result, ensure}; use chrono::{DateTime, TimeDelta, Utc}; use std::{mem::MaybeUninit, time::Instant}; +#[derive(Clone)] pub struct NativeClock { origin: DateTime, monotonic: Instant, diff --git a/crates/agent-opnsense-jobs/Cargo.toml b/crates/agent-opnsense-jobs/Cargo.toml index 4b75022..858228d 100644 --- a/crates/agent-opnsense-jobs/Cargo.toml +++ b/crates/agent-opnsense-jobs/Cargo.toml @@ -16,6 +16,8 @@ rmm-domain = { path = "../domain" } rmm-protocol = { path = "../protocol" } rusqlite.workspace = true serde_json.workspace = true +serde.workspace = true +sha1 = "0.10" uuid.workspace = true [target.'cfg(target_os = "freebsd")'.dev-dependencies] diff --git a/crates/agent-opnsense-jobs/src/main.rs b/crates/agent-opnsense-jobs/src/main.rs index 921539d..4c2c23b 100644 --- a/crates/agent-opnsense-jobs/src/main.rs +++ b/crates/agent-opnsense-jobs/src/main.rs @@ -1,8 +1,17 @@ #[cfg(target_os = "freebsd")] mod native; #[cfg(target_os = "freebsd")] +mod root; +#[cfg(target_os = "freebsd")] fn main() -> anyhow::Result<()> { - native::main() + match std::env::args().nth(1).as_deref() { + Some("--root-helper") => root::serve(), + Some("--root-capabilities") => { + println!("{}", serde_json::to_string(&root::caps()?)?); + Ok(()) + } + _ => native::main(), + } } #[cfg(not(target_os = "freebsd"))] fn main() { diff --git a/crates/agent-opnsense-jobs/src/native.rs b/crates/agent-opnsense-jobs/src/native.rs index 61912f7..5033dee 100644 --- a/crates/agent-opnsense-jobs/src/native.rs +++ b/crates/agent-opnsense-jobs/src/native.rs @@ -1,6 +1,6 @@ //! One worker per authenticated Python HTTPS channel, never a network listener. -//! Only the fixed unprivileged probe is executable. The shared Rust core owns -//! all approval/permit verification, receipt, consumption and sync transitions. +//! Executes approved service-account POSIX scripts or delegates approved root +//! scripts to the independently synchronized local helper. use anyhow::{Context, Result, bail, ensure}; use chrono::Utc; use prost::Message; @@ -22,6 +22,11 @@ use std::{ unix::fs::{MetadataExt, OpenOptionsExt}, }, path::Path, + sync::{ + Arc, + atomic::{AtomicBool, Ordering}, + }, + thread::JoinHandle, time::{Duration, Instant}, }; use uuid::Uuid; @@ -31,9 +36,16 @@ mod tests; fn supported(job: &JobPayload) -> bool { job.execution_identity == "agent_service" - && job.action.opnsense_kernel_probe() - && job.max_runtime_seconds == 10 - && job.max_output_bytes == 1024 + && job.action.opnsense_service_script() + && job + .action + .valid_job_limits(job.max_runtime_seconds, job.max_output_bytes) +} +struct Running { + offer: JobOffer, + grant: rmm_domain::jobs::ExecutionPermitPayload, + cancel: Arc, + task: JoinHandle, } struct Worker { @@ -45,6 +57,17 @@ struct Worker { ledger: Connection, sync_due: Instant, permit_after: Instant, + root_enabled: bool, + pending_sync: Option, + running: Option, +} +impl Drop for Worker { + fn drop(&mut self) { + if let Some(r) = self.running.take() { + r.cancel.store(true, Ordering::Release); + let _ = r.task.join(); + } + } } impl Worker { fn envelope(&self, payload: Payload) -> Result { @@ -93,24 +116,43 @@ impl Worker { Ok(()) } fn next(&mut self) -> Result> { + if self.running.as_ref().is_some_and(|r| r.task.is_finished()) { + let r = self.running.take().unwrap(); + let o = r + .task + .join() + .unwrap_or_else(|_| Outcome::unknown("WORKER_INTERRUPTED")); + ledger::persist_outcome(&self.ledger, &r.grant, &o)?; + self.result(&r.offer, &r.grant.grant_id.to_string(), o.clone())?; + ledger::finish(&self.ledger, &r.grant, &o)?; + } if let Some(mut e) = jobs::events(&self.db)?.into_iter().next() { e.connection_generation = self.channel.connection_generation; return Ok(Some(e)); } // A refused or unqualified clock closes the effect gate, not telemetry. + if self.running.is_some() { + return Ok(None); + } if Instant::now() >= self.sync_due { self.sync_due = Instant::now() + Duration::from_secs(40); if self.clock.now().is_err() { self.sync.close(); return Ok(None); } + let snapshot = if self.root_enabled { + Some(crate::root::snapshot(self.channel.connection_generation)?) + } else { + None + }; let p = self.sync.prepare( &mut self.db, &self.ledger, self.channel.clone(), - None, + snapshot.as_ref(), &self.clock, )?; + self.pending_sync = Some(p.request); return Ok(Some(p.envelope)); } if self.sync.can_start(&self.channel, false, &self.clock) @@ -126,7 +168,12 @@ impl Worker { )?; return self.next(); } - ensure!(supported(&job), "UNSUPPORTED_JOB"); + let root = self.root_enabled && crate::root::supported(&job); + ensure!(supported(&job) || root, "UNSUPPORTED_JOB"); + if !self.sync.can_start(&self.channel, root, &self.clock) { + self.sync_due = Instant::now(); + return Ok(None); + } jobs::reserve_request(&self.db, &offer)?; return self .envelope(Payload::ExecutionPermitRequest(ExecutionPermitRequest { @@ -151,9 +198,16 @@ impl Worker { match e.payload.context("EMPTY_REPLY")? { Payload::Ack(a) => jobs::ack(&mut self.db, &a.message_id)?, Payload::SyncResponse(s) => { + let q = self.pending_sync.take().context("UNEXPECTED_SYNC")?; let applied = self.sync.apply(&mut self.db, &s, &self.clock)?; - ensure!(applied.helper_instruction.is_none(), "UNEXPECTED_HELPER"); self.sync.apply_consumption(&mut self.ledger, &self.clock)?; + if applied.helper_instruction.is_some() { + ensure!(self.root_enabled, "UNEXPECTED_HELPER"); + let snapshot = crate::root::apply(&q, &s)?; + if self.sync.can_start(&self.channel, false, &self.clock) { + self.sync.confirm_helper(&snapshot)?; + } + } } Payload::JobOffer(o) => { let receipt = self.envelope(Payload::JobAccepted(JobAccepted { @@ -163,7 +217,9 @@ impl Worker { journal_proof: hash(&o.encode_to_vec()), }))?; let tx = self.db.transaction()?; - let fresh = jobs::accept(&tx, &self.binding, &o, supported)?; + let fresh = jobs::accept(&tx, &self.binding, &o, |j| { + supported(j) || (self.root_enabled && crate::root::supported(j)) + })?; jobs::event(&tx, &receipt)?; tx.commit()?; if fresh { @@ -172,6 +228,12 @@ impl Worker { } Payload::ExecutionPermit(p) => self.permit(p)?, Payload::CancelRequest(c) => { + if let Some(r) = &self.running + && r.offer.job_id == c.job_id + && r.offer.attempt_id == c.attempt_id + { + r.cancel.store(true, Ordering::Release); + } let offer:Option>=rusqlite::OptionalExtension::optional(self.db.query_row( "UPDATE job_attempts SET cancel_requested=1 WHERE job=?1 AND attempt=?2 AND state='accepted' RETURNING offer", params![c.job_id,c.attempt_id],|r|r.get(0)))?; @@ -197,9 +259,10 @@ impl Worker { return Ok(()); } let req = jobs::permit_request(&offer, &p)?; + let root = self.binding.job(&offer.payload_bytes)?.execution_identity == "root"; let verify = || -> Result<_> { ensure!( - self.sync.can_start(&self.channel, false, &self.clock), + self.sync.can_start(&self.channel, root, &self.clock), "SYNC_REQUIRED" ); let (low, high) = self.clock.bounds()?; @@ -221,14 +284,23 @@ impl Worker { Err(e) => return Err(e), } }; - ensure!(supported(&job), "UNSUPPORTED_JOB"); - let Action::RunScript { script_utf8, .. } = &job.action else { + ensure!( + supported(&job) || (self.root_enabled && crate::root::supported(&job)), + "UNSUPPORTED_JOB" + ); + 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, - vec![], + arguments.clone(), Duration::from_secs(job.max_runtime_seconds.into()), job.max_output_bytes as usize, )?; @@ -252,46 +324,69 @@ impl Worker { })); jobs::event(&tx, &running)?; tx.commit()?; - let mut first = true; - let result = run_script_controlled(&script, || { - if first { - ensure!( - self.sync.can_start(&self.channel, false, &self.clock), - "SYNC_EXPIRED" - ); - let (lo, hi) = self.clock.bounds()?; - self.binding.verify(&req, lo)?; - self.binding.verify(&req, hi)?; - first = false; - } else { - self.clock.now()?; + let cancel = Arc::new(AtomicBool::new(false)); + let flag = cancel.clone(); + let deadline = self.sync.validity_deadline().context("SYNC_LEASE")?; + let binding = self.binding.clone(); + let generation = self.channel.connection_generation; + let expected = expected_stdout.clone(); + let seconds = job.max_runtime_seconds; + let digest = hash(script_utf8.as_bytes()); + let clock = self.clock.clone(); + let task = std::thread::spawn(move || { + if root { + return crate::root::execute(generation, req, &flag, seconds) + .unwrap_or_else(|_| Outcome::unknown("HELPER_TRANSPORT_EFFECT_UNKNOWN")); } - Ok(()) - }); - let outcome = match result { - Ok(o) => { - let ok = o.code == Some(0) - && !o.timed_out - && !o.interrupted - && !o.truncated - && o.stdout == b"FreeBSD\n"; - Outcome { - state: 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,"effective_uid":unsafe{libc::geteuid()}}), - error_code: if ok { "" } else { "PROBE_POSTCONDITION_FAILED" }.into(), + let mut first = true; + let result = run_script_controlled(&script, || { + ensure!(!flag.load(Ordering::Acquire), "CANCEL_OR_FENCE"); + if first { + let (lo, hi) = clock.bounds()?; + ensure!(hi < deadline, "SYNC_EXPIRED"); + binding.verify(&req, lo)?; + binding.verify(&req, hi)?; + first = false; + } else { + clock.now()?; } + Ok(()) + }); + match result { + Ok(o) => { + let ok = o.code == Some(0) + && !o.timed_out + && !o.interrupted + && expected + .as_ref() + .is_none_or(|v| !o.truncated && o.stdout == v.as_bytes()); + Outcome { + state: if ok { + "succeeded" + } else if o.interrupted || o.timed_out || o.code.is_none() { + "unknown" + } 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,"effective_uid":unsafe{libc::geteuid()},"script_sha256":digest}), + error_code: if ok { "" } else { "PROBE_POSTCONDITION_FAILED" }.into(), + } + } + Err(_) => Outcome::unknown("PROBE_EFFECT_UNCERTAIN"), } - Err(_) => Outcome::unknown("PROBE_EFFECT_UNCERTAIN"), - }; - ledger::persist_outcome(&self.ledger, &grant, &outcome)?; - let saved = serde_json::to_vec(&outcome)?; - self.result(&offer, &id, outcome)?; - ledger::finish(&self.ledger, &grant, &serde_json::from_slice(&saved)?)?; + }); + self.running = Some(Running { + offer, + grant, + task, + cancel, + }); Ok(()) } } @@ -368,6 +463,9 @@ pub fn main() -> Result<()> { clock: NativeClock::default(), sync_due: Instant::now(), permit_after: Instant::now(), + pending_sync: None, + running: None, + root_enabled: env::var_os("DISCOVERY_ROOT_SESSION").is_some(), }; w.recover()?; let mut input = io::stdin().lock(); diff --git a/crates/agent-opnsense-jobs/src/native/tests.rs b/crates/agent-opnsense-jobs/src/native/tests.rs index aed0a20..0ad772d 100644 --- a/crates/agent-opnsense-jobs/src/native/tests.rs +++ b/crates/agent-opnsense-jobs/src/native/tests.rs @@ -40,6 +40,9 @@ fn native_probe_requires_signature_and_redelivery_does_not_rerun() -> Result<()> sync_due: Instant::now(), permit_after: Instant::now(), clock: NativeClock::default(), + pending_sync: None, + running: None, + root_enabled: false, }; let now = w.clock.now()?; let job = JobPayload { @@ -119,6 +122,12 @@ fn native_probe_requires_signature_and_redelivery_does_not_rerun() -> Result<()> |db: &Connection| db.query_row("SELECT count(*) FROM consumed", [], |r| r.get::<_, i64>(0)); ensure!(count(&w.ledger)? == 0); w.permit(permit.clone())?; + let end = Instant::now() + Duration::from_secs(10); + while w.running.is_some() { + ensure!(Instant::now() < end, "execution timeout"); + w.next()?; + std::thread::yield_now(); + } w.receive(w.envelope(Payload::JobOffer(offer))?)?; ensure!(w.permit(permit).is_err() && count(&w.ledger)? == 1); let results = jobs::events(&w.db)? diff --git a/crates/agent-opnsense-jobs/src/root.rs b/crates/agent-opnsense-jobs/src/root.rs new file mode 100644 index 0000000..d71607e --- /dev/null +++ b/crates/agent-opnsense-jobs/src/root.rs @@ -0,0 +1,543 @@ +//! 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(()) +} diff --git a/deploy/opnsense/README.md b/deploy/opnsense/README.md index 67cac9d..1904837 100644 --- a/deploy/opnsense/README.md +++ b/deploy/opnsense/README.md @@ -17,6 +17,8 @@ Der OPNsense-eigene Python-Interpreter führt zwei Zipapps aus. Der lokale Colle **Firewall:** aktiver PF-Hauptregelsatz in Kernelreihenfolge, einschließlich automatisch erzeugter Regeln. Kein Editor und kein rekursives Auslesen der Anchor-Regelsätze. -**Profile:** Ohne Worker und Signaturbindung bleibt das Gerät passiv. Mit dem FreeBSD-Worker unterstützt `0.1.0-opnsense.5` genau die feste Kernelabfrage (`uname -s\n`, `posix_sh`, erwartete Ausgabe `FreeBSD\n`, keine Argumente, Dienstkonto, 10 s, 1024 Byte). Unter **Geräte → OPNsense-Kernelabfrage** lässt sie sich für diese Installation einreichen. Die persönliche WebUI-Genehmigung und der signierte Startgrant sind erforderlich. Root, beliebige Shell-/Bibliotheksskripte und signierte OPNsense-Releases bleiben offen. Das Gerät ist kein Linuxziel. +**Skripte:** Unter **Aufträge → Neuer Auftrag** die OPNsense-Zielgeräte wählen. Unter **Aus der Bibliothek** eine feste POSIX-Shell-Revision wählen, alternativ ein **Einmaliges Skript** eingeben. **Ausführen als** unterstützt Dienstkonto und bei entsprechender Berechtigung `root`. **Zusammenfassung ansehen** bindet das Skript samt Zielen und Grenzen; **Zur Genehmigung einreichen** legt den Antrag an. Die persönliche Freigabe erfolgt unter **Genehmigungen**, die Ausgabe erscheint im Auftrag. OPNsense kann POSIX-Shellskripte ausführen; Linux-spezifische Programme und Optionen werden nicht übersetzt. Zwei [Startrevisionen aus dem Repository](../../migrations/0047_opnsense_library.sql) zeigen Version/Ausführungskonto bzw. aktive Firewallregeln. Im Gerätedetail stehen Inventar und Verweise auf vorhandene Aufträge. **Probe bereitstellen:** Im Gast steht die gepinnte Toolchain unter `/opt/discovery-rust`. `cargo build --locked -p rmm-opnsense-jobs` nativ bauen und `rmm-opnsense-jobs` root-eigen (0555) neben den Zipapps installieren. Auf der bereits aufgenommenen Testinstallation `python3 -I pin-probe.py TENANT ASSET AGENT ENROLLMENT_GENERATION ASSIGNMENT_VERSION` mit den bestätigten Kennungen aufrufen. Das Skript bezieht den öffentlichen Jobschlüssel über das bestehende Gerätezertifikat und überschreibt keine andere Bindung. Den Agentendienst anschließend neu starten. Der Worker nutzt bestehende Nachrichtenfolgen, den signierten Abgleich und getrennte dauerhafte Start-/Ergebnisjournale. Er läuft ohne Netzwerklistener als `discovery`. Der [native Integrationstest](../../crates/agent-opnsense-jobs/src/native/tests.rs) prüft mit eigener Testidentität und eigenem Schlüssel die Ablehnung einer defekten Signatur, erwartete Ausgabe, einen Verbrauch und keine zweite Ausführung bei Wiederzustellung. Das ist ein separater Beleg vom persönlich genehmigten Geräteauftrag. + +**Root-Helper (ab `0.1.0-opnsense.6`):** Native Binärdatei zusätzlich in den privaten Stagingordner kopieren. Auf dem Gast `python3 -I enable-root.py /absoluter/Stagingpfad/rmm-opnsense-jobs` und `sh install-dev.sh /absoluter/Stagingpfad` ausführen. Die lokale Policy bindet Worker-Hash, Gerätebindung, Dienst-UID und Gruppe. Der zusätzliche `rc.d`-Prozess läuft als root, hört ausschließlich auf einem geschützten Unix-Socket und prüft den Peer über `getpeereid`. Den vom Helper bestätigten Binär- und Policyhash mit `tools/dev_opnsense_root_scope.py --help` für die genaue Kopplung und den berechtigten lokalen Principal registrieren. Es gibt keine automatische Freigabe oder automatische Pinrotation. Root akzeptiert `posix_sh` mit `full_maintenance_v1` (bis 300 Sekunden und 65536 Ausgabebyte), verifiziert selbst Sync, Grant, Skriptbytes, Boot und Uhr, und führt ein eigenes Verbrauchsjournal in `/var/db/discovery-root-jobs`. Ohne Startbeleg gibt es kein positives Ergebnis. Bei `unknown` zuerst die bestehenden Journale abgleichen. Der [isolierte native Helper-Test](test_root_helper.py) benutzt nur eine Wegwerfidentität und separate Journale. diff --git a/deploy/opnsense/agent.py b/deploy/opnsense/agent.py index f4993a0..59556c4 100644 --- a/deploy/opnsense/agent.py +++ b/deploy/opnsense/agent.py @@ -1,4 +1,4 @@ -"""Unprivileged OPNsense telemetry channel. Input never selects a local command.""" +"""Unprivileged OPNsense telemetry and signed job transport.""" import hashlib import contextlib import fcntl @@ -20,7 +20,7 @@ STATE = Path('/var/db/discovery-agent') CA = '/usr/local/etc/discovery-agent/ca.pem' HOST = 'discovery.ease-technologies.de' MEDIA = 'application/x-protobuf' -VERSION = '0.1.0-opnsense.5' +VERSION = '0.1.0-opnsense.6' WORKER = Path('/usr/local/libexec/discovery-agent/rmm-opnsense-jobs') BINDING = Path('/usr/local/etc/discovery-agent/job-binding.json') @@ -225,11 +225,19 @@ def run_channel(db, identity, boot, instance, stack): ctx = context() ctx.load_cert_chain(STATE/'device.pem', STATE/'device.key') caps = ['heartbeat/1','opnsense.base/1'] + root_caps=[] if enabled: - caps.extend(['rmm.sync.v1','run_script','opnsense.uname/1']) + caps.extend(['rmm.sync.v1','run_script','opnsense.uname/1','opnsense.posix/1']) + if Path('/usr/local/etc/discovery-agent/root-policy.json').is_file(): + probe=subprocess.run([WORKER,'--root-capabilities'],capture_output=True,timeout=15) + if probe.returncode==0: + root_caps=json.loads(probe.stdout) + caps.extend(root_caps) generation = send('client_hello',pb.ClientHello(agent_version=VERSION, capabilities=caps)) if enabled: - p = subprocess.Popen([WORKER,identity['agent_id'],identity['asset_id'],boot,str(generation)], + env=os.environ.copy();env.pop('DISCOVERY_ROOT_SESSION',None) + if root_caps:env['DISCOVERY_ROOT_SESSION']='1' + p = subprocess.Popen([WORKER,identity['agent_id'],identity['asset_id'],boot,str(generation)],env=env, stdin=subprocess.PIPE,stdout=subprocess.PIPE,close_fds=True) def close(): p.stdin.close() @@ -271,8 +279,13 @@ def run_channel(db, identity, boot, instance, stack): scope='opnsense.base',schema_version=1,chunk_count=1,data=raw, sha256=hashlib.sha256(raw).digest(),completeness='partial'),stamp//1_000_000) last = stamp - if jobs: + if jobs and (root_caps or not Path('/usr/local/etc/discovery-agent/root-policy.json').is_file()): jobs.pump(ctx,identity['agent_id'],boot,generation) + elif jobs: + # Preserve the established helper journal chain across a helper + # restart. Keep telemetry flowing, then renegotiate capabilities. + if subprocess.run([WORKER,'--root-capabilities'],capture_output=True,timeout=15).returncode==0: + return time.sleep(20) diff --git a/deploy/opnsense/discovery_agent b/deploy/opnsense/discovery_agent index c06f098..d81673f 100644 --- a/deploy/opnsense/discovery_agent +++ b/deploy/opnsense/discovery_agent @@ -11,6 +11,15 @@ start_cmd=discovery_start stop_cmd=discovery_stop discovery_start() { + if [ -f /usr/local/etc/discovery-agent/root-policy.json ]; then + install -d -o root -g wheel -m 0700 /var/db/discovery-root-jobs || return 1 + install -d -o root -g discovery -m 0750 /var/run/discovery-root-jobs || return 1 + pid=/var/run/discovery-root-jobs.pid + if [ -z "$(check_pidfile "$pid" /usr/sbin/daemon)" ]; then + /usr/sbin/daemon -f -r -R 5 -P "$pid" -S -T discovery-root-jobs \ + /usr/local/libexec/discovery-agent/rmm-opnsense-jobs --root-helper || return 1 + fi + fi for part in collect agent; do pid=/var/run/discovery-$part.pid [ -z "$(check_pidfile "$pid" /usr/sbin/daemon)" ] || continue @@ -21,7 +30,7 @@ discovery_start() { done } discovery_stop() { - for part in agent collect; do + for part in agent collect root-jobs; do pid=$(check_pidfile "/var/run/discovery-$part.pid" /usr/sbin/daemon) [ -z "$pid" ] || kill -TERM "$pid" done diff --git a/deploy/opnsense/enable-root.py b/deploy/opnsense/enable-root.py new file mode 100644 index 0000000..1a6f3fe --- /dev/null +++ b/deploy/opnsense/enable-root.py @@ -0,0 +1,38 @@ +"""In the guest, bind a staged native helper to the existing signed job identity. +Print only the hashes used by the central operator. Never replace another policy. +""" +import hashlib +import json +import os +from pathlib import Path +import pwd +import stat +import sys + + +def main(): + if os.getuid()!=0 or os.geteuid()!=0 or len(sys.argv)!=2: + raise SystemExit('Run as root: enable-root.py /absolute/staging/rmm-opnsense-jobs') + app=Path(sys.argv[1]).resolve(strict=True) + conf=Path('/usr/local/etc/discovery-agent') + binding=conf/'job-binding.json' + for path in (app,*app.parents,binding,*binding.parents): + info=path.lstat() + if info.st_uid!=0 or info.st_mode & 0o022 or stat.S_ISLNK(info.st_mode): + raise ValueError('untrusted provisioning path') + user=pwd.getpwnam('discovery') + if not user.pw_uid or not user.pw_gid: raise ValueError('invalid agent identity') + image=hashlib.file_digest(app.open('rb'),'sha256').hexdigest() + policy=dict(schema_version=1,profile='full_maintenance_v1',agent_uid=user.pw_uid,agent_gid=user.pw_gid, + binding_sha256=hashlib.sha256(binding.read_bytes()).hexdigest(),helper_binary_sha256=image) + raw=(json.dumps(policy,separators=(',',':'))+'\n').encode() + path=conf/'root-policy.json' + if path.exists(): + if path.is_symlink() or path.read_bytes()!=raw: raise ValueError('existing policy differs') + else: + with path.open('xb') as f: + os.fchmod(f.fileno(),0o444); f.write(raw);f.flush();os.fsync(f.fileno()) + print(json.dumps(dict(helper_binary_sha256=image,helper_policy_sha256=hashlib.sha256(raw).hexdigest()))) + + +if __name__=='__main__':main() diff --git a/deploy/opnsense/install-dev.sh b/deploy/opnsense/install-dev.sh index 8132947..5828406 100644 --- a/deploy/opnsense/install-dev.sh +++ b/deploy/opnsense/install-dev.sh @@ -24,13 +24,22 @@ done if [ -x "$rc" ]; then "$rc" onestop for _ in 1 2 3 4 5; do - [ -f /var/run/discovery-agent.pid ] || [ -f /var/run/discovery-collect.pid ] || break + [ -f /var/run/discovery-agent.pid ] || [ -f /var/run/discovery-collect.pid ] || [ -f /var/run/discovery-root-jobs.pid ] || break sleep 1 done - if [ -f /var/run/discovery-agent.pid ] || [ -f /var/run/discovery-collect.pid ]; then + if [ -f /var/run/discovery-agent.pid ] || [ -f /var/run/discovery-collect.pid ] || [ -f /var/run/discovery-root-jobs.pid ]; then echo 'Existing service still running' >&2; exit 1 fi fi +if [ -f "$src/rmm-opnsense-jobs" ]; then + install -o root -g wheel -m 0555 "$src/rmm-opnsense-jobs" "$app/jobs.next" + if [ -f "$conf/root-policy.json" ] && ! /usr/local/bin/python3 -I -c \ + 'import hashlib,json,sys;sys.exit(hashlib.file_digest(open(sys.argv[1],"rb"),"sha256").hexdigest()!=json.load(open(sys.argv[2]))["helper_binary_sha256"])' \ + "$app/jobs.next" "$conf/root-policy.json"; then + echo 'Native helper differs from the local policy pin' >&2; "$rc" start; exit 1 + fi + mv -f "$app/jobs.next" "$app/rmm-opnsense-jobs" +fi for part in collect agent; do mv -f "$app/$part.next" "$app/$part.pyz"; done install -o root -g wheel -m 0444 "$src/ca.pem" "$conf/ca.pem" install -o root -g wheel -m 0555 "$src/discovery_agent" "$rc" diff --git a/deploy/opnsense/test_root_helper.py b/deploy/opnsense/test_root_helper.py new file mode 100644 index 0000000..d779ed5 --- /dev/null +++ b/deploy/opnsense/test_root_helper.py @@ -0,0 +1,132 @@ +"""Native development integration: private chroot, disposable signer and identities. + +Runs the installed FreeBSD helper binary and a child with the discovery uid in an +empty root; the installed device's socket, config, keys and journals are not used. +""" +import datetime +import hashlib +import json +import os +from pathlib import Path +import pwd +import re +import shutil +import socket +import sqlite3 +import struct +import subprocess +import sys +import tempfile +import time +import uuid + +APP='/usr/local/libexec/discovery-agent/rmm-opnsense-jobs' +CONF='/usr/local/etc/discovery-agent' +SOCK='/var/run/discovery-root-jobs/control.sock' +STATE='/var/db/discovery-root-jobs' +pack=lambda v:json.dumps(v,separators=(',',':')).encode() +sha=lambda b:hashlib.sha256(b).hexdigest() +new=lambda:str(uuid.uuid4()) +now=lambda:datetime.datetime.now(datetime.timezone.utc) + + +def check(jail, folder, result): + import agent_pb2 as pb + u=pwd.getpwnam('discovery') + def inside(path):return jail/path.lstrip('/') + def copy(path): + dst=inside(path);dst.parent.mkdir(exist_ok=True,parents=True);shutil.copyfile(path,dst);dst.chmod(0o555) + copy('/libexec/ld-elf.so.1') + for path in [APP,'/bin/sh','/usr/bin/id','/sbin/sysctl']: + copy(path) + for lib in re.findall(r'=> (/\S+)',subprocess.check_output(['ldd',path],text=True)):copy(lib) + for path in [CONF,STATE,str(Path(SOCK).parent),'/tmp','/dev']:inside(path).mkdir(exist_ok=True,parents=True) + inside(STATE).chmod(0o700);inside('/tmp').chmod(0o1777);inside('/dev/null').touch() + key=folder/'fixture.key' + subprocess.run(['openssl','genpkey','-algorithm','Ed25519','-out',key],check=True) + public=subprocess.check_output(['openssl','pkey','-in',key,'-pubout','-outform','DER'])[-32:] + def signed(data): + f=folder/'message';f.write_bytes(data) + return list(subprocess.check_output(['openssl','pkeyutl','-sign','-rawin','-inkey',key,'-in',f])) + b=dict(tenant_id=new(),asset_id=new(),agent_id=new(),assignment_version=1,enrollment_generation=1) + binding=pack(dict(**b,public_key_hex=public.hex()));inside(CONF+'/job-binding.json').write_bytes(binding) + image=sha(inside(APP).read_bytes()) + policy=pack(dict(schema_version=1,profile='full_maintenance_v1',agent_uid=u.pw_uid,agent_gid=u.pw_gid, + helper_binary_sha256=image,binding_sha256=sha(binding))) + inside(CONF+'/root-policy.json').write_bytes(policy) + helper=subprocess.Popen([APP,'--root-helper'],preexec_fn=lambda:(os.chroot(jail),os.chdir('/')), + stdin=subprocess.DEVNULL,stdout=subprocess.DEVNULL) + def invoke(op,deny=False,uid=u.pw_uid): + # Socket comes from the isolated chroot. The peer uid seen by getpeereid + # must be a real kernel credential, not a field in the test frame. + a,z=socket.socketpair();pid=os.fork() + if pid==0: + a.close() + try: + os.chroot(jail);os.chdir('/');os.setgroups([]);os.setgid(u.pw_gid);os.setuid(uid) + with socket.socket(socket.AF_UNIX) as s: + s.settimeout(12);s.connect(SOCK) + nonce=new();raw=pack(dict(nonce=nonce,policy=sha(policy),image=image,op=op)) + s.sendall(struct.pack('>I',len(raw))+raw) + with s.makefile('rb') as f: + hdr=f.read(4) + if not hdr:os._exit(0 if deny else 1) + n=struct.unpack('>I',hdr)[0];assert n<=8*1024*1024 + r=json.loads(f.read(n));assert not deny and r['nonce']==nonce + z.sendall(pack(r['data'])) + os._exit(0) + except (ConnectionResetError,BrokenPipeError): + os._exit(0 if deny else 1) + except BaseException:os._exit(1) + z.close() + with a,a.makefile('rb') as f:data=f.read() + assert os.waitpid(pid,0)[1]==0, 'unexpected response from helper' + return json.loads(data) if data else None + try: + end=time.monotonic()+8 + while not inside(SOCK).is_socket(): + assert helper.poll() is None and time.monotonic()0,'invalid pins or generations') + scope=dict(tenant_id=str(a.tenant),asset_id=str(a.asset),agent_id=str(a.agent), + enrollment_generation=a.enrollment_generation,assignment_version=a.assignment_version, + principals=['local:'+str(a.principal)],helper_policy_sha256=a.policy,helper_binary_sha256=a.binary, + allowed_script_profiles=['full_maintenance_v1'],allow_root_scripts=True,allow_reboot=False, + allowed_services=[],acceptance_evidence_id='opnsense-root-'+str(a.agent)) + program='import fcntl,json,os,stat,tempfile\nfrom pathlib import Path\n' + for f in (require,protected,encoded,replace,register):program+=inspect.getsource(f)+'\n' + subprocess.run([*ssh_prefix('server'),'python3 -I -'],input=program+f'register(Path({str(POLICY)!r}),{scope!r})\n',text=True,check=True) + + +if __name__=='__main__': main()