Integrate signed agent catalog, tenant enrollment and HTTPS installers
This commit is contained in:
@@ -0,0 +1,301 @@
|
||||
//! 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)
|
||||
}
|
||||
Reference in New Issue
Block a user