553 lines
19 KiB
Rust
553 lines
19 KiB
Rust
//! Closed systemd service set; status is corroborated with held kernel process
|
|
//! identity. No shell, enable/reboot, global kill or repeated stop/start.
|
|
use crate::{
|
|
Budget, DurableEffectFence, Effect, digest,
|
|
process::{HeldProcess, ProcessProof},
|
|
};
|
|
use anyhow::{Result, ensure};
|
|
use serde::{Deserialize, Serialize};
|
|
use std::{
|
|
collections::BTreeMap,
|
|
fs::File,
|
|
io::Read,
|
|
os::fd::{AsRawFd, FromRawFd},
|
|
os::unix::net::UnixStream,
|
|
process::{Child, Command, Stdio},
|
|
thread,
|
|
time::{Duration, Instant},
|
|
};
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
|
|
#[serde(rename_all = "snake_case")]
|
|
pub enum Service {
|
|
Agent,
|
|
General,
|
|
Full,
|
|
Apt,
|
|
Updater,
|
|
}
|
|
impl Service {
|
|
fn handoff_service(self) -> Result<rmm_updater_handoff::Service> {
|
|
Ok(match self {
|
|
Self::Agent => rmm_updater_handoff::Service::LinuxAgent,
|
|
Self::General => rmm_updater_handoff::Service::LinuxGeneralHelper,
|
|
Self::Full => rmm_updater_handoff::Service::LinuxFullHelper,
|
|
Self::Apt => rmm_updater_handoff::Service::LinuxAptHelper,
|
|
Self::Updater => anyhow::bail!("UPDATE_UPDATER_NOT_IN_TARGET_SET"),
|
|
})
|
|
}
|
|
pub fn unit(self) -> &'static str {
|
|
match self {
|
|
Self::Agent => "rmm-agent-remote.service",
|
|
Self::General => "rmm-helper-cloud.service",
|
|
Self::Full => "rmm-full-maintenance-helper.service",
|
|
Self::Apt => "rmm-apt-helper.service",
|
|
Self::Updater => "rmm-agent-updater.service",
|
|
}
|
|
}
|
|
fn uid(self) -> u32 {
|
|
if self == Self::Agent { 993 } else { 0 }
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct ServiceProof {
|
|
pub service: Service,
|
|
pub invocation_id: String,
|
|
pub enabled: String,
|
|
pub process: ProcessProof,
|
|
pub unit_sha256: String,
|
|
}
|
|
pub struct HeldService {
|
|
proof: ServiceProof,
|
|
process: HeldProcess,
|
|
}
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct ServicePolicy {
|
|
pub service: Service,
|
|
pub image_sha256: String,
|
|
pub unit_sha256: String,
|
|
}
|
|
|
|
pub struct Systemd {
|
|
policies: Vec<ServicePolicy>,
|
|
}
|
|
impl Systemd {
|
|
pub fn observe_updater(pin: ServicePolicy, budget: &Budget) -> Result<HeldService> {
|
|
ensure!(
|
|
pin.service == Service::Updater
|
|
&& crate::valid_digest(&pin.image_sha256)
|
|
&& crate::valid_digest(&pin.unit_sha256),
|
|
"UPDATE_UPDATER_PINS"
|
|
);
|
|
Self {
|
|
policies: vec![pin],
|
|
}
|
|
.observe(Service::Updater, budget)
|
|
}
|
|
/// Full is an ordinary required participant in the current Linux topology;
|
|
/// APT may additionally be installed but is never in the restart set.
|
|
pub fn new(policies: Vec<ServicePolicy>) -> Result<Self> {
|
|
let services: Vec<_> = policies.iter().map(|p| p.service).collect();
|
|
ensure!(
|
|
services == [Service::Agent, Service::General, Service::Full]
|
|
|| services
|
|
== [
|
|
Service::Agent,
|
|
Service::General,
|
|
Service::Full,
|
|
Service::Apt
|
|
],
|
|
"UPDATE_CLOSED_SERVICE_SET"
|
|
);
|
|
ensure!(
|
|
policies.iter().all(
|
|
|p| crate::valid_digest(&p.image_sha256) && crate::valid_digest(&p.unit_sha256)
|
|
),
|
|
"UPDATE_SERVICE_PINS"
|
|
);
|
|
ensure!(
|
|
policies[1].image_sha256 == policies[2].image_sha256,
|
|
"UPDATE_HELPER_PAIR_MISMATCH"
|
|
);
|
|
Ok(Self { policies })
|
|
}
|
|
pub fn authenticate_helper_peer(
|
|
&self,
|
|
socket: &UnixStream,
|
|
budget: &Budget,
|
|
) -> Result<rmm_domain::agent_update::ParticipantIdentity> {
|
|
for service in [Service::General, Service::Full] {
|
|
let held = self.observe(service, budget)?;
|
|
if let Ok(peer) = held.authenticate_peer(socket, budget) {
|
|
return Ok(peer);
|
|
}
|
|
}
|
|
anyhow::bail!("UPDATE_HELPER_PEER_NOT_BOUND")
|
|
}
|
|
fn status(service: Service, budget: &Budget) -> Result<BTreeMap<String, String>> {
|
|
budget.check()?;
|
|
let output = command(
|
|
&[
|
|
"show",
|
|
service.unit(),
|
|
"-p",
|
|
"LoadState",
|
|
"-p",
|
|
"ActiveState",
|
|
"-p",
|
|
"MainPID",
|
|
"-p",
|
|
"InvocationID",
|
|
"-p",
|
|
"UnitFileState",
|
|
"-p",
|
|
"FragmentPath",
|
|
"-p",
|
|
"DropInPaths",
|
|
],
|
|
budget,
|
|
)?;
|
|
let text = std::str::from_utf8(&output)?;
|
|
let mut fields = BTreeMap::new();
|
|
for row in text.lines() {
|
|
let (k, v) = row
|
|
.split_once('=')
|
|
.ok_or_else(|| anyhow::anyhow!("UPDATE_SYSTEMD_RESPONSE"))?;
|
|
ensure!(
|
|
fields.insert(k.into(), v.into()).is_none(),
|
|
"UPDATE_SYSTEMD_DUPLICATE"
|
|
);
|
|
}
|
|
ensure!(
|
|
fields.len() == 8 && fields.get("LoadState").is_some_and(|v| v == "loaded"),
|
|
"UPDATE_SYSTEMD_LOADED"
|
|
);
|
|
Ok(fields)
|
|
}
|
|
pub fn observe(&self, service: Service, budget: &Budget) -> Result<HeldService> {
|
|
let pin = self
|
|
.policies
|
|
.iter()
|
|
.find(|p| p.service == service)
|
|
.ok_or_else(|| anyhow::anyhow!("UPDATE_SERVICE_NOT_PINNED"))?;
|
|
let first = Self::status(service, budget)?;
|
|
ensure!(
|
|
first.get("ActiveState").is_some_and(|s| s == "active"),
|
|
"UPDATE_SERVICE_INACTIVE"
|
|
);
|
|
let pid = first
|
|
.get("MainPID")
|
|
.ok_or_else(|| anyhow::anyhow!("UPDATE_SERVICE_PID"))?
|
|
.parse()?;
|
|
let invocation_id = first
|
|
.get("InvocationID")
|
|
.ok_or_else(|| anyhow::anyhow!("UPDATE_SERVICE_INSTANCE"))?
|
|
.to_owned();
|
|
ensure!(
|
|
invocation_id.len() == 32 && invocation_id.bytes().all(|b| b.is_ascii_hexdigit()),
|
|
"UPDATE_SERVICE_INSTANCE"
|
|
);
|
|
// Unit composition must be independently provisioned. No unrecognized
|
|
// drop-in is silently ignored or inherited as an update permission.
|
|
let unit_sha = unit_composition(&first)?;
|
|
ensure!(unit_sha == pin.unit_sha256, "UPDATE_UNIT_CHANGED");
|
|
let process = HeldProcess::open(
|
|
pid,
|
|
service.uid(),
|
|
if service == Service::Updater { 0 } else { 984 },
|
|
&pin.image_sha256,
|
|
)?;
|
|
ensure!(
|
|
Self::status(service, budget)? == first,
|
|
"UPDATE_SERVICE_CHANGED_DURING_OBSERVATION"
|
|
);
|
|
process.verify()?;
|
|
Ok(HeldService {
|
|
proof: ServiceProof {
|
|
service,
|
|
invocation_id,
|
|
enabled: first["UnitFileState"].clone(),
|
|
process: process.proof().clone(),
|
|
unit_sha256: unit_sha,
|
|
},
|
|
process,
|
|
})
|
|
}
|
|
pub fn stop_all(
|
|
self,
|
|
budget: &Budget,
|
|
fence: &mut impl DurableEffectFence,
|
|
) -> Result<StoppedServices> {
|
|
let mut original = Vec::new();
|
|
for pin in &self.policies {
|
|
if pin.service == Service::Apt {
|
|
let s = Self::status(Service::Apt, budget)?;
|
|
ensure!(
|
|
s["ActiveState"] == "inactive"
|
|
&& s["MainPID"] == "0"
|
|
&& s["UnitFileState"] == "disabled"
|
|
&& unit_composition(&s)? == pin.unit_sha256,
|
|
"UPDATE_APT_MUST_REMAIN_CLOSED"
|
|
);
|
|
} else {
|
|
original.push(self.observe(pin.service, budget)?);
|
|
}
|
|
}
|
|
for held in &original {
|
|
held.process.verify()?;
|
|
let effect = Effect::StopService {
|
|
service: held.proof.service,
|
|
};
|
|
fence.before_effect(&effect)?;
|
|
budget.check()?;
|
|
command(&["--no-block", "stop", held.proof.service.unit()], budget)?;
|
|
loop {
|
|
budget.check()?;
|
|
let state = Self::status(held.proof.service, budget)?;
|
|
if state["ActiveState"] == "inactive"
|
|
&& state["MainPID"] == "0"
|
|
&& held.process.exited()?
|
|
{
|
|
break;
|
|
}
|
|
ensure!(
|
|
state["MainPID"] == "0"
|
|
|| state["MainPID"] == held.proof.process.pid.to_string(),
|
|
"UPDATE_STOP_PID_CHANGED"
|
|
);
|
|
thread::sleep(Duration::from_millis(20));
|
|
}
|
|
fence.after_effect(&effect, &digest(&serde_json::to_vec(&held.proof)?))?;
|
|
}
|
|
let result = StoppedServices {
|
|
systemd: self,
|
|
original,
|
|
};
|
|
result.verify_still_stopped(budget)?;
|
|
Ok(result)
|
|
}
|
|
}
|
|
impl HeldService {
|
|
pub fn started_proof(&self, budget: &Budget) -> Result<rmm_updater_handoff::StartedService> {
|
|
self.verify(budget)?;
|
|
ensure!(
|
|
self.proof.service != Service::Apt,
|
|
"UPDATE_APT_NOT_IN_START_SET"
|
|
);
|
|
Ok(rmm_updater_handoff::StartedService {
|
|
service: self.proof.service.handoff_service()?,
|
|
process: rmm_updater_handoff::Process {
|
|
pid: self.proof.process.pid,
|
|
birth: self.proof.process.birth,
|
|
image_sha256: self.proof.process.image_sha256.clone(),
|
|
},
|
|
})
|
|
}
|
|
pub fn proof(&self) -> &ServiceProof {
|
|
&self.proof
|
|
}
|
|
pub fn verify(&self, budget: &Budget) -> Result<()> {
|
|
self.process.verify()?;
|
|
let current = Systemd::status(self.proof.service, budget)?;
|
|
ensure!(
|
|
current["ActiveState"] == "active"
|
|
&& current["MainPID"] == self.proof.process.pid.to_string()
|
|
&& current["InvocationID"] == self.proof.invocation_id
|
|
&& current["UnitFileState"] == self.proof.enabled
|
|
&& unit_composition(¤t)? == self.proof.unit_sha256,
|
|
"UPDATE_SERVICE_BINDING_CHANGED"
|
|
);
|
|
self.process.verify()
|
|
}
|
|
/// Authenticate the actual local connection independently of request JSON.
|
|
/// Root alone is insufficient; the fixed service's held pidfd must match.
|
|
pub fn authenticate_peer(
|
|
&self,
|
|
socket: &UnixStream,
|
|
budget: &Budget,
|
|
) -> Result<rmm_domain::agent_update::ParticipantIdentity> {
|
|
use rmm_domain::agent_update::{ParticipantIdentity, ParticipantRole};
|
|
self.verify(budget)?;
|
|
let mut peer = std::mem::MaybeUninit::<libc::ucred>::uninit();
|
|
let mut len = std::mem::size_of::<libc::ucred>() as libc::socklen_t;
|
|
// SAFETY: live Unix socket, correctly sized writable ucred and length.
|
|
let result = unsafe {
|
|
libc::getsockopt(
|
|
socket.as_raw_fd(),
|
|
libc::SOL_SOCKET,
|
|
libc::SO_PEERCRED,
|
|
peer.as_mut_ptr().cast(),
|
|
&mut len,
|
|
)
|
|
};
|
|
ensure!(
|
|
result == 0 && len as usize == std::mem::size_of::<libc::ucred>(),
|
|
"UPDATE_PEER_CREDENTIALS"
|
|
);
|
|
let peer = unsafe { peer.assume_init() };
|
|
ensure!(
|
|
peer.pid > 0
|
|
&& peer.pid as u32 == self.proof.process.pid
|
|
&& peer.uid == 0
|
|
&& peer.gid == self.proof.process.gid,
|
|
"UPDATE_PEER_SERVICE_BINDING"
|
|
);
|
|
let role = match self.proof.service {
|
|
Service::Updater => ParticipantRole::LinuxUpdater,
|
|
Service::General => ParticipantRole::LinuxGeneralHelper,
|
|
Service::Full => ParticipantRole::LinuxFullHelper,
|
|
_ => anyhow::bail!("UPDATE_PARTICIPANT_ROLE"),
|
|
};
|
|
self.verify(budget)?;
|
|
Ok(ParticipantIdentity {
|
|
role,
|
|
pid: self.proof.process.pid,
|
|
birth: self.proof.process.birth,
|
|
image_sha256: self.proof.process.image_sha256.clone(),
|
|
security_principal: "uid:0".into(),
|
|
service_instance_sha256: digest(&serde_json::to_vec(&self.proof)?),
|
|
})
|
|
}
|
|
}
|
|
|
|
pub struct StoppedServices {
|
|
systemd: Systemd,
|
|
original: Vec<HeldService>,
|
|
}
|
|
impl StoppedServices {
|
|
pub fn verify_still_stopped(&self, budget: &Budget) -> Result<()> {
|
|
for pin in &self.systemd.policies {
|
|
let s = Systemd::status(pin.service, budget)?;
|
|
ensure!(
|
|
s["ActiveState"] == "inactive"
|
|
&& s["MainPID"] == "0"
|
|
&& unit_composition(&s)? == pin.unit_sha256,
|
|
"UPDATE_READER_NOT_STOPPED"
|
|
);
|
|
if pin.service == Service::Apt {
|
|
ensure!(
|
|
s["UnitFileState"] == "disabled",
|
|
"UPDATE_APT_MUST_REMAIN_CLOSED"
|
|
);
|
|
}
|
|
}
|
|
ensure!(
|
|
self.original
|
|
.iter()
|
|
.all(|s| s.process.exited().unwrap_or(false)),
|
|
"UPDATE_OLD_PROCESS_STILL_LIVE"
|
|
);
|
|
Ok(())
|
|
}
|
|
pub fn proofs(&self) -> Vec<ServiceProof> {
|
|
self.original.iter().map(|s| s.proof.clone()).collect()
|
|
}
|
|
/// The embedding fence MUST verify the exact PairVerified and durable
|
|
/// LedgerReturnIntent, released same guard and new target hashes first.
|
|
pub fn start_once(
|
|
self,
|
|
new: Systemd,
|
|
budget: &Budget,
|
|
fence: &mut impl DurableEffectFence,
|
|
) -> Result<Vec<HeldService>> {
|
|
self.verify_still_stopped(budget)?;
|
|
ensure!(
|
|
self.systemd
|
|
.policies
|
|
.iter()
|
|
.map(|p| p.service)
|
|
.eq(new.policies.iter().map(|p| p.service)),
|
|
"UPDATE_START_SET_CHANGED"
|
|
);
|
|
let mut started = Vec::new();
|
|
for service in [Service::General, Service::Full, Service::Agent] {
|
|
let effect = Effect::StartService { service };
|
|
fence.before_effect(&effect)?;
|
|
budget.check()?;
|
|
command(&["--no-block", "start", service.unit()], budget)?;
|
|
loop {
|
|
budget.check()?;
|
|
let state = Systemd::status(service, budget)?;
|
|
if state["ActiveState"] == "active" && state["MainPID"] != "0" {
|
|
let held = new.observe(service, budget)?;
|
|
ensure!(
|
|
!self
|
|
.original
|
|
.iter()
|
|
.any(|old| old.proof.process.pid == held.proof.process.pid),
|
|
"UPDATE_PROCESS_REUSE"
|
|
);
|
|
fence.after_effect(&effect, &digest(&serde_json::to_vec(&held.proof)?))?;
|
|
started.push(held);
|
|
break;
|
|
}
|
|
ensure!(
|
|
state["ActiveState"] == "activating" || state["ActiveState"] == "active",
|
|
"UPDATE_START_UNPROVEN"
|
|
);
|
|
thread::sleep(Duration::from_millis(20));
|
|
}
|
|
}
|
|
// Return in the canonical Handoff stop-set order, not actual start order.
|
|
started.sort_by_key(|s| s.proof.service);
|
|
Ok(started)
|
|
}
|
|
}
|
|
|
|
fn unit_composition(fields: &BTreeMap<String, String>) -> Result<String> {
|
|
use crate::files::Directory;
|
|
use std::{ffi::OsStr, path::Path};
|
|
let fragment = fields
|
|
.get("FragmentPath")
|
|
.ok_or_else(|| anyhow::anyhow!("UPDATE_UNIT_FRAGMENT"))?;
|
|
let mut paths = vec![fragment.as_str()];
|
|
paths.extend(
|
|
fields
|
|
.get("DropInPaths")
|
|
.ok_or_else(|| anyhow::anyhow!("UPDATE_UNIT_DROPINS"))?
|
|
.split_ascii_whitespace(),
|
|
);
|
|
let mut proof = Vec::new();
|
|
for path in paths {
|
|
let path = Path::new(path);
|
|
ensure!(path.is_absolute(), "UPDATE_UNIT_PATH");
|
|
let directory = Directory::open(
|
|
path.parent()
|
|
.ok_or_else(|| anyhow::anyhow!("UPDATE_UNIT_PARENT"))?,
|
|
0,
|
|
false,
|
|
)?;
|
|
let file = directory.inspect(path.file_name().unwrap_or(OsStr::new("")), 0, 65536)?;
|
|
proof.push((path.to_string_lossy().into_owned(), file.proof().clone()));
|
|
}
|
|
Ok(digest(&serde_json::to_vec(&proof)?))
|
|
}
|
|
|
|
struct OwnedCommand {
|
|
child: Child,
|
|
pidfd: File,
|
|
}
|
|
impl Drop for OwnedCommand {
|
|
fn drop(&mut self) {
|
|
// Signal this exact retained kernel process, including on every early
|
|
// error. An exited child cannot turn the descriptor into another PID.
|
|
unsafe {
|
|
libc::syscall(
|
|
libc::SYS_pidfd_send_signal,
|
|
self.pidfd.as_raw_fd(),
|
|
libc::SIGKILL,
|
|
0usize,
|
|
0,
|
|
)
|
|
};
|
|
let _ = self.child.wait();
|
|
}
|
|
}
|
|
fn drain(stream: &mut dyn Read, buffer: &mut Vec<u8>) -> Result<()> {
|
|
let mut bytes = [0; 1024];
|
|
loop {
|
|
match stream.read(&mut bytes) {
|
|
Ok(0) => break,
|
|
Ok(n) => {
|
|
ensure!(buffer.len() + n <= 16384, "UPDATE_COMMAND_OUTPUT_LIMIT");
|
|
buffer.extend_from_slice(&bytes[..n]);
|
|
}
|
|
Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => break,
|
|
Err(e) => return Err(e.into()),
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
fn command(args: &[&str], budget: &Budget) -> Result<Vec<u8>> {
|
|
budget.check()?;
|
|
let mut child = Command::new("/usr/bin/systemctl")
|
|
.args(["--system", "--no-ask-password", "--no-pager"])
|
|
.args(args)
|
|
.env_clear()
|
|
.env("PATH", "/usr/bin:/bin")
|
|
.env("LC_ALL", "C")
|
|
.stdin(Stdio::null())
|
|
.stdout(Stdio::piped())
|
|
.stderr(Stdio::piped())
|
|
.spawn()?;
|
|
// A live Child has not been reaped, so this pidfd cannot target a reused PID.
|
|
let raw = unsafe { libc::syscall(libc::SYS_pidfd_open, child.id(), 0) };
|
|
if raw < 0 {
|
|
let _ = child.kill();
|
|
let _ = child.wait();
|
|
anyhow::bail!("UPDATE_COMMAND_PIDFD_UNAVAILABLE");
|
|
}
|
|
let pidfd = unsafe { File::from_raw_fd(raw as i32) };
|
|
let mut owned = OwnedCommand { child, pidfd };
|
|
let deadline = Instant::now() + Duration::from_secs(10);
|
|
let mut stdout = owned.child.stdout.take().unwrap();
|
|
let mut stderr = owned.child.stderr.take().unwrap();
|
|
for fd in [stdout.as_raw_fd(), stderr.as_raw_fd()] {
|
|
ensure!(
|
|
unsafe { libc::fcntl(fd, libc::F_SETFL, libc::O_NONBLOCK) } >= 0,
|
|
"UPDATE_COMMAND_NONBLOCK"
|
|
);
|
|
}
|
|
let mut out = Vec::new();
|
|
let mut error = Vec::new();
|
|
loop {
|
|
drain(&mut stdout, &mut out)?;
|
|
drain(&mut stderr, &mut error)?;
|
|
if let Some(status) = owned.child.try_wait()? {
|
|
drain(&mut stdout, &mut out)?;
|
|
drain(&mut stderr, &mut error)?;
|
|
ensure!(status.success(), "UPDATE_SYSTEMD_COMMAND_FAILED");
|
|
return Ok(out);
|
|
}
|
|
if budget.check().is_err() || Instant::now() >= deadline {
|
|
// Kill only our held systemctl client. A request may already have
|
|
// reached systemd: the embedding worker must record Unknown.
|
|
anyhow::bail!("UPDATE_SYSTEMD_REPLY_UNKNOWN");
|
|
}
|
|
thread::sleep(Duration::from_millis(5));
|
|
}
|
|
}
|