Files
rust-discovery/crates/agent-windows/examples/helper_peer_controls.rs
2026-11-14 07:43:36 +01:00

1021 lines
40 KiB
Rust

//! Negative, read-only raw Probe clients. Never SDK self-refusal as server proof.
//! The permanent services, their tokens/configuration and private state stay intact.
// Compile the unchanged production proof in this diagnostic crate. Keeping the
// module public avoids hiding its public transport API behind dead-code lint;
// no new API is exported from the agent library.
#[cfg(all(windows, feature = "system-helper"))]
#[path = "../src/helper_ipc.rs"]
pub mod helper_ipc;
#[cfg(all(windows, feature = "system-helper"))]
pub use rmm_agent_windows::SERVICE_NAME;
#[cfg(all(windows, feature = "system-helper"))]
mod platform {
use crate::helper_ipc as ipc;
use anyhow::{Result, ensure};
use serde::Deserialize;
use serde_json::json;
use std::{
fs::OpenOptions,
io::{Read, Write},
mem::{size_of, zeroed},
os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle},
path::PathBuf,
ptr,
sync::{
OnceLock,
atomic::{AtomicUsize, Ordering},
},
time::{Duration, Instant},
};
use windows_sys::Win32::{
Foundation::*,
Security::{Authorization::ConvertSidToStringSidW, *},
Storage::FileSystem::*,
System::{
IO::*, JobObjects::*, Pipes::GetNamedPipeServerProcessId, Services::*, Threading::*,
},
};
const NAME: &str = "RmmDiscoveryPeerControl";
// winnt.h TOKEN_GROUPS attributes; avoid adding Cargo feature dependencies.
const SE_GROUP_ENABLED: u32 = 0x4;
const SE_GROUP_USE_FOR_DENY_ONLY: u32 = 0x10;
const PARENT_NAME: &str = "RmmDiscoveryPeerParent";
const ROOT: &str = r"C:\ProgramData\RustDiscoveryPeerControls";
static CASE: OnceLock<uuid::Uuid> = OnceLock::new();
static IS_PARENT: OnceLock<bool> = OnceLock::new();
static DIRECT_PEER_PROOF: OnceLock<bool> = OnceLock::new();
static STATUS: AtomicUsize = AtomicUsize::new(0);
fn wide(s: &str) -> Vec<u16> {
s.encode_utf16().chain(Some(0)).collect()
}
fn owned(handle: HANDLE) -> Result<OwnedHandle> {
ensure!(
!handle.is_null() && handle != INVALID_HANDLE_VALUE,
"CONTROL_HANDLE"
);
Ok(unsafe { OwnedHandle::from_raw_handle(handle) })
}
fn sid_text(sid: PSID) -> Result<String> {
let mut text = ptr::null_mut();
ensure!(
unsafe { ConvertSidToStringSidW(sid, &mut text) } != 0,
"CONTROL_SID"
);
let result = (|| {
let mut n = 0;
while unsafe { *text.add(n) } != 0 {
n += 1;
ensure!(n <= 256, "CONTROL_SID_LIMIT");
}
Ok(String::from_utf16(unsafe {
std::slice::from_raw_parts(text, n)
})?)
})();
unsafe {
LocalFree(text.cast());
}
result
}
fn token_information(token: HANDLE, class: TOKEN_INFORMATION_CLASS) -> Result<Vec<usize>> {
let mut size = 0;
unsafe {
GetTokenInformation(token, class, ptr::null_mut(), 0, &mut size);
}
ensure!(size > 0 && size <= 65536, "CONTROL_TOKEN_LIMIT");
let mut bytes = vec![0usize; (size as usize).div_ceil(size_of::<usize>())];
ensure!(
unsafe {
GetTokenInformation(token, class, bytes.as_mut_ptr().cast(), size, &mut size)
} != 0,
"CONTROL_TOKEN_QUERY"
);
Ok(bytes)
}
fn token(mode: &str) -> Result<serde_json::Value> {
let mut raw = ptr::null_mut();
ensure!(
unsafe { OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &mut raw) } != 0,
"CONTROL_OWN_TOKEN"
);
let handle = owned(raw)?;
let user = token_information(handle.as_raw_handle(), TokenUser)?;
let user = unsafe { &*user.as_ptr().cast::<TOKEN_USER>() };
let user_sid = sid_text(user.User.Sid)?;
let groups = token_information(handle.as_raw_handle(), TokenGroups)?;
let groups_buffer_bytes = groups.len() * size_of::<usize>();
let groups = unsafe { &*groups.as_ptr().cast::<TOKEN_GROUPS>() };
ensure!(
groups.GroupCount <= 1024
&& std::mem::offset_of!(TOKEN_GROUPS, Groups)
+ groups.GroupCount as usize * size_of::<SID_AND_ATTRIBUTES>()
<= groups_buffer_bytes,
"CONTROL_GROUP_LIMIT"
);
let values = unsafe {
std::slice::from_raw_parts(groups.Groups.as_ptr(), groups.GroupCount as usize)
};
let control_sid = if mode == "service" {
ipc::service_sid(NAME)?
} else {
String::new()
};
let agent_sid = ipc::service_sid(rmm_agent_windows::SERVICE_NAME)?;
let enabled = |sid: &str| -> Result<bool> {
for value in values {
if value.Attributes & SE_GROUP_ENABLED != 0
&& value.Attributes & SE_GROUP_USE_FOR_DENY_ONLY == 0
&& sid_text(value.Sid)? == sid
{
return Ok(true);
}
}
Ok(false)
};
let control = enabled(&control_sid)?;
let agent = enabled(&agent_sid)?;
let admin = enabled("S-1-5-32-544")?;
if mode == "service" {
rmm_agent_windows::native::require_local_service()?;
ensure!(
user_sid == "S-1-5-19" && control && !agent && !admin,
"CONTROL_DISTINCT_LOCAL_SERVICE_SID"
);
} else if mode == "child" {
rmm_agent_windows::native::require_local_service()?;
ensure!(
user_sid == "S-1-5-19" && agent && !control && !admin,
"CONTROL_DUPLICATED_AGENT_IDENTITY"
);
} else if mode == "parent" {
ensure!(
user_sid == "S-1-5-18" && enabled(&ipc::service_sid(PARENT_NAME)?)?,
"CONTROL_OWN_SYSTEM_PARENT"
);
} else {
ensure!(
admin && user_sid != "S-1-5-19" && user_sid != "S-1-5-18" && !agent,
"CONTROL_BOOTSTRAP_ADMIN_ONLY"
);
}
Ok(
json!({"user_sid":user_sid,"administrator_enabled":admin,"control_service_sid":control_sid,"control_service_sid_enabled":control,"agent_service_sid_enabled":agent,"parent_service_sid":if mode=="parent"{Some(ipc::service_sid(PARENT_NAME)?)}else{None},"parent_service_sid_enabled":mode=="parent","actual_process_id":std::process::id()}),
)
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Input {
schema_version: u32,
case_id: uuid::Uuid,
pin: ipc::Pin,
expected_agent_pid: u32,
expected_helper_pid: u32,
expected_agent_creation: u64,
control_binary_sha256: String,
}
fn read_input(case: uuid::Uuid) -> Result<Input> {
let root = PathBuf::from(ROOT).join(case.to_string());
let path = root.join("input.json");
for path in [&root, &path] {
let metadata = std::fs::symlink_metadata(path)?;
ensure!(!metadata.is_symlink(), "CONTROL_INPUT_REPARSE");
}
let mut file = std::fs::File::open(path)?;
ensure!(file.metadata()?.len() <= 32768, "CONTROL_INPUT_SIZE");
let mut bytes = Vec::new();
Read::by_ref(&mut file)
.take(32769)
.read_to_end(&mut bytes)?;
ensure!(bytes.len() <= 32768, "CONTROL_INPUT_SIZE");
let value: Input = serde_json::from_slice(&bytes)?;
value.pin.validate()?;
let current = std::env::current_exe()?;
ensure!(
current
== PathBuf::from(ROOT)
.join(&value.control_binary_sha256)
.join("HelperPeerControls.exe"),
"CONTROL_OWN_FIXED_IMAGE"
);
let mut image = std::fs::File::open(current)?;
ensure!(
image.metadata()?.len() <= 128 * 1024 * 1024,
"CONTROL_IMAGE_LIMIT"
);
use sha2::Digest;
let mut hash = sha2::Sha256::new();
let mut buffer = [0u8; 65536];
loop {
let count = image.read(&mut buffer)?;
if count == 0 {
break;
}
hash.update(&buffer[..count]);
}
let hash: String = hash.finalize().iter().map(|b| format!("{b:02x}")).collect();
ensure!(hash == value.control_binary_sha256, "CONTROL_IMAGE_HASH");
ensure!(
value.schema_version == 1
&& value.case_id == case
&& value.expected_agent_pid > 0
&& value.expected_helper_pid > 0,
"CONTROL_INPUT_BINDING"
);
Ok(value)
}
fn save(case: uuid::Uuid, name: &str, value: &serde_json::Value) -> Result<()> {
let bytes = serde_json::to_vec(value)?;
ensure!(bytes.len() <= 8192, "CONTROL_REPORT_LIMIT");
let root = PathBuf::from(ROOT).join(case.to_string());
let (folder, writer) = match name {
"admin-token.json" | "admin-result.json" => ("admin", None),
"service-token.json" | "service-result.json" => {
("service", Some(ipc::service_sid(NAME)?))
}
"child-token.json" | "child-sdk-prechecks.json" | "child-result.json" => (
"child",
Some(ipc::service_sid(rmm_agent_windows::SERVICE_NAME)?),
),
"parent-token.json"
| "parent-result.json"
| "child-create-intent.json"
| "child-started.json" => ("controller", None),
_ => anyhow::bail!("CONTROL_FIXED_REPORT_NAME"),
};
let directory = root.join(folder);
let roles: Vec<String> = writer.into_iter().collect();
// Actor directories are read-only. Bootstrap precreates just the fixed
// writable leaves with SYSTEM/Admin ownership, so SID19 cannot gain
// owner-implied WRITE_DAC or forge a different actor's receipts.
let _parent = ipc::PinnedFile::open_read_shared(&directory, true, &roles, &[])?;
let path = directory.join(name);
if folder != "controller" {
let mut output = ipc::PinnedFile::open(&path, false, &[], &roles, true)?;
output.limit_writer_rights(0x0012_019f)?;
ensure!(
output.file.metadata()?.len() == 0,
"CONTROL_REPORT_ALREADY_WRITTEN"
);
output.file.write_all(&bytes)?;
output.file.sync_all()?;
output.check()?;
} else {
let mut output = OpenOptions::new().create_new(true).write(true).open(path)?;
output.write_all(&bytes)?;
output.sync_all()?;
}
Ok(())
}
struct Io {
event: OwnedHandle,
overlapped: OVERLAPPED,
}
impl Io {
fn new() -> Result<Self> {
let event = owned(unsafe { CreateEventW(ptr::null(), 1, 0, ptr::null()) })?;
let mut overlapped: OVERLAPPED = unsafe { zeroed() };
overlapped.hEvent = event.as_raw_handle();
Ok(Self { event, overlapped })
}
fn wait(&mut self, pipe: HANDLE, deadline: Instant) -> std::result::Result<u32, u32> {
let delay = deadline
.saturating_duration_since(Instant::now())
.as_millis()
.min(5000) as u32;
if unsafe { WaitForSingleObject(self.event.as_raw_handle(), delay) } != WAIT_OBJECT_0 {
unsafe {
CancelIoEx(pipe, &self.overlapped);
}
// Pending kernel IO owns our stack/buffer until cancellation
// completes. Never free it or spawn replacement workers.
if unsafe { WaitForSingleObject(self.event.as_raw_handle(), 1000) } != WAIT_OBJECT_0
{
std::process::abort();
}
return Err(ERROR_TIMEOUT);
}
let mut done = 0;
if unsafe { GetOverlappedResult(pipe, &self.overlapped, &mut done, 0) } == 0 {
Err(unsafe { GetLastError() })
} else {
Ok(done)
}
}
}
fn transfer(
pipe: HANDLE,
bytes: &mut [u8],
write: bool,
deadline: Instant,
) -> std::result::Result<(), u32> {
let mut offset = 0;
while offset < bytes.len() {
if Instant::now() >= deadline {
return Err(ERROR_TIMEOUT);
}
let mut io = Io::new().map_err(|_| ERROR_INVALID_HANDLE)?;
let mut done = 0;
let part = &mut bytes[offset..];
let ok = unsafe {
if write {
WriteFile(
pipe,
part.as_ptr(),
part.len() as u32,
&mut done,
&mut io.overlapped,
)
} else {
ReadFile(
pipe,
part.as_mut_ptr(),
part.len() as u32,
&mut done,
&mut io.overlapped,
)
}
};
let count = if ok != 0 {
done
} else {
let error = unsafe { GetLastError() };
if error != ERROR_IO_PENDING {
return Err(error);
}
io.wait(pipe, deadline)?
};
if count == 0 {
return Err(ERROR_BROKEN_PIPE);
}
if count as usize > part.len() {
return Err(ERROR_INVALID_DATA);
}
offset += count as usize;
}
Ok(())
}
fn denied(error: u32) -> bool {
matches!(
error,
ERROR_BROKEN_PIPE | ERROR_NO_DATA | ERROR_PIPE_NOT_CONNECTED
)
}
fn raw(input: &Input) -> Result<serde_json::Value> {
let call = ipc::Call::new(&input.pin, ipc::Operation::Probe {});
let mut bytes = serde_json::to_vec(&call)?;
ensure!(bytes.len() <= 32768, "CONTROL_FIXED_PROBE_FRAME");
let raw = unsafe {
CreateFileW(
wide(ipc::PIPE_NAME).as_ptr(),
ipc::CLIENT_PIPE_RIGHTS,
0,
ptr::null(),
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED | SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION,
ptr::null_mut(),
)
};
if raw == INVALID_HANDLE_VALUE {
let error = unsafe { GetLastError() };
return Ok(
json!({"challenge":call.challenge,"opened":false,"rejected":error==ERROR_ACCESS_DENIED,"stage":"open","win32_error":error,"sdk_self_check_used":false}),
);
}
let pipe = owned(raw)?;
let mut server_pid = 0;
ensure!(
unsafe { GetNamedPipeServerProcessId(pipe.as_raw_handle(), &mut server_pid) } != 0
&& server_pid == input.expected_helper_pid,
"CONTROL_ACTUAL_HELPER_PID"
);
let deadline = Instant::now() + Duration::from_secs(5);
let mut header = (bytes.len() as u32).to_be_bytes();
let result = transfer(pipe.as_raw_handle(), &mut header, true, deadline)
.and_then(|()| transfer(pipe.as_raw_handle(), &mut bytes, true, deadline))
.and_then(|()| transfer(pipe.as_raw_handle(), &mut [0u8; 4], false, deadline));
Ok(match result {
Err(error) => {
json!({"challenge":call.challenge,"opened":true,"actual_server_pid":server_pid,"rejected":denied(error),"stage":"framed_probe","win32_error":error,"sdk_self_check_used":false})
}
Ok(()) => {
json!({"challenge":call.challenge,"opened":true,"actual_server_pid":server_pid,"rejected":false,"stage":"unexpected_response","sdk_self_check_used":false})
}
})
}
fn codes(error: &anyhow::Error) -> Vec<String> {
error
.chain()
.filter_map(|cause| {
let text = cause.to_string();
(text.len() <= 96
&& !text.is_empty()
&& text
.bytes()
.all(|b| b.is_ascii_uppercase() || b.is_ascii_digit() || b == b'_'))
.then_some(text)
})
.take(8)
.collect()
}
fn sdk_prechecks(input: &Input) -> Vec<serde_json::Value> {
let mut out = Vec::new();
let mut check = |stage: &str, run: &mut dyn FnMut() -> Result<()>| match run() {
Ok(()) => out.push(json!({"stage":stage,"ok":true})),
Err(error) => out.push(json!({"stage":stage,"ok":false,"error_codes":codes(&error)})),
};
check("sdk_self_token", &mut || {
ipc::require_self(&input.pin.agent)
});
check("public_root_and_pin_acl", &mut || {
let readers = [
input.pin.agent.service_sid.clone(),
input.pin.helper.service_sid.clone(),
];
let _root = ipc::PinnedFile::open(
std::path::Path::new(r"C:\ProgramData\RustDiscoverySystem"),
true,
&readers,
&[],
false,
)?;
let _pin = ipc::PinnedFile::open(
std::path::Path::new(r"C:\ProgramData\RustDiscoverySystem\agent-pin.json"),
false,
&readers,
&[],
false,
)?;
Ok(())
});
check("helper_scm_query_config_status", &mut || {
let manager = unsafe { OpenSCManagerW(ptr::null(), ptr::null(), SC_MANAGER_CONNECT) };
if manager.is_null() {
anyhow::bail!("CONTROL_SCM_MANAGER_WIN32_{}", unsafe { GetLastError() });
}
let service = unsafe {
OpenServiceW(
manager,
wide(ipc::HELPER_SERVICE).as_ptr(),
SERVICE_QUERY_STATUS | SERVICE_QUERY_CONFIG,
)
};
let error = unsafe { GetLastError() };
unsafe {
CloseServiceHandle(manager);
}
if service.is_null() {
anyhow::bail!("CONTROL_SCM_HELPER_WIN32_{error}");
}
let result = (|| {
let mut size = 0;
unsafe {
QueryServiceConfigW(service, ptr::null_mut(), 0, &mut size);
}
ensure!((1..=32768).contains(&size), "CONTROL_HELPER_CONFIG_SIZE");
let mut data = vec![0usize; (size as usize).div_ceil(size_of::<usize>())];
if unsafe {
QueryServiceConfigW(service, data.as_mut_ptr().cast(), size, &mut size)
} == 0
{
anyhow::bail!("CONTROL_HELPER_CONFIG_WIN32_{}", unsafe { GetLastError() });
}
let mut status: SERVICE_STATUS_PROCESS = unsafe { zeroed() };
if unsafe {
QueryServiceStatusEx(
service,
SC_STATUS_PROCESS_INFO,
(&mut status as *mut SERVICE_STATUS_PROCESS).cast(),
size_of::<SERVICE_STATUS_PROCESS>() as u32,
&mut size,
)
} == 0
{
anyhow::bail!("CONTROL_HELPER_STATUS_WIN32_{}", unsafe { GetLastError() });
}
ensure!(
status.dwCurrentState == SERVICE_RUNNING
&& status.dwProcessId == input.expected_helper_pid,
"CONTROL_HELPER_STATUS_PIN"
);
Ok(())
})();
unsafe {
CloseServiceHandle(service);
}
result
});
check("helper_process_and_token_query", &mut || {
let raw = unsafe {
OpenProcess(
PROCESS_QUERY_LIMITED_INFORMATION | SYNCHRONIZE,
0,
input.expected_helper_pid,
)
};
if raw.is_null() {
anyhow::bail!("CONTROL_HELPER_PROCESS_WIN32_{}", unsafe { GetLastError() });
}
let process = owned(raw)?;
let _born = creation(process.as_raw_handle())?;
let mut raw = ptr::null_mut();
if unsafe { OpenProcessToken(process.as_raw_handle(), TOKEN_QUERY, &mut raw) } == 0 {
anyhow::bail!("CONTROL_HELPER_TOKEN_WIN32_{}", unsafe { GetLastError() });
}
let token = owned(raw)?;
ipc::verify_token(
token.as_raw_handle(),
"S-1-5-18",
&input.pin.helper.service_sid,
)
});
check("helper_image_parent_file_acl_hash", &mut || {
let readers = [
input.pin.agent.service_sid.clone(),
input.pin.helper.service_sid.clone(),
];
let _parent = ipc::PinnedFile::open(
input.pin.helper.binary.parent().unwrap(),
true,
&readers,
&[],
false,
)?;
let mut image =
ipc::PinnedFile::open(&input.pin.helper.binary, false, &readers, &[], false)?;
ensure!(
image.sha256()? == input.pin.helper.binary_sha256,
"CONTROL_HELPER_IMAGE_HASH"
);
Ok(())
});
out
}
fn run(case: uuid::Uuid, mode: &str) -> Result<()> {
let input = read_input(case)?;
let token = token(mode)?;
save(case, &format!("{mode}-token.json"), &token)?;
let report = if mode == "child" {
let call = ipc::Call::new(&input.pin, ipc::Operation::Probe {});
let prechecks = sdk_prechecks(&input);
save(
case,
"child-sdk-prechecks.json",
&json!({"schema_version":1,"read_only":true,"token_exported":false,"checks":prechecks}),
)?;
let began = Instant::now();
match ipc::exchange(&input.pin, &call, Duration::from_secs(5)) {
Ok(_) => {
json!({"challenge":call.challenge,"received_reply":true,"rejected":false,"sdk_self_check_used":true,"stage":"unexpected_sdk_reply"})
}
Err(error) => {
let values = codes(&error);
let elapsed = began.elapsed().as_millis();
json!({"challenge":call.challenge,"received_reply":false,"error_codes":values,"elapsed_ms":elapsed,"sdk_self_check_used":true,"stage":"sdk_diagnostic","rejected":false,"diagnostic_only":true})
}
}
} else {
raw(&input)?
};
save(
case,
&format!("{mode}-result.json"),
&json!({"schema_version":1,"case_id":case,"mode":mode,"token":token,"pipe":report,"source":"native_read_only_peer_control","expected_agent_pid":input.expected_agent_pid,"expected_helper_pid":input.expected_helper_pid,"helper_binary_sha256":input.pin.helper.binary_sha256,"policy_sha256":input.pin.policy_sha256,"own_control_image_sha256":input.control_binary_sha256,"no_jobs":true,"read_only":true,"token_exported":false,"clock_changed":false}),
)
}
fn creation(process: HANDLE) -> Result<u64> {
let (mut c, mut e, mut k, mut u) = unsafe { (zeroed(), zeroed(), zeroed(), zeroed()) };
ensure!(
unsafe { GetProcessTimes(process, &mut c, &mut e, &mut k, &mut u) } != 0,
"CONTROL_AGENT_CREATION"
);
Ok((u64::from(c.dwHighDateTime) << 32) | u64::from(c.dwLowDateTime))
}
fn agent_pid() -> Result<u32> {
let manager = unsafe { OpenSCManagerW(ptr::null(), ptr::null(), SC_MANAGER_CONNECT) };
ensure!(!manager.is_null(), "CONTROL_SCM_MANAGER");
let service = unsafe {
OpenServiceW(
manager,
wide(rmm_agent_windows::SERVICE_NAME).as_ptr(),
SERVICE_QUERY_STATUS,
)
};
unsafe {
CloseServiceHandle(manager);
}
ensure!(!service.is_null(), "CONTROL_SCM_AGENT");
let mut status: SERVICE_STATUS_PROCESS = unsafe { zeroed() };
let mut needed = 0;
let ok = unsafe {
QueryServiceStatusEx(
service,
SC_STATUS_PROCESS_INFO,
(&mut status as *mut SERVICE_STATUS_PROCESS).cast(),
size_of::<SERVICE_STATUS_PROCESS>() as u32,
&mut needed,
)
};
unsafe {
CloseServiceHandle(service);
}
ensure!(
ok != 0 && status.dwCurrentState == SERVICE_RUNNING,
"CONTROL_AGENT_RUNNING"
);
Ok(status.dwProcessId)
}
struct Attributes(Vec<usize>);
impl Attributes {
fn new() -> Result<Self> {
let mut size = 0;
unsafe {
InitializeProcThreadAttributeList(ptr::null_mut(), 1, 0, &mut size);
}
ensure!((1..=65536).contains(&size), "CONTROL_ATTRIBUTE_SIZE");
let mut data = vec![0usize; size.div_ceil(size_of::<usize>())];
ensure!(
unsafe {
InitializeProcThreadAttributeList(data.as_mut_ptr().cast(), 1, 0, &mut size)
} != 0,
"CONTROL_ATTRIBUTE_INIT"
);
Ok(Self(data))
}
fn pointer(&mut self) -> LPPROC_THREAD_ATTRIBUTE_LIST {
self.0.as_mut_ptr().cast()
}
}
impl Drop for Attributes {
fn drop(&mut self) {
unsafe {
DeleteProcThreadAttributeList(self.pointer());
}
}
}
fn spawn_fixed_child(case: uuid::Uuid, input: &Input) -> Result<serde_json::Value> {
ensure!(
agent_pid()? == input.expected_agent_pid,
"CONTROL_CURRENT_AGENT_PID"
);
let process = owned(unsafe {
OpenProcess(
PROCESS_QUERY_LIMITED_INFORMATION | SYNCHRONIZE,
0,
input.expected_agent_pid,
)
})?;
ensure!(
creation(process.as_raw_handle())? == input.expected_agent_creation,
"CONTROL_ORIGINAL_AGENT_BIRTH"
);
let mut image = vec![0u16; 32768];
let mut length = image.len() as u32;
ensure!(
unsafe {
QueryFullProcessImageNameW(
process.as_raw_handle(),
0,
image.as_mut_ptr(),
&mut length,
)
} != 0,
"CONTROL_ORIGINAL_AGENT_IMAGE_QUERY"
);
let actual_image = String::from_utf16(&image[..length as usize])?;
ensure!(
std::path::Path::new(&actual_image) == input.pin.agent.binary,
"CONTROL_ORIGINAL_AGENT_IMAGE"
);
let mut actual = ipc::PinnedFile::open(
&input.pin.agent.binary,
false,
&[
input.pin.agent.service_sid.clone(),
input.pin.helper.service_sid.clone(),
],
&[],
false,
)?;
ensure!(
actual.sha256()? == input.pin.agent.binary_sha256,
"CONTROL_ORIGINAL_AGENT_HASH"
);
let mut raw = ptr::null_mut();
ensure!(
unsafe {
OpenProcessToken(
process.as_raw_handle(),
TOKEN_QUERY | TOKEN_DUPLICATE,
&mut raw,
)
} != 0,
"CONTROL_AGENT_QUERY_DUPLICATE_ONLY"
);
let original = owned(raw)?;
ipc::verify_token(
original.as_raw_handle(),
"S-1-5-19",
&input.pin.agent.service_sid,
)?;
let mut raw = ptr::null_mut();
ensure!(
unsafe {
DuplicateTokenEx(
original.as_raw_handle(),
TOKEN_QUERY | TOKEN_DUPLICATE | TOKEN_ASSIGN_PRIMARY,
ptr::null(),
SecurityImpersonation,
TokenPrimary,
&mut raw,
)
} != 0,
"CONTROL_DUPLICATE_PRIMARY"
);
let duplicate = owned(raw)?;
let job = owned(unsafe { CreateJobObjectW(ptr::null(), ptr::null()) })?;
let mut limits: JOBOBJECT_EXTENDED_LIMIT_INFORMATION = unsafe { zeroed() };
limits.BasicLimitInformation.LimitFlags =
JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE | JOB_OBJECT_LIMIT_ACTIVE_PROCESS;
limits.BasicLimitInformation.ActiveProcessLimit = 1;
ensure!(
unsafe {
SetInformationJobObject(
job.as_raw_handle(),
JobObjectExtendedLimitInformation,
(&limits as *const JOBOBJECT_EXTENDED_LIMIT_INFORMATION).cast(),
size_of::<JOBOBJECT_EXTENDED_LIMIT_INFORMATION>() as u32,
)
} != 0,
"CONTROL_CHILD_JOB_LIMIT"
);
let exe = std::env::current_exe()?;
let mut command = wide(&format!(
"\"{}\" --agent-child {}",
exe.to_string_lossy(),
case
));
let exe = wide(&exe.to_string_lossy());
let directory = wide(&PathBuf::from(ROOT).join(case.to_string()).to_string_lossy());
// The handle array outlives its attribute list. JOB_LIST assigns the
// child atomically, eliminating a suspended unowned-process gap.
// Microsoft UpdateProcThreadAttribute: JOB_LIST (Windows10+).
let jobs = [job.as_raw_handle()];
let mut attributes = Attributes::new()?;
ensure!(
unsafe {
UpdateProcThreadAttribute(
attributes.pointer(),
0,
PROC_THREAD_ATTRIBUTE_JOB_LIST as usize,
jobs.as_ptr().cast(),
size_of_val(&jobs),
ptr::null_mut(),
ptr::null(),
)
} != 0,
"CONTROL_ATOMIC_JOB_ATTRIBUTE"
);
let mut startup: STARTUPINFOEXW = unsafe { zeroed() };
startup.StartupInfo.cb = size_of::<STARTUPINFOEXW>() as u32;
startup.lpAttributeList = attributes.pointer();
let mut child: PROCESS_INFORMATION = unsafe { zeroed() };
// Fixed image/arguments, no inherited handles/shell/profile import.
// CreateProcessAsUser may enable its required privileges only for this
// call on our own SYSTEM token; no explicit adjustment or DACL grant.
save(
case,
"child-create-intent.json",
&json!({"fixed_image_sha256":input.control_binary_sha256,"fixed_argument":"--agent-child","case_id":case,"atomic_job_list":true,"no_jobs":true,"token_exported":false}),
)?;
let ok = unsafe {
CreateProcessAsUserW(
duplicate.as_raw_handle(),
exe.as_ptr(),
command.as_mut_ptr(),
ptr::null(),
ptr::null(),
0,
CREATE_SUSPENDED | CREATE_NO_WINDOW | EXTENDED_STARTUPINFO_PRESENT,
ptr::null(),
directory.as_ptr(),
&startup.StartupInfo,
&mut child,
)
};
let error = if ok == 0 {
unsafe { GetLastError() }
} else {
0
};
ensure!(ok != 0, "CONTROL_FIXED_CHILD_CREATE_WIN32_{error}");
let child_process = owned(child.hProcess)?;
let child_thread = owned(child.hThread)?;
let mut assigned = 0;
if unsafe {
IsProcessInJob(
child_process.as_raw_handle(),
job.as_raw_handle(),
&mut assigned,
)
} == 0
|| assigned == 0
{
unsafe {
TerminateProcess(child_process.as_raw_handle(), 125);
WaitForSingleObject(child_process.as_raw_handle(), 5000);
}
anyhow::bail!("CONTROL_CHILD_ATOMIC_JOB_NOT_CONFIRMED");
}
save(
case,
"child-started.json",
&json!({"child_pid":child.dwProcessId,"wrong_agent_pid":child.dwProcessId!=input.expected_agent_pid,"fixed_child_image":true,"agent_primary_token_duplicated":true,"atomic_job_membership_confirmed":true,"token_exported":false}),
)?;
ensure!(
unsafe { ResumeThread(child_thread.as_raw_handle()) } != u32::MAX,
"CONTROL_CHILD_RESUME"
);
if unsafe { WaitForSingleObject(child_process.as_raw_handle(), 20000) } != WAIT_OBJECT_0 {
unsafe {
TerminateJobObject(job.as_raw_handle(), 125);
}
ensure!(
unsafe { WaitForSingleObject(child_process.as_raw_handle(), 5000) }
== WAIT_OBJECT_0,
"CONTROL_CHILD_CLEANUP"
);
anyhow::bail!("CONTROL_CHILD_TIMEOUT_NO_RETRY");
}
let mut exit = 0;
ensure!(
unsafe { GetExitCodeProcess(child_process.as_raw_handle(), &mut exit) } != 0,
"CONTROL_CHILD_EXIT"
);
ensure!(
agent_pid()? == input.expected_agent_pid
&& creation(process.as_raw_handle())? == input.expected_agent_creation
&& unsafe { WaitForSingleObject(process.as_raw_handle(), 0) } == WAIT_TIMEOUT,
"CONTROL_AGENT_PRESERVED"
);
Ok(
json!({"child_pid":child.dwProcessId,"exit_code":exit,"child_exited":true,"agent_preserved":true,"token_exported":false,"existing_process_or_token_acl_changed":false,"diagnostic_only":true}),
)
}
fn parent(case: uuid::Uuid) -> Result<()> {
let identity = token("parent")?;
save(case, "parent-token.json", &identity)?;
let input = read_input(case)?;
let result = match spawn_fixed_child(case, &input) {
Ok(value) => value,
Err(error) => {
json!({"error_codes":codes(&error),"completed":false,"diagnostic_only":true,"token_exported":false})
}
};
save(
case,
"parent-result.json",
&json!({"schema_version":1,"case_id":case,"source":"own_system_fixed_child_controller","result":result,"no_jobs":true,"read_only":true,"token_exported":false}),
)
}
fn direct_peer_proof(case: uuid::Uuid) -> Result<()> {
let identity = token("parent")?;
save(case, "parent-token.json", &identity)?;
let input = read_input(case)?;
let began = Instant::now();
let proof = (|| -> Result<serde_json::Value> {
let mut peer = ipc::PeerProof::for_service(&input.pin.agent, input.expected_agent_pid)?;
ensure!(
peer.identity().creation_ticks == input.expected_agent_creation,
"CONTROL_ORIGINAL_AGENT_BIRTH"
);
ensure!(!peer.exited()?, "CONTROL_ORIGINAL_AGENT_EXITED");
peer.check()?;
Ok(serde_json::to_value(peer.identity())?)
})();
let result = match proof {
Ok(actual) => json!({"direct_agent_peer_proof":true,"verified":true,"identity":actual}),
Err(error) => {
json!({"direct_agent_peer_proof":true,"verified":false,"error_codes":codes(&error)})
}
};
save(
case,
"parent-result.json",
&json!({"schema_version":1,"case_id":case,"source":"own_system_direct_production_agent_peer_proof","result":result,"elapsed_ms":began.elapsed().as_millis(),"expected_agent_pid":input.expected_agent_pid,"expected_agent_creation":input.expected_agent_creation,"no_jobs":true,"read_only":true,"pipe_used":false,"token_duplicated":false,"token_exported":false,"service_or_process_acl_changed":false}),
)
}
fn status(state: u32, error: u32) {
let handle = STATUS.load(Ordering::SeqCst) as SERVICE_STATUS_HANDLE;
if handle.is_null() {
return;
}
let value = SERVICE_STATUS {
dwServiceType: SERVICE_WIN32_OWN_PROCESS,
dwCurrentState: state,
dwControlsAccepted: 0,
dwWin32ExitCode: error,
dwServiceSpecificExitCode: 0,
dwCheckPoint: 0,
dwWaitHint: 10000,
};
unsafe {
SetServiceStatus(handle, &value);
}
}
unsafe extern "system" fn control(
_: u32,
_: u32,
_: *mut std::ffi::c_void,
_: *mut std::ffi::c_void,
) -> u32 {
0
}
unsafe extern "system" fn service_main(_: u32, _: *mut *mut u16) {
let handle = unsafe {
RegisterServiceCtrlHandlerExW(
wide(if *IS_PARENT.get().unwrap_or(&false) {
PARENT_NAME
} else {
NAME
})
.as_ptr(),
Some(control),
ptr::null_mut(),
)
};
if handle.is_null() {
return;
}
STATUS.store(handle as usize, Ordering::SeqCst);
status(SERVICE_RUNNING, 0);
let result = if *IS_PARENT.get().unwrap_or(&false) {
if *DIRECT_PEER_PROOF.get().unwrap_or(&false) {
direct_peer_proof(*CASE.get().unwrap())
} else {
parent(*CASE.get().unwrap())
}
} else {
run(*CASE.get().unwrap(), "service")
};
std::thread::sleep(Duration::from_secs(2));
status(SERVICE_STOPPED, if result.is_ok() { 0 } else { 1066 });
}
pub fn main() -> Result<()> {
let args: Vec<_> = std::env::args().skip(1).collect();
ensure!(
args.len() == 2
&& matches!(
args[0].as_str(),
"--admin" | "--service" | "--agent-child" | "--parent" | "--peer-proof"
),
"CONTROL_FIXED_MODE"
);
let case = uuid::Uuid::parse_str(&args[1])?;
ensure!(
case.get_version_num() == 4 && case.to_string() == args[1],
"CONTROL_CANONICAL_UUID"
);
if args[0] == "--admin" {
return run(case, "admin");
}
if args[0] == "--agent-child" {
return run(case, "child");
}
IS_PARENT
.set(matches!(args[0].as_str(), "--parent" | "--peer-proof"))
.map_err(|_| anyhow::anyhow!("CONTROL_MODE_ALREADY_SET"))?;
DIRECT_PEER_PROOF
.set(args[0] == "--peer-proof")
.map_err(|_| anyhow::anyhow!("CONTROL_MODE_ALREADY_SET"))?;
CASE.set(case)
.map_err(|_| anyhow::anyhow!("CONTROL_CASE_ALREADY_SET"))?;
let mut name = wide(if matches!(args[0].as_str(), "--parent" | "--peer-proof") {
PARENT_NAME
} else {
NAME
});
let table = [
SERVICE_TABLE_ENTRYW {
lpServiceName: name.as_mut_ptr(),
lpServiceProc: Some(service_main),
},
SERVICE_TABLE_ENTRYW {
lpServiceName: ptr::null_mut(),
lpServiceProc: None,
},
];
ensure!(
unsafe { StartServiceCtrlDispatcherW(table.as_ptr()) } != 0,
"CONTROL_SERVICE_DISPATCH"
);
Ok(())
}
}
#[cfg(all(windows, feature = "system-helper"))]
fn main() -> anyhow::Result<()> {
platform::main()
}
#[cfg(not(all(windows, feature = "system-helper")))]
fn main() -> anyhow::Result<()> {
anyhow::bail!("Windows system-helper build required for native peer controls")
}