Files
rust-discovery/crates/updater-worker/src/bridge.rs
T
2026-11-15 00:18:43 +01:00

570 lines
21 KiB
Rust

//! Bounded client of the EXISTING fixed Fullhelper control socket. No retry,
//! SQL/event transport, caller paths, process-name or root-UID-only fallback.
use crate::{clock::NativeClock, participants::StableParticipant};
use anyhow::{Context, Result, ensure};
use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
use rmm_agent_core::{
reconcile::SyncClock,
update_handoff::{
NativeControlOperation, NativeControlReply, NativeControlRequest, NativeEffect,
NativeEffectClaim,
},
};
use rmm_domain::{
agent_update::{ParticipantRole, UpdateDelegation, UpdateInflightProof, verify_inflight_proof},
reconciliation::{ReconciledOutcome, canonical_outcome_bytes},
};
use rmm_updater_handoff::{Handoff, Phase};
use rmm_updater_linux::{
Budget,
files::Directory,
services::{Service, Systemd},
};
use std::{
io::{Read, Write},
os::{
fd::{AsRawFd, FromRawFd},
unix::{
fs::{FileTypeExt, MetadataExt},
net::UnixStream,
},
},
path::Path,
time::{Duration, Instant},
};
use uuid::Uuid;
const SOCKET: &str = "/run/rmm-helper-maintenance/control.sock";
const MAX_REPLY: usize = 1536 * 1024;
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum Generation {
Original,
Replacement,
}
pub struct BridgeContext<'a> {
pub handoff: &'a Handoff,
pub delegation: &'a UpdateDelegation,
pub services: &'a Systemd,
pub updater: &'a StableParticipant,
pub clock: &'a NativeClock,
pub budget: &'a Budget,
pub health_public_key: [u8; 32],
pub generation: Generation,
}
pub struct FullBridge<'a> {
context: BridgeContext<'a>,
prefix: Option<UpdateInflightProof>,
poisoned: bool,
finalized: bool,
}
pub struct Reply {
pub proof: Option<UpdateInflightProof>,
pub original_start: Option<Vec<u8>>,
pub claim: Option<NativeEffectClaim>,
pub original_outcome: Option<Vec<u8>>,
}
impl<'a> FullBridge<'a> {
/// Prefix is either the exact initial atomic StopIntent or a complete
/// retained prefix read under the original guarded ledger. Never truncate.
pub fn new(context: BridgeContext<'a>, prefix: UpdateInflightProof) -> Result<Self> {
let (handoff, _) = verify_inflight_proof(&prefix, context.health_public_key)
.map_err(anyhow::Error::msg)?;
ensure!(
handoff.bytes()? == context.handoff.bytes()?
&& prefix.delegation == *context.delegation,
"UPDATE_BRIDGE_PREFIX_BINDING"
);
Ok(Self {
context,
prefix: Some(prefix),
poisoned: false,
finalized: false,
})
}
/// First read obtains the actual original prefix from the authenticated
/// Full process/ledger. No event is synthesized from a caller's header.
pub fn original(context: BridgeContext<'a>) -> Result<Self> {
ensure!(
context.generation == Generation::Original,
"UPDATE_BRIDGE_ORIGINAL_ONLY"
);
context.handoff.validate()?;
ensure!(
context.delegation.handoff_sha256 == rmm_domain::jobs::hash(&context.handoff.bytes()?)
&& context.delegation.owner_nonce == context.handoff.owner_nonce,
"UPDATE_BRIDGE_ORIGINAL_HEADER"
);
Ok(Self {
context,
prefix: None,
poisoned: false,
finalized: false,
})
}
pub fn call(&mut self, method: NativeControlOperation) -> Result<Reply> {
let context = &self.context;
context
.updater
.verify_delegation(context.delegation, context.budget)?;
context.budget.check()?;
if self.prefix.is_none() {
ensure!(
matches!(method, NativeControlOperation::ReadOriginal),
"UPDATE_BRIDGE_ORIGINAL_READ_REQUIRED"
);
}
let journal = self
.prefix
.as_ref()
.map(|prefix| {
verify_inflight_proof(prefix, context.health_public_key)
.map(|(_, journal)| journal)
.map_err(anyhow::Error::msg)
})
.transpose()?;
match &method {
NativeControlOperation::ReadOriginal => {}
NativeControlOperation::ClaimStop {
expected_head_sha256,
..
} => ensure!(
context.generation == Generation::Original
&& journal
.as_ref()
.is_some_and(|j| j.phase() == Phase::StopIntent)
&& Some(expected_head_sha256.as_str())
== self.prefix.as_ref().map(|p| p.head_sha256.as_str()),
"UPDATE_BRIDGE_CLAIM_PHASE"
),
NativeControlOperation::ObserveStarts { .. } => ensure!(
context.generation == Generation::Replacement
&& journal
.as_ref()
.is_some_and(|j| j.phase() == Phase::LedgerReturnIntent),
"UPDATE_BRIDGE_START_PHASE"
),
NativeControlOperation::Health { receipt } => {
ensure!(
context.generation == Generation::Replacement
&& journal
.as_ref()
.is_some_and(|j| j.phase() == Phase::ServicesStarted),
"UPDATE_BRIDGE_HEALTH_PHASE"
);
journal
.as_ref()
.context("UPDATE_BRIDGE_ORIGINAL_READ_REQUIRED")?
.prepare(
u64::try_from(context.clock.now()?.timestamp())?,
rmm_updater_handoff::Evidence::HealthVerified {
receipt: receipt.clone(),
},
)?;
}
NativeControlOperation::Finalize => ensure!(
context.generation == Generation::Replacement
&& journal
.as_ref()
.is_some_and(|j| j.phase() == Phase::HealthVerified),
"UPDATE_BRIDGE_FINAL_PHASE"
),
}
let mutating = !matches!(method, NativeControlOperation::ReadOriginal);
ensure!(
!self.finalized && (!mutating || !self.poisoned),
"UPDATE_BRIDGE_NO_RETRY_OR_RESUME"
);
if mutating {
self.poisoned = true;
}
let io_budget = IoBudget {
clock: context.clock,
budget: context.budget,
finish_before: context.handoff.finish_before,
until: Instant::now() + Duration::from_secs(5),
};
io_budget.remaining()?;
ensure!(
std::fs::read_to_string("/proc/sys/kernel/random/boot_id")?
.trim()
.parse::<Uuid>()?
== context.handoff.boot_id,
"UPDATE_BRIDGE_BOOT_CHANGED"
);
let directory = Directory::open(Path::new("/run/rmm-helper-maintenance"), 0, false)?;
let meta = std::fs::symlink_metadata(SOCKET)?;
ensure!(
meta.file_type().is_socket()
&& meta.uid() == 0
&& meta.mode() & 0o007 == 0
&& meta.nlink() == 1,
"UPDATE_BRIDGE_SOCKET_PERMISSIONS"
);
let stream = connect(&io_budget)?;
directory.verify()?;
let after = std::fs::symlink_metadata(SOCKET)?;
ensure!(
meta.dev() == after.dev()
&& meta.ino() == after.ino()
&& meta.mode() == after.mode()
&& meta.uid() == after.uid()
&& meta.gid() == after.gid(),
"UPDATE_BRIDGE_SOCKET_CHANGED"
);
let helper = context.services.observe(Service::Full, context.budget)?;
let peer = helper.authenticate_peer(&stream, context.budget)?;
ensure!(
peer.role == ParticipantRole::LinuxFullHelper,
"UPDATE_BRIDGE_FULL_REQUIRED"
);
match context.generation {
Generation::Original => ensure!(
peer == context.delegation.original_helper,
"UPDATE_BRIDGE_ORIGINAL_HELPER_CHANGED"
),
Generation::Replacement => ensure!(
peer.image_sha256 == context.handoff.target.helper_sha256
&& peer.pid != context.delegation.original_helper.pid,
"UPDATE_BRIDGE_REPLACEMENT_HELPER_CHANGED"
),
}
let request = NativeControlRequest {
operation: "agent_update_control_v1".into(),
schema_version: 1,
challenge: Uuid::new_v4(),
tenant_id: context.handoff.attempt.tenant_id,
asset_id: context.handoff.attempt.asset_id,
agent_id: context.handoff.attempt.agent_id,
enrollment_generation: context.handoff.attempt.enrollment_generation,
assignment_version: context.handoff.attempt.assignment_version,
grant_id: context.handoff.attempt.grant_id,
owner_nonce: context.handoff.owner_nonce,
handoff_sha256: context.delegation.handoff_sha256.clone(),
method,
};
let raw = serde_json::to_vec(&request)?;
ensure!(
!raw.is_empty() && raw.len() <= 32768,
"UPDATE_BRIDGE_REQUEST_LIMIT"
);
let mut io = SocketIo {
stream,
budget: io_budget,
};
io.write_all(&(raw.len() as u32).to_be_bytes())?;
io.write_all(&raw)?;
io.flush()?;
let mut size = [0; 4];
io.read_exact(&mut size)?;
let size = u32::from_be_bytes(size) as usize;
ensure!(size > 0 && size <= MAX_REPLY, "UPDATE_BRIDGE_REPLY_LIMIT");
let mut raw = vec![0; size];
io.read_exact(&mut raw)?;
let reply: NativeControlReply = serde_json::from_slice(&raw)?;
helper.verify(context.budget)?;
ensure!(
reply.schema_version == 1
&& !reply.ready
&& reply.challenge == request.challenge
&& reply.tenant_id == request.tenant_id
&& reply.asset_id == request.asset_id
&& reply.agent_id == request.agent_id
&& reply.enrollment_generation == request.enrollment_generation
&& reply.assignment_version == request.assignment_version
&& reply.grant_id == request.grant_id
&& reply.owner_nonce == request.owner_nonce
&& reply.handoff_sha256 == request.handoff_sha256,
"UPDATE_BRIDGE_REPLY_BINDING"
);
let original_start = reply
.original_start_base64url
.as_deref()
.map(|v| decode(v, 512 * 1024))
.transpose()?;
let original_outcome = reply
.original_outcome_base64url
.as_deref()
.map(|v| decode(v, 512 * 1024))
.transpose()?;
if matches!(request.method, NativeControlOperation::Finalize) {
ensure!(
reply.proof.is_none() && reply.claim.is_none() && original_start.is_none(),
"UPDATE_BRIDGE_FINAL_REPLY"
);
let raw = original_outcome
.as_ref()
.context("UPDATE_BRIDGE_ORIGINAL_OUTCOME_MISSING")?;
let outcome: ReconciledOutcome = serde_json::from_slice(raw)?;
ensure!(
canonical_outcome_bytes(&outcome)? == *raw
&& outcome.state == "succeeded"
&& !outcome.reboot_required,
"UPDATE_BRIDGE_NONCANONICAL_OR_UNSUCCESSFUL_OUTCOME"
);
} else {
ensure!(
original_outcome.is_none(),
"UPDATE_BRIDGE_UNEXPECTED_TERMINAL"
);
let proof = reply
.proof
.as_ref()
.context("UPDATE_BRIDGE_PROOF_MISSING")?;
let (handoff, journal) = verify_inflight_proof(proof, context.health_public_key)
.map_err(anyhow::Error::msg)?;
ensure!(
handoff.bytes()? == context.handoff.bytes()?
&& proof.delegation == *context.delegation
&& self
.prefix
.as_ref()
.is_none_or(|prior| proof.events.len() >= prior.events.len()
&& proof.events[..prior.events.len()] == prior.events),
"UPDATE_BRIDGE_PROOF_ROLLBACK_OR_CHANGED"
);
match request.method {
NativeControlOperation::ReadOriginal => ensure!(
reply.claim.is_none() && original_start.is_some(),
"UPDATE_BRIDGE_ORIGINAL_REPLY"
),
NativeControlOperation::ClaimStop {
ref expected_head_sha256,
service,
} => {
let claim = reply
.claim
.as_ref()
.context("UPDATE_BRIDGE_STOP_CLAIM_MISSING")?;
ensure!(
context.generation == Generation::Original
&& journal.phase() == Phase::StopIntent
&& claim.effect() == &NativeEffect::StopService { service }
&& claim.grant_id() == request.grant_id
&& claim.owner_nonce() == request.owner_nonce
&& claim.head_sha256() == expected_head_sha256
&& proof.head_sha256 == *expected_head_sha256
&& original_start.is_none(),
"UPDATE_BRIDGE_STOP_CLAIM_CHANGED"
);
}
NativeControlOperation::ObserveStarts { .. } => ensure!(
context.generation == Generation::Replacement
&& journal.phase() == Phase::ServicesStarted
&& reply.claim.is_none()
&& original_start.is_none(),
"UPDATE_BRIDGE_STARTS_REPLY"
),
NativeControlOperation::Health { .. } => ensure!(
context.generation == Generation::Replacement
&& journal.phase() == Phase::HealthVerified
&& reply.claim.is_none()
&& original_start.is_none(),
"UPDATE_BRIDGE_HEALTH_REPLY"
),
NativeControlOperation::Finalize => unreachable!(),
}
self.prefix = Some(proof.clone());
}
context.budget.check()?;
if matches!(request.method, NativeControlOperation::Finalize) {
self.finalized = true;
}
if mutating {
self.poisoned = false;
}
Ok(Reply {
proof: reply.proof,
claim: reply.claim,
original_start,
original_outcome,
})
}
pub fn head_sha256(&self) -> Result<&str> {
self.prefix
.as_ref()
.map(|p| p.head_sha256.as_str())
.context("UPDATE_BRIDGE_ORIGINAL_READ_REQUIRED")
}
pub fn observe_starts(
&mut self,
held: &[rmm_updater_linux::services::HeldService],
) -> Result<Reply> {
ensure!(
held.len() == 3
&& held.iter().map(|s| s.proof().service).eq([
Service::Agent,
Service::General,
Service::Full
]),
"UPDATE_BRIDGE_STARTED_SET"
);
let services = held
.iter()
.map(|s| s.started_proof(self.context.budget))
.collect::<Result<Vec<_>>>()?;
let proofs = held.iter().map(|s| s.proof().clone()).collect::<Vec<_>>();
let observation_sha256 = rmm_domain::jobs::hash(&serde_json::to_vec(&proofs)?);
let reply = self.call(NativeControlOperation::ObserveStarts {
services: services.clone(),
observation_sha256: observation_sha256.clone(),
})?;
for service in held {
service.verify(self.context.budget)?;
}
let proof = reply
.proof
.as_ref()
.context("UPDATE_BRIDGE_STARTED_PROOF_MISSING")?;
let raw = proof.decode().map_err(anyhow::Error::msg)?;
let last: rmm_updater_handoff::Event = serde_json::from_slice(
raw.events
.last()
.context("UPDATE_BRIDGE_STARTED_EVENT_MISSING")?,
)?;
ensure!(
matches!(last.evidence,rmm_updater_handoff::Evidence::ServicesStarted {services:actual,observation_sha256:hash,..}
if actual==services && hash==observation_sha256),
"UPDATE_BRIDGE_STARTED_RESULT_CHANGED"
);
Ok(reply)
}
}
fn decode(value: &str, max: usize) -> Result<Vec<u8>> {
ensure!(
!value.is_empty() && value.len() <= 4 * max.div_ceil(3),
"UPDATE_BRIDGE_BASE64_LIMIT"
);
let raw = URL_SAFE_NO_PAD.decode(value)?;
ensure!(
!raw.is_empty() && raw.len() <= max && URL_SAFE_NO_PAD.encode(&raw) == value,
"UPDATE_BRIDGE_NONCANONICAL_BASE64"
);
Ok(raw)
}
struct IoBudget<'a> {
clock: &'a NativeClock,
budget: &'a Budget,
finish_before: u64,
until: Instant,
}
impl IoBudget<'_> {
fn remaining(&self) -> Result<Duration> {
self.budget.check()?;
let now = self.clock.now()?;
let finish = chrono::DateTime::from_timestamp(i64::try_from(self.finish_before)?, 0)
.context("UPDATE_BRIDGE_FINISH")?;
let original = (finish - now).to_std()?;
let frame = self.until.saturating_duration_since(Instant::now());
let remaining = original.min(frame);
ensure!(!remaining.is_zero(), "UPDATE_BRIDGE_DEADLINE");
Ok(remaining)
}
}
struct SocketIo<'a> {
stream: UnixStream,
budget: IoBudget<'a>,
}
impl Read for SocketIo<'_> {
fn read(&mut self, bytes: &mut [u8]) -> std::io::Result<usize> {
self.stream.set_read_timeout(Some(
self.budget.remaining().map_err(std::io::Error::other)?,
))?;
self.stream.read(bytes)
}
}
impl Write for SocketIo<'_> {
fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
self.stream.set_write_timeout(Some(
self.budget.remaining().map_err(std::io::Error::other)?,
))?;
self.stream.write(bytes)
}
fn flush(&mut self) -> std::io::Result<()> {
self.budget.remaining().map_err(std::io::Error::other)?;
self.stream.flush()
}
}
fn connect(budget: &IoBudget<'_>) -> Result<UnixStream> {
// A blocking Unix connect can wait forever on a full listener backlog.
// Use only the fixed path and an owned nonblocking socket, including during
// connect; never switch to a network endpoint or another helper.
let fd = unsafe {
libc::socket(
libc::AF_UNIX,
libc::SOCK_STREAM | libc::SOCK_CLOEXEC | libc::SOCK_NONBLOCK,
0,
)
};
ensure!(fd >= 0, "UPDATE_BRIDGE_SOCKET_CREATE");
let stream = unsafe { UnixStream::from_raw_fd(fd) };
let mut address: libc::sockaddr_un = unsafe { std::mem::zeroed() };
address.sun_family = libc::AF_UNIX as libc::sa_family_t;
ensure!(
SOCKET.len() < address.sun_path.len(),
"UPDATE_BRIDGE_FIXED_PATH_LIMIT"
);
for (slot, byte) in address.sun_path.iter_mut().zip(SOCKET.bytes()) {
*slot = byte as libc::c_char;
}
let result = unsafe {
libc::connect(
fd,
(&address as *const libc::sockaddr_un).cast(),
std::mem::size_of::<libc::sockaddr_un>() as libc::socklen_t,
)
};
if result < 0 {
let error = std::io::Error::last_os_error();
ensure!(
error.raw_os_error() == Some(libc::EINPROGRESS),
"UPDATE_BRIDGE_CONNECT: {error}"
);
loop {
let remaining = budget.remaining()?;
let mut poll = libc::pollfd {
fd: stream.as_raw_fd(),
events: libc::POLLOUT,
revents: 0,
};
let result = unsafe {
libc::poll(
&mut poll,
1,
i32::try_from(remaining.as_millis().min(200))?.max(1),
)
};
if result < 0 {
let error = std::io::Error::last_os_error();
ensure!(
error.kind() == std::io::ErrorKind::Interrupted,
"UPDATE_BRIDGE_CONNECT_POLL: {error}"
);
continue;
}
if result == 0 {
continue;
}
let mut error: libc::c_int = 0;
let mut length = std::mem::size_of_val(&error) as libc::socklen_t;
ensure!(
unsafe {
libc::getsockopt(
fd,
libc::SOL_SOCKET,
libc::SO_ERROR,
(&mut error as *mut libc::c_int).cast(),
&mut length,
)
} == 0
&& error == 0
&& poll.revents == libc::POLLOUT,
"UPDATE_BRIDGE_CONNECT_FAILED"
);
break;
}
}
budget.remaining()?;
stream.set_nonblocking(false)?;
Ok(stream)
}