//! 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; } pub struct Server { pin: Pin, pipe: OwnedHandle, } pub struct Received { pub request: NativeControlRequest, pub peer: PeerProof, } impl Server { pub fn bind(pin: Pin) -> Result { 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::() 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> { 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 { let result = (|| -> Result { 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 { 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) }