Run approved FreeBSD root jobs through independently pinned and synchronized local helper
Rust development slice / linux (push) Failing after 11s
Rust development slice / linux (push) Failing after 11s
This commit is contained in:
@@ -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<Uuid> {
|
||||
// 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<u32> {
|
||||
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<T: Serialize>(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<T: DeserializeOwned>(s: &mut UnixStream) -> Result<T> {
|
||||
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<u8>, 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<Data> {
|
||||
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<Vec<String>> {
|
||||
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<HelperSnapshot> {
|
||||
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<HelperSnapshot> {
|
||||
mapped(call(Op::Snapshot(g))?)
|
||||
}
|
||||
pub fn apply(q: &SyncRequest, s: &SyncResponse) -> Result<HelperSnapshot> {
|
||||
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<Outcome> {
|
||||
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<Option<Vec<u8>>>=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(())
|
||||
}
|
||||
Reference in New Issue
Block a user