302 lines
11 KiB
Rust
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)
|
|
}
|