//! 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 = OnceLock::new(); static IS_PARENT: OnceLock = OnceLock::new(); static DIRECT_PEER_PROOF: OnceLock = OnceLock::new(); static STATUS: AtomicUsize = AtomicUsize::new(0); fn wide(s: &str) -> Vec { s.encode_utf16().chain(Some(0)).collect() } fn owned(handle: HANDLE) -> Result { ensure!( !handle.is_null() && handle != INVALID_HANDLE_VALUE, "CONTROL_HANDLE" ); Ok(unsafe { OwnedHandle::from_raw_handle(handle) }) } fn sid_text(sid: PSID) -> Result { 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> { 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::())]; ensure!( unsafe { GetTokenInformation(token, class, bytes.as_mut_ptr().cast(), size, &mut size) } != 0, "CONTROL_TOKEN_QUERY" ); Ok(bytes) } fn token(mode: &str) -> Result { 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::() }; 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::(); let groups = unsafe { &*groups.as_ptr().cast::() }; ensure!( groups.GroupCount <= 1024 && std::mem::offset_of!(TOKEN_GROUPS, Groups) + groups.GroupCount as usize * size_of::() <= 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 { 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 { 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 = 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 { 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 { 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 { 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 { 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 { 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::())]; 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::() 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 { 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 { 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::() as u32, &mut needed, ) }; unsafe { CloseServiceHandle(service); } ensure!( ok != 0 && status.dwCurrentState == SERVICE_RUNNING, "CONTROL_AGENT_RUNNING" ); Ok(status.dwProcessId) } struct Attributes(Vec); impl Attributes { fn new() -> Result { 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::())]; 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 { 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::() 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::() 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 { 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") }