Files
rust-discovery/crates/agent-windows/src/update_control_ipc.rs
T

302 lines
11 KiB
Rust

//! Reverse stable-updater -> SYSTEM-helper control. A distinct fixed endpoint
//! never broadens the LocalService pipe into an updater effect API. Native
//! control still requires the ORIGINAL guarded journal and phase-specific proof.
use crate::{
helper_ipc::{self as ipc, PeerProof},
update_ipc::Pin,
};
use anyhow::{Result, ensure};
use rmm_agent_core::update_handoff::{
NativeControlOperation, NativeControlReply, NativeControlRequest, NativeService,
};
use std::{
mem::size_of,
os::windows::io::{AsRawHandle, OwnedHandle},
ptr,
time::{Duration, Instant},
};
use windows_sys::Win32::{
Foundation::*,
Security::*,
Storage::FileSystem::*,
System::{Pipes::*, Threading::*},
};
pub const PIPE: &str = r"\\.\pipe\RustDiscovery-System-Update-v1";
fn request_valid(pin: &Pin, r: &NativeControlRequest) -> Result<()> {
ensure!(
r.operation == "agent_update_control_v1"
&& r.schema_version == 1
&& !r.challenge.is_nil()
&& r.tenant_id == pin.binding.tenant_id
&& r.asset_id == pin.binding.asset_id
&& r.agent_id == pin.binding.agent_id
&& r.enrollment_generation == pin.binding.enrollment_generation
&& r.assignment_version == pin.binding.assignment_version
&& !r.grant_id.is_nil()
&& !r.owner_nonce.is_nil()
&& ipc::digest(&r.handoff_sha256),
"UPDATE_CONTROL_REQUEST_BINDING"
);
match &r.method {
NativeControlOperation::ClaimStop {
expected_head_sha256,
service,
} => ensure!(
ipc::digest(expected_head_sha256)
&& matches!(
service,
NativeService::WindowsAgent | NativeService::WindowsHelper
),
"UPDATE_CONTROL_WINDOWS_STOP_ONLY"
),
NativeControlOperation::Health { receipt } => ensure!(
!receipt.payload.is_empty()
&& receipt.payload.len() <= 4096
&& receipt.signature.len() == 64,
"UPDATE_CONTROL_HEALTH_LIMIT"
),
NativeControlOperation::ObserveStarts {
services,
observation_sha256,
} => ensure!(
services.len() == 2 && ipc::digest(observation_sha256),
"UPDATE_CONTROL_START_LIMIT"
),
NativeControlOperation::ReadOriginal | NativeControlOperation::Finalize => {}
}
Ok(())
}
fn reply_valid(r: &NativeControlRequest, v: &NativeControlReply) -> Result<()> {
ensure!(
v.schema_version == 1
&& v.challenge == r.challenge
&& v.tenant_id == r.tenant_id
&& v.asset_id == r.asset_id
&& v.agent_id == r.agent_id
&& v.enrollment_generation == r.enrollment_generation
&& v.assignment_version == r.assignment_version
&& v.grant_id == r.grant_id
&& v.owner_nonce == r.owner_nonce
&& v.handoff_sha256 == r.handoff_sha256
&& !v.ready,
"UPDATE_CONTROL_REPLY_BINDING"
);
if let Some(proof) = &v.proof {
ensure!(
proof.delegation.owner_nonce == r.owner_nonce
&& proof.delegation.handoff_sha256 == r.handoff_sha256,
"UPDATE_CONTROL_PROOF_BINDING"
);
}
ensure!(
v.original_start_base64url
.as_ref()
.is_none_or(|s| s.len() <= 699051)
&& v.original_outcome_base64url
.as_ref()
.is_none_or(|s| s.len() <= 699051),
"UPDATE_CONTROL_REPLY_LIMIT"
);
match (
&v.pre_stop_sync_request_base64url,
&v.pre_stop_sync_response_base64url,
) {
(None, None) => {}
(Some(request), Some(response)) => {
use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
ensure!(
matches!(r.method, NativeControlOperation::ReadOriginal)
&& request.len() <= 699051
&& response.len() <= 699051,
"UPDATE_CONTROL_PRESTOP_SCOPE_LIMIT"
);
for raw in [request, response] {
let decoded = URL_SAFE_NO_PAD.decode(raw)?;
ensure!(
!decoded.is_empty()
&& decoded.len() <= 512 * 1024
&& URL_SAFE_NO_PAD.encode(&decoded) == *raw,
"UPDATE_CONTROL_PRESTOP_CANONICAL"
);
}
}
_ => anyhow::bail!("UPDATE_CONTROL_PRESTOP_PAIR_REQUIRED"),
}
match &r.method {
NativeControlOperation::ReadOriginal => ensure!(
v.original_start_base64url.is_some()
&& v.original_outcome_base64url.is_none()
&& v.claim.is_none(),
"UPDATE_CONTROL_READ_REPLY"
),
NativeControlOperation::ClaimStop { .. } => ensure!(
v.claim.is_some()
&& v.original_start_base64url.is_none()
&& v.original_outcome_base64url.is_none(),
"UPDATE_CONTROL_CLAIM_REPLY"
),
NativeControlOperation::ObserveStarts { .. } | NativeControlOperation::Health { .. } => {
ensure!(
v.original_start_base64url.is_none()
&& v.original_outcome_base64url.is_none()
&& v.claim.is_none(),
"UPDATE_CONTROL_PHASE_REPLY"
)
}
NativeControlOperation::Finalize => ensure!(
v.original_start_base64url.is_none() && v.claim.is_none(),
"UPDATE_CONTROL_FINAL_REPLY"
),
}
Ok(())
}
pub trait Engine {
fn handle(
&mut self,
peer: &mut PeerProof,
request: &NativeControlRequest,
) -> Result<NativeControlReply>;
}
pub struct Server {
pin: Pin,
pipe: OwnedHandle,
}
pub struct Received {
pub request: NativeControlRequest,
pub peer: PeerProof,
}
impl Server {
pub fn bind(pin: Pin) -> Result<Self> {
pin.validate()?;
ipc::require_self(&pin.helper)?;
let d = ipc::Descriptor::from(&format!(
"O:SYG:SYD:P(D;;GA;;;NU)(A;;GA;;;SY)(A;;GA;;;BA)(A;;GA;;;{})(A;;0x{:08x};;;{})",
pin.helper.service_sid,
ipc::CLIENT_PIPE_RIGHTS,
pin.updater.service_sid
))?;
let sa = SECURITY_ATTRIBUTES {
nLength: size_of::<SECURITY_ATTRIBUTES>() as u32,
lpSecurityDescriptor: d.0,
bInheritHandle: 0,
};
let pipe = ipc::owned(unsafe {
CreateNamedPipeW(
ipc::wide(PIPE).as_ptr(),
PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED | FILE_FLAG_FIRST_PIPE_INSTANCE,
PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT | PIPE_REJECT_REMOTE_CLIENTS,
1,
65536,
65536,
1000,
&sa,
)
})?;
Ok(Self { pin, pipe })
}
pub fn receive(&self) -> Result<Option<Received>> {
ipc::require_self(&self.pin.helper)?;
let pipe = self.pipe.as_raw_handle();
let mut event = ipc::IoEvent::new()?;
if unsafe { ConnectNamedPipe(pipe, &mut event.overlapped) } == 0 {
let error = unsafe { GetLastError() };
if error == ERROR_IO_PENDING {
if let Err(e) = event.wait(pipe, Instant::now() + Duration::from_millis(25)) {
if ipc::diagnostic(&e).code == "HELPER_PIPE_TIMEOUT" {
self.disconnect();
return Ok(None);
}
return Err(e);
}
} else {
ensure!(error == ERROR_PIPE_CONNECTED, "UPDATE_CONTROL_CONNECT");
}
}
let deadline = Instant::now() + Duration::from_secs(5);
let len = ipc::length(pipe, deadline)?;
let mut peer = PeerProof::capture(pipe, &self.pin.updater, true)?;
ensure!(
unsafe { ImpersonateNamedPipeClient(pipe) } != 0,
"UPDATE_CONTROL_IMPERSONATE"
);
let auth = (|| -> Result<()> {
let mut token = ptr::null_mut();
ensure!(
unsafe { OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, 1, &mut token) } != 0,
"UPDATE_CONTROL_THREAD_TOKEN"
);
let token = ipc::owned(token)?;
ipc::verify_token(
token.as_raw_handle(),
&self.pin.updater.user_sid,
&self.pin.updater.service_sid,
)
})();
if unsafe { RevertToSelf() } == 0 {
std::process::abort();
}
auth?;
ipc::require_self(&self.pin.helper)?;
let request: NativeControlRequest = ipc::body(pipe, len, deadline)?;
request_valid(&self.pin, &request)?;
peer.check()?;
Ok(Some(Received { request, peer }))
}
pub fn reply(&self, received: &mut Received, reply: &NativeControlReply) -> Result<()> {
reply_valid(&received.request, reply)?;
received.peer.check()?;
let mut raw = ipc::encode(reply)?;
let deadline = Instant::now() + Duration::from_secs(5);
ipc::send_bytes(self.pipe.as_raw_handle(), &mut raw, deadline)?;
let mut receipt = [0; ipc::DRAIN_RECEIPT_LEN];
ipc::transfer(self.pipe.as_raw_handle(), &mut receipt, false, deadline)?;
ipc::verify_drain_receipt(&receipt, received.request.challenge, &raw)?;
received.peer.check()
}
pub fn serve_one(&self, engine: &mut impl Engine) -> Result<bool> {
let result = (|| -> Result<bool> {
let Some(mut received) = self.receive()? else {
return Ok(false);
};
let reply = engine.handle(&mut received.peer, &received.request)?;
self.reply(&mut received, &reply)?;
Ok(true)
})();
self.disconnect();
result
}
pub fn disconnect(&self) {
unsafe {
DisconnectNamedPipe(self.pipe.as_raw_handle());
}
}
}
/// One original request, no reconnect/retry of a possibly committed claim.
pub fn exchange(pin: &Pin, request: &NativeControlRequest) -> Result<NativeControlReply> {
pin.validate()?;
request_valid(pin, request)?;
ipc::require_self(&pin.updater)?;
let pipe = ipc::owned(unsafe {
CreateFileW(
ipc::wide(PIPE).as_ptr(),
ipc::CLIENT_PIPE_RIGHTS,
0,
ptr::null(),
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED | SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION,
ptr::null_mut(),
)
})?;
let mut peer = PeerProof::capture(pipe.as_raw_handle(), &pin.helper, false)?;
let deadline = Instant::now() + Duration::from_secs(5);
ipc::send(pipe.as_raw_handle(), request, deadline)?;
let length = ipc::length(pipe.as_raw_handle(), deadline)?;
let raw = ipc::body_bytes(pipe.as_raw_handle(), length, deadline)?;
let reply: NativeControlReply = serde_json::from_slice(&raw)?;
reply_valid(request, &reply)?;
peer.check()?;
let mut receipt = ipc::drain_receipt(request.challenge, &raw);
ipc::transfer(pipe.as_raw_handle(), &mut receipt, true, deadline)?;
Ok(reply)
}