1021 lines
40 KiB
Rust
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")
|
|
}
|