Verify Windows ACL regression fix and native denied administrator probe
Rust development slice / linux (push) Failing after 7s
Rust development slice / linux (push) Failing after 7s
This commit is contained in:
@@ -0,0 +1,976 @@
|
||||
//! Negative, read-only raw Probe clients. Never SDK self-refusal as server proof.
|
||||
//! The permanent services, their tokens/configuration and private state stay intact.
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
mod platform {
|
||||
use anyhow::{Result, ensure};
|
||||
use rmm_agent_windows::helper_ipc as ipc;
|
||||
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 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(&directory, true, &roles, &[], false)?;
|
||||
let path = directory.join(name);
|
||||
if folder != "controller" {
|
||||
let mut output = ipc::PinnedFile::open(&path, false, &[], &roles, true)?;
|
||||
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 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) {
|
||||
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"
|
||||
),
|
||||
"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(args[0] == "--parent")
|
||||
.map_err(|_| anyhow::anyhow!("CONTROL_MODE_ALREADY_SET"))?;
|
||||
CASE.set(case)
|
||||
.map_err(|_| anyhow::anyhow!("CONTROL_CASE_ALREADY_SET"))?;
|
||||
let mut name = wide(if args[0] == "--parent" {
|
||||
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")
|
||||
}
|
||||
@@ -0,0 +1,170 @@
|
||||
//! UNWIRED diagnostic candidate, never a job-capable BootSource.
|
||||
//!
|
||||
//! Microsoft's public NtQuerySystemInformation contract explicitly permits API
|
||||
//! changes and recommends dynamic lookup. It does NOT specify class90 or the
|
||||
//! BootIdentifier layout used below. The fixed32-byte/GUID-prefix hypothesis
|
||||
//! therefore remains unqualified, even when samples agree on Windows11/26300.
|
||||
//! No CIM timestamp, wall clock, uptime subtraction or registry counter is used.
|
||||
//! https://learn.microsoft.com/en-us/windows/win32/api/winternl/nf-winternl-ntquerysysteminformation
|
||||
//! https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/nf-wdm-rtlgetversion
|
||||
//! https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-getfirmwaretype
|
||||
use serde::Serialize;
|
||||
use uuid::Uuid;
|
||||
|
||||
pub const CANDIDATE_BUILD: u32 = 26300;
|
||||
#[derive(Clone, Debug, Serialize)]
|
||||
pub struct Observation {
|
||||
pub source: &'static str,
|
||||
pub quality: &'static str,
|
||||
pub code: &'static str,
|
||||
pub windows_build: Option<u32>,
|
||||
pub nt_status: Option<i32>,
|
||||
pub returned_bytes: Option<u32>,
|
||||
pub candidate_identifier: Option<Uuid>,
|
||||
pub firmware_type: Option<u32>,
|
||||
pub job_binding_qualified: bool,
|
||||
pub public_class_90_abi_documented: bool,
|
||||
}
|
||||
impl Observation {
|
||||
fn unsupported(code: &'static str) -> Self {
|
||||
Self {
|
||||
source: "ntdll/NtQuerySystemInformation/class90/experimental32",
|
||||
quality: "unsupported",
|
||||
code,
|
||||
windows_build: None,
|
||||
nt_status: None,
|
||||
returned_bytes: None,
|
||||
candidate_identifier: None,
|
||||
firmware_type: None,
|
||||
job_binding_qualified: false,
|
||||
public_class_90_abi_documented: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
#[cfg(any(windows, test))]
|
||||
fn decode(status: i32, returned: u32, bytes: [u8; 32], firmware: u32) -> Option<Uuid> {
|
||||
if status != 0
|
||||
|| returned != 32
|
||||
|| !matches!(firmware, 1 | 2)
|
||||
|| u32::from_le_bytes(bytes[16..20].try_into().ok()?) != firmware
|
||||
{
|
||||
return None;
|
||||
}
|
||||
let id = Uuid::from_bytes_le(bytes[..16].try_into().ok()?);
|
||||
(!id.is_nil()).then_some(id)
|
||||
}
|
||||
/// Actual bounded native read, but no qualification/capability follows from it.
|
||||
pub fn observe_candidate() -> Observation {
|
||||
#[cfg(windows)]
|
||||
{
|
||||
windows::observe()
|
||||
}
|
||||
#[cfg(not(windows))]
|
||||
{
|
||||
Observation::unsupported("BOOT_CANDIDATE_WINDOWS_ONLY")
|
||||
}
|
||||
}
|
||||
#[cfg(windows)]
|
||||
mod windows {
|
||||
use super::*;
|
||||
use std::mem::{size_of, zeroed};
|
||||
use windows_sys::Win32::System::{
|
||||
LibraryLoader::{GetModuleHandleW, GetProcAddress},
|
||||
SystemInformation::{
|
||||
GetFirmwareType, GetNativeSystemInfo, OSVERSIONINFOEXW, PROCESSOR_ARCHITECTURE_AMD64,
|
||||
SYSTEM_INFO,
|
||||
},
|
||||
};
|
||||
type RtlVersion = unsafe extern "system" fn(*mut OSVERSIONINFOEXW) -> i32;
|
||||
type Query = unsafe extern "system" fn(i32, *mut core::ffi::c_void, u32, *mut u32) -> i32;
|
||||
pub(super) fn observe() -> Observation {
|
||||
let mut out = Observation::unsupported("BOOT_CANDIDATE_API_UNAVAILABLE");
|
||||
// ntdll is already loaded by the OS. No path/search-based DLL loading.
|
||||
let name: Vec<u16> = "ntdll.dll".encode_utf16().chain(Some(0)).collect();
|
||||
let module = unsafe { GetModuleHandleW(name.as_ptr()) };
|
||||
if module.is_null() {
|
||||
return out;
|
||||
}
|
||||
let Some(version) = (unsafe { GetProcAddress(module, c"RtlGetVersion".as_ptr().cast()) })
|
||||
else {
|
||||
return out;
|
||||
};
|
||||
let Some(query) =
|
||||
(unsafe { GetProcAddress(module, c"NtQuerySystemInformation".as_ptr().cast()) })
|
||||
else {
|
||||
return out;
|
||||
};
|
||||
// Public entrypoint calling conventions; class90's returned layout is
|
||||
// explicitly experimental and checked as bytes, not a dereferenced ABI.
|
||||
let version: RtlVersion = unsafe { std::mem::transmute(version) };
|
||||
let query: Query = unsafe { std::mem::transmute(query) };
|
||||
let mut os: OSVERSIONINFOEXW = unsafe { zeroed() };
|
||||
os.dwOSVersionInfoSize = size_of::<OSVERSIONINFOEXW>() as u32;
|
||||
if unsafe { version(&mut os) } != 0 {
|
||||
return out;
|
||||
}
|
||||
out.windows_build = Some(os.dwBuildNumber);
|
||||
let mut system: SYSTEM_INFO = unsafe { zeroed() };
|
||||
unsafe { GetNativeSystemInfo(&mut system) };
|
||||
if os.dwMajorVersion != 10
|
||||
|| os.dwMinorVersion != 0
|
||||
|| os.dwBuildNumber != CANDIDATE_BUILD
|
||||
|| os.wProductType != 1
|
||||
|| unsafe { system.Anonymous.Anonymous.wProcessorArchitecture }
|
||||
!= PROCESSOR_ARCHITECTURE_AMD64
|
||||
{
|
||||
out.code = "BOOT_CANDIDATE_BUILD_OR_ARCHITECTURE_UNSUPPORTED";
|
||||
return out;
|
||||
}
|
||||
let mut firmware = 0;
|
||||
if unsafe { GetFirmwareType(&mut firmware) } == 0 {
|
||||
out.code = "BOOT_CANDIDATE_FIRMWARE_CROSSCHECK_UNAVAILABLE";
|
||||
return out;
|
||||
}
|
||||
// Fixed aligned32-byte capacity; no remote length/allocation or fallback.
|
||||
let mut data = [0u64; 4];
|
||||
let mut returned = 0;
|
||||
let status = unsafe { query(90, data.as_mut_ptr().cast(), 32, &mut returned) };
|
||||
out.nt_status = Some(status);
|
||||
out.returned_bytes = Some(returned);
|
||||
out.firmware_type = Some(firmware as u32);
|
||||
if status == 0xC0000022u32 as i32 {
|
||||
out.quality = "permission_denied";
|
||||
out.code = "BOOT_CANDIDATE_ACCESS_DENIED";
|
||||
return out;
|
||||
}
|
||||
let mut bytes = [0u8; 32];
|
||||
for (i, value) in data.iter().enumerate() {
|
||||
bytes[i * 8..i * 8 + 8].copy_from_slice(&value.to_ne_bytes());
|
||||
}
|
||||
if let Some(id) = decode(status, returned, bytes, firmware as u32) {
|
||||
out.candidate_identifier = Some(id);
|
||||
out.quality = "candidate_unqualified";
|
||||
out.code = "BOOT_CANDIDATE_REQUIRES_ABI_AND_NATIVE_LIFECYCLE_QUALIFICATION";
|
||||
} else {
|
||||
out.code = "BOOT_CANDIDATE_STATUS_LENGTH_OR_LAYOUT_UNSUPPORTED";
|
||||
}
|
||||
// Neither raw BootFlags nor unrelated native memory is exposed.
|
||||
out
|
||||
}
|
||||
}
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn candidate_layout_and_status_never_imply_job_qualification() {
|
||||
let id = Uuid::parse_str("12345678-9abc-4def-8123-456789abcdef").unwrap();
|
||||
let mut bytes = [0u8; 32];
|
||||
bytes[..16].copy_from_slice(&id.to_bytes_le());
|
||||
bytes[16..20].copy_from_slice(&2u32.to_le_bytes());
|
||||
assert_eq!(decode(0, 32, bytes, 2), Some(id));
|
||||
assert_eq!(decode(-1, 32, bytes, 2), None);
|
||||
assert_eq!(decode(0, 31, bytes, 2), None);
|
||||
assert_eq!(decode(0, 32, bytes, 1), None);
|
||||
bytes[..16].fill(0);
|
||||
assert_eq!(decode(0, 32, bytes, 2), None);
|
||||
let out = Observation::unsupported("TEST");
|
||||
assert!(!out.job_binding_qualified);
|
||||
assert!(!out.public_class_90_abi_documented);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
#requires -Version 5.1
|
||||
<# Standalone diagnostic bootstrap ONLY. Root runs explicitly after qualification.
|
||||
Prepare stages one hash-pinned binary. Start creates one temporary own Manual
|
||||
LocalService service, not an enrolled RMM client/job. Lost replies permit only
|
||||
Readback. Cleanup removes ONLY that exact stopped probe service. No installed
|
||||
product, permanent agent/helper, time service, privilege, boot counter or trust
|
||||
configuration is modified. SCM registration is confined to this temporary probe.
|
||||
Two independent fresh cases can show process independence; matching samples do
|
||||
NOT qualify a reboot/clock-jump invariant or enable a signed-job boot capability.
|
||||
#>
|
||||
[CmdletBinding()]
|
||||
param([Parameter(Mandatory=$true)][ValidateSet('Prepare','Start','Readback','Cleanup')][string]$Action,
|
||||
[Parameter(Mandatory=$true)][ValidatePattern('^[a-f0-9]{64}$')][string]$BinarySha256,
|
||||
[Parameter(Mandatory=$true)][ValidatePattern('^[a-f0-9]{64}$')][string]$ExpectedSourceSha256,
|
||||
[Guid]$CaseId=[Guid]::Empty)
|
||||
Set-StrictMode -Version Latest
|
||||
$ErrorActionPreference='Stop'
|
||||
$root='C:\ProgramData\RustDiscoveryBootProbe';$name='RmmWindowsBootIdentityProbe'
|
||||
$binary=Join-Path (Join-Path $root $BinarySha256) 'WindowsBootProbe.exe'
|
||||
$sys='S-1-5-18';$admin='S-1-5-32-544';$local='S-1-5-19'
|
||||
# MS-LSAT service SID is independent of whether this temporary service still
|
||||
# exists. This keeps post-cleanup/lost-reply readback genuinely read-only.
|
||||
$algorithm=[Security.Cryptography.SHA1]::Create()
|
||||
try {$digest=$algorithm.ComputeHash([Text.Encoding]::Unicode.GetBytes($name.ToUpperInvariant()))} finally {$algorithm.Dispose()}
|
||||
$serviceSid='S-1-5-80-'+((0..4|ForEach-Object {[BitConverter]::ToUInt32($digest,$_ * 4)})-join '-')
|
||||
function Require([bool]$v,[string]$code){if(!$v){throw $code}}
|
||||
function Hash([string]$p){return (Get-FileHash -LiteralPath $p -Algorithm SHA256).Hash.ToLowerInvariant()}
|
||||
function No-Reparse([string]$p){$i=Get-Item -LiteralPath $p -Force;while($null -ne $i){Require (($i.Attributes-band[IO.FileAttributes]::ReparsePoint)-eq 0) 'BOOT_PROBE_REPARSE';if($i-is[IO.FileInfo]){$i=$i.Directory}else{$i=$i.Parent}}}
|
||||
function Protect([string]$p,[string]$writer){$a=New-Object Security.AccessControl.DirectorySecurity;$a.SetAccessRuleProtection($true,$false);$a.SetOwner((New-Object Security.Principal.SecurityIdentifier($admin)));foreach($sid in @($sys,$admin,$local,$writer)|Where-Object {$_}|Select-Object -Unique){$rights=if($sid-in@($sys,$admin,$writer)){'FullControl'}else{'ReadAndExecute'};$a.AddAccessRule((New-Object Security.AccessControl.FileSystemAccessRule((New-Object Security.Principal.SecurityIdentifier($sid)),$rights,'ContainerInherit,ObjectInherit','None','Allow')))};Set-Acl -LiteralPath $p -AclObject $a}
|
||||
function Check([string]$p,[string[]]$writers){No-Reparse $p;$a=Get-Acl -LiteralPath $p;Require ($a.GetOwner([Security.Principal.SecurityIdentifier]).Value-in@($sys,$admin)-or(!(Get-Item -LiteralPath $p).PSIsContainer-and$writers.Count-gt 0-and$a.GetOwner([Security.Principal.SecurityIdentifier]).Value-eq$local)) 'BOOT_PROBE_OWNER';$r=@($a.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier]));Require ($r.Count-gt 0) 'BOOT_PROBE_DACL';foreach($ace in $r){$sid=$ace.IdentityReference.Value;Require ($ace.AccessControlType-eq'Allow') 'BOOT_PROBE_ACE';if($sid-notin@($sys,$admin)+$writers){Require ($sid-eq$local-and([long]$ace.FileSystemRights-band 0x500d0156)-eq 0) 'BOOT_PROBE_FOREIGN_WRITE'}}}
|
||||
function Write-New([string]$p,$v){$f=[IO.File]::Open($p,[IO.FileMode]::CreateNew,[IO.FileAccess]::Write,[IO.FileShare]::Read);try{$b=[Text.Encoding]::UTF8.GetBytes(($v|ConvertTo-Json -Depth 12 -Compress));$f.Write($b,0,$b.Length);$f.Flush($true)}finally{$f.Dispose()}}
|
||||
Require ((Hash $PSCommandPath)-ceq$ExpectedSourceSha256) 'BOOT_PROBE_EXACT_SOURCE'
|
||||
if($Action-eq'Prepare'){
|
||||
if(!(Test-Path -LiteralPath $root)){[void](New-Item -ItemType Directory -Path $root);Protect $root ''};Check $root @()
|
||||
$dir=Split-Path $binary -Parent;if(!(Test-Path -LiteralPath $dir)){[void](New-Item -ItemType Directory -Path $dir);Protect $dir ''};Check $dir @()
|
||||
$present=Test-Path -LiteralPath $binary;if($present){Check $binary @();Require ((Hash $binary)-ceq$BinarySha256) 'BOOT_PROBE_STAGED_HASH'}
|
||||
[ordered]@{prepared=$true;binary_present=$present;upload_path=$binary;no_service_change=$true}|ConvertTo-Json -Compress;exit 0
|
||||
}
|
||||
Require ($CaseId-ne[Guid]::Empty) 'BOOT_PROBE_CASE_REQUIRED'
|
||||
Check $root @();Check $binary @();Require ((Hash $binary)-ceq$BinarySha256) 'BOOT_PROBE_BINARY_HASH'
|
||||
$case=Join-Path $root $CaseId.ToString();$command='"'+$binary+'" --service '+$CaseId.ToString()
|
||||
if($Action-eq'Start'){
|
||||
Require (!(Test-Path -LiteralPath $case)-and$null-eq(Get-Service -Name $name -ErrorAction SilentlyContinue)) 'BOOT_PROBE_FRESH_CASE_AND_SERVICE'
|
||||
[void](New-Item -ItemType Directory -Path $case);Protect $case ''
|
||||
Write-New (Join-Path $case 'intent.json') @{case_id=$CaseId.ToString();binary_sha256=$BinarySha256;source_sha256=$ExpectedSourceSha256;command=$command;service=$name;read_only=$true}
|
||||
Write-New (Join-Path $case 'create-attempt.json') @{create_once=$true}
|
||||
New-Service -Name $name -BinaryPathName $command -StartupType Manual -Credential (New-Object Management.Automation.PSCredential('NT AUTHORITY\LocalService',(New-Object Security.SecureString)))|Out-Null
|
||||
$sc=Join-Path ([Environment]::GetFolderPath([Environment+SpecialFolder]::System)) 'sc.exe'
|
||||
& $sc sidtype $name unrestricted|Out-Null;Require ($LASTEXITCODE-eq 0) 'BOOT_PROBE_SERVICE_SID'
|
||||
$sid=(New-Object Security.Principal.NTAccount('NT SERVICE',$name)).Translate([Security.Principal.SecurityIdentifier]).Value
|
||||
Require ($sid-ceq$serviceSid) 'BOOT_PROBE_ACTUAL_SERVICE_SID'
|
||||
Protect $case $sid
|
||||
Write-New (Join-Path $case 'start-attempt.json') @{start_once=$true;no_jobs=$true}
|
||||
Start-Service -Name $name
|
||||
}
|
||||
Check $case @($serviceSid)
|
||||
$intent=Get-Content -LiteralPath (Join-Path $case 'intent.json') -Raw|ConvertFrom-Json
|
||||
Require ($intent.case_id-ceq$CaseId.ToString()-and$intent.binary_sha256-ceq$BinarySha256-and$intent.source_sha256-ceq$ExpectedSourceSha256-and$intent.command-ceq$command-and$intent.service-ceq$name) 'BOOT_PROBE_RETAINED_INTENT'
|
||||
$service=Get-CimInstance Win32_Service -Filter "Name='RmmWindowsBootIdentityProbe'" -OperationTimeoutSec 10
|
||||
if($null-ne$service){Require ($service.PathName-ceq$command-and$service.StartName-in@('NT AUTHORITY\LocalService','NT AUTHORITY\Local Service')-and$service.StartMode-ceq'Manual') 'BOOT_PROBE_SCM_CONFIG'}
|
||||
$limit=[Diagnostics.Stopwatch]::StartNew()
|
||||
while($null-ne$service-and$service.State-ne'Stopped'-and$limit.Elapsed.TotalSeconds-lt 15){Start-Sleep -Milliseconds 250;$service=Get-CimInstance Win32_Service -Filter "Name='RmmWindowsBootIdentityProbe'" -OperationTimeoutSec 10}
|
||||
Require ($null-eq$service-or$service.State-eq'Stopped') 'BOOT_PROBE_RETAIN_ACTIVE_READBACK_ONLY'
|
||||
$result=$null;$path=Join-Path $case 'result.json'
|
||||
if(Test-Path -LiteralPath $path){Check $path @($serviceSid);Require ((Get-Item -LiteralPath $path).Length-le 8192) 'BOOT_PROBE_REPORT_SIZE';$result=Get-Content -LiteralPath $path -Raw|ConvertFrom-Json;Require ($result.case_id-ceq$CaseId.ToString()-and$result.service_name-ceq$name-and$result.user_sid-ceq$local-and$result.administrator_member-eq$false-and$result.scm_callback_entered-eq$true-and$result.read_only-eq$true-and$result.job_binding_qualified-eq$false) 'BOOT_PROBE_ACTUAL_LOCAL_SERVICE'}
|
||||
if($Action-eq'Cleanup'){
|
||||
Require ($null-ne$service-and$service.State-eq'Stopped') 'BOOT_PROBE_ONLY_OWN_STOPPED_SERVICE'
|
||||
Write-New (Join-Path $case 'cleanup-attempt.json') @{service=$name;command=$command;remove_once=$true}
|
||||
$sc=Join-Path ([Environment]::GetFolderPath([Environment+SpecialFolder]::System)) 'sc.exe'; & $sc delete $name|Out-Null;Require ($LASTEXITCODE-eq 0) 'BOOT_PROBE_OWN_CLEANUP'
|
||||
}
|
||||
[ordered]@{case_id=$CaseId.ToString();native_report=$result;service_stopped=($null-eq$service-or$service.State-eq'Stopped');service_exit_code=if($null-ne$service){$service.ExitCode}else{$null};job_binding_qualified=$false;no_jobs=$true;no_clock_change=$true;no_permanent_agent_change=$true}|ConvertTo-Json -Depth 12 -Compress
|
||||
@@ -0,0 +1,195 @@
|
||||
//! Standalone SCM diagnostic. Never enrolls, starts a job or changes the clock.
|
||||
#[path = "../../crates/agent-windows/src/native_boot.rs"]
|
||||
mod native_boot;
|
||||
#[cfg(windows)]
|
||||
mod service {
|
||||
use anyhow::{Result, ensure};
|
||||
use std::{
|
||||
io::Write,
|
||||
mem::size_of,
|
||||
path::PathBuf,
|
||||
ptr,
|
||||
sync::{
|
||||
OnceLock,
|
||||
atomic::{AtomicUsize, Ordering},
|
||||
},
|
||||
time::Duration,
|
||||
};
|
||||
use windows_sys::Win32::{
|
||||
Foundation::*,
|
||||
Security::*,
|
||||
System::{Services::*, Threading::*},
|
||||
};
|
||||
const NAME: &str = "RmmWindowsBootIdentityProbe";
|
||||
static CASE: OnceLock<uuid::Uuid> = OnceLock::new();
|
||||
static STATUS: AtomicUsize = AtomicUsize::new(0);
|
||||
fn wide(s: &str) -> Vec<u16> {
|
||||
s.encode_utf16().chain(Some(0)).collect()
|
||||
}
|
||||
fn token() -> Result<()> {
|
||||
let mut thread = ptr::null_mut();
|
||||
if unsafe { OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, 1, &mut thread) } != 0 {
|
||||
unsafe { CloseHandle(thread) };
|
||||
anyhow::bail!("BOOT_PROBE_IMPERSONATION_FORBIDDEN")
|
||||
}
|
||||
ensure!(
|
||||
unsafe { GetLastError() } == ERROR_NO_TOKEN,
|
||||
"BOOT_PROBE_THREAD_TOKEN"
|
||||
);
|
||||
let mut raw = ptr::null_mut();
|
||||
ensure!(
|
||||
unsafe { OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &mut raw) } != 0,
|
||||
"BOOT_PROBE_TOKEN"
|
||||
);
|
||||
let result = (|| {
|
||||
let mut needed = 0;
|
||||
unsafe { GetTokenInformation(raw, TokenUser, ptr::null_mut(), 0, &mut needed) };
|
||||
ensure!((1..=4096).contains(&needed), "BOOT_PROBE_TOKEN_SIZE");
|
||||
let mut data = vec![0usize; (needed as usize).div_ceil(size_of::<usize>())];
|
||||
ensure!(
|
||||
unsafe {
|
||||
GetTokenInformation(
|
||||
raw,
|
||||
TokenUser,
|
||||
data.as_mut_ptr().cast(),
|
||||
needed,
|
||||
&mut needed,
|
||||
)
|
||||
} != 0,
|
||||
"BOOT_PROBE_USER"
|
||||
);
|
||||
let user = unsafe { &*data.as_ptr().cast::<TOKEN_USER>() };
|
||||
ensure!(
|
||||
unsafe { IsWellKnownSid(user.User.Sid, WinLocalServiceSid) } != 0,
|
||||
"BOOT_PROBE_LOCAL_SERVICE_REQUIRED"
|
||||
);
|
||||
let mut sid = [0usize; 16];
|
||||
let mut bytes = size_of::<[usize; 16]>() as u32;
|
||||
ensure!(
|
||||
unsafe {
|
||||
CreateWellKnownSid(
|
||||
WinBuiltinAdministratorsSid,
|
||||
ptr::null_mut(),
|
||||
sid.as_mut_ptr().cast(),
|
||||
&mut bytes,
|
||||
)
|
||||
} != 0,
|
||||
"BOOT_PROBE_ADMIN_SID"
|
||||
);
|
||||
let mut admin = 0;
|
||||
ensure!(
|
||||
unsafe {
|
||||
CheckTokenMembership(ptr::null_mut(), sid.as_mut_ptr().cast(), &mut admin)
|
||||
} != 0
|
||||
&& admin == 0,
|
||||
"BOOT_PROBE_ADMIN_FORBIDDEN"
|
||||
);
|
||||
Ok(())
|
||||
})();
|
||||
unsafe { CloseHandle(raw) };
|
||||
result
|
||||
}
|
||||
fn run() -> Result<()> {
|
||||
token()?;
|
||||
let case = CASE.get().unwrap();
|
||||
let path = PathBuf::from(r"C:\ProgramData\RustDiscoveryBootProbe").join(case.to_string());
|
||||
ensure!(
|
||||
std::fs::symlink_metadata(&path)?.is_dir()
|
||||
&& !std::fs::symlink_metadata(&path)?.file_type().is_symlink(),
|
||||
"BOOT_PROBE_CASE_DIRECTORY"
|
||||
);
|
||||
let first = super::native_boot::observe_candidate();
|
||||
std::thread::sleep(Duration::from_millis(750));
|
||||
let second = super::native_boot::observe_candidate();
|
||||
let equal = first.candidate_identifier.is_some()
|
||||
&& first.candidate_identifier == second.candidate_identifier;
|
||||
let report = serde_json::json!({"schema_version":1,"case_id":case,"service_name":NAME,"process_id":std::process::id(),"user_sid":"S-1-5-19","administrator_member":false,"thread_impersonation":false,"scm_callback_entered":true,"read_only":true,"jobs_created":false,"clock_queried":false,"clock_changed":false,"reboot_requested":false,"job_binding_qualified":false,"same_process_samples_equal":equal,"samples":[first,second]});
|
||||
let data = serde_json::to_vec(&report)?;
|
||||
ensure!(data.len() <= 8192, "BOOT_PROBE_REPORT_LIMIT");
|
||||
let mut output = std::fs::OpenOptions::new()
|
||||
.write(true)
|
||||
.create_new(true)
|
||||
.open(path.join("result.json"))?;
|
||||
output.write_all(&data)?;
|
||||
output.sync_all()?;
|
||||
Ok(())
|
||||
}
|
||||
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 core::ffi::c_void,
|
||||
_: *mut core::ffi::c_void,
|
||||
) -> u32 {
|
||||
0
|
||||
}
|
||||
unsafe extern "system" fn entry(_: u32, _: *mut *mut u16) {
|
||||
let name = wide(NAME);
|
||||
let handle =
|
||||
unsafe { RegisterServiceCtrlHandlerExW(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 = run();
|
||||
if result.is_ok() {
|
||||
std::thread::sleep(Duration::from_secs(2))
|
||||
};
|
||||
status(SERVICE_STOPPED, if result.is_ok() { 0 } else { 1066 });
|
||||
}
|
||||
pub fn main() -> Result<()> {
|
||||
let args: Vec<String> = std::env::args().collect();
|
||||
ensure!(
|
||||
args.len() == 3 && args[1] == "--service",
|
||||
"BOOT_PROBE_SERVICE_ONLY"
|
||||
);
|
||||
let case = uuid::Uuid::parse_str(&args[2])?;
|
||||
ensure!(!case.is_nil(), "BOOT_PROBE_CASE");
|
||||
CASE.set(case).unwrap();
|
||||
let mut name = wide(NAME);
|
||||
let table = [
|
||||
SERVICE_TABLE_ENTRYW {
|
||||
lpServiceName: name.as_mut_ptr(),
|
||||
lpServiceProc: Some(entry),
|
||||
},
|
||||
SERVICE_TABLE_ENTRYW {
|
||||
lpServiceName: ptr::null_mut(),
|
||||
lpServiceProc: None,
|
||||
},
|
||||
];
|
||||
ensure!(
|
||||
unsafe { StartServiceCtrlDispatcherW(table.as_ptr()) } != 0,
|
||||
"BOOT_PROBE_SCM_REQUIRED"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
#[cfg(windows)]
|
||||
fn main() -> anyhow::Result<()> {
|
||||
service::main()
|
||||
}
|
||||
#[cfg(not(windows))]
|
||||
fn main() {
|
||||
println!(
|
||||
"{}",
|
||||
serde_json::to_string(&native_boot::observe_candidate()).unwrap()
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,299 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Native negative peer controls and bounded SDK diagnostic, never an RMM job.
|
||||
|
||||
Only Root executes native phases after source review. Failed/ambiguous starts
|
||||
permit readback of the same case only; no token/key/private ledger data export.
|
||||
"""
|
||||
import argparse
|
||||
import base64
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import uuid
|
||||
|
||||
import client_bootstrap as cb
|
||||
import transport_acceptance as base
|
||||
import runtime_feature_upgrade as feature
|
||||
import system_helper_bootstrap as helper
|
||||
import auto_transport_acceptance as auto
|
||||
|
||||
require=cb.contract.require
|
||||
STATE=cb.EVIDENCE/'helper-peer-controls'
|
||||
NAME='RmmDiscoveryPeerControl'
|
||||
PARENT='RmmDiscoveryPeerParent'
|
||||
ROOT=r'C:\ProgramData\RustDiscoveryPeerControls'
|
||||
|
||||
# Shared by real Protect and read-only memory guards. Normalize the collection,
|
||||
# never an invalid individual SID. PS5 if {...} else {@()} assigns $null.
|
||||
ACL_CONSTRUCTORS=r'''function ControlIdentities([string[]]$readers,[string[]]$writers){
|
||||
if($null-eq$readers){$readers=@()};if($null-eq$writers){$writers=@()}
|
||||
$ids=@('S-1-5-18','S-1-5-32-544')+$readers+$writers
|
||||
foreach($id in $ids){if([string]::IsNullOrWhiteSpace($id)){throw 'EMPTY_CONTROL_SID'}}
|
||||
return $ids
|
||||
}
|
||||
function ControlRule([string]$id,[bool]$directory,[bool]$reader,[bool]$writer){
|
||||
[Security.AccessControl.InheritanceFlags]$inheritFlags=[Security.AccessControl.InheritanceFlags]::None
|
||||
if($directory){$inheritFlags=[Security.AccessControl.InheritanceFlags]::ContainerInherit-bor[Security.AccessControl.InheritanceFlags]::ObjectInherit}
|
||||
[Security.AccessControl.FileSystemRights]$rights=[Security.AccessControl.FileSystemRights]::FullControl
|
||||
if($writer){$rights=[Security.AccessControl.FileSystemRights]::Read-bor[Security.AccessControl.FileSystemRights]::Write}
|
||||
elseif($reader){$rights=[Security.AccessControl.FileSystemRights]::ReadAndExecute}
|
||||
$identity=[Security.Principal.SecurityIdentifier]::new($id)
|
||||
return [Security.AccessControl.FileSystemAccessRule]::new($identity,$rights,$inheritFlags,[Security.AccessControl.PropagationFlags]::None,[Security.AccessControl.AccessControlType]::Allow)
|
||||
}
|
||||
'''
|
||||
MEMORY_GUARD=ACL_CONSTRUCTORS+r'''$ErrorActionPreference='Stop'
|
||||
$rows=@()
|
||||
foreach($kind in @('root','controller','admin-leaf','writer-leaf')){
|
||||
$readers=if($kind-ceq'root'){@('S-1-5-80-1','S-1-5-80-2')}else{@()}
|
||||
$writers=if($kind-ceq'writer-leaf'){@('S-1-5-80-3')}else{@()}
|
||||
$ids=@(ControlIdentities $readers $writers);$expected=if($kind-ceq'root'){4}elseif($kind-ceq'writer-leaf'){3}else{2}
|
||||
if($ids.Count-ne$expected-or@($ids|Where-Object{[string]::IsNullOrWhiteSpace($_)}).Count){throw 'NORMALIZED_ROLE_COUNT'}
|
||||
$masks=@();foreach($id in $ids){$r=ControlRule $id ($kind-in@('root','controller')) ($id-in$readers) ($id-in$writers);$masks+=[int64]$r.FileSystemRights}
|
||||
if($masks[0]-ne2032127-or$masks[1]-ne2032127){throw 'EXACT_ADMIN_MASKS'}
|
||||
if($kind-ceq'root'-and($masks[2]-ne1179817-or$masks[3]-ne1179817)){throw 'EXACT_READER_MASKS'}
|
||||
if($kind-ceq'writer-leaf'-and$masks[2]-ne1180063){throw 'EXACT_LEAF_WRITER_MASK'}
|
||||
$rows+=@{case=$kind;constructor_count=$ids.Count;input_readers_null=($null-eq$readers);input_writers_null=($null-eq$writers);masks=$masks}
|
||||
}
|
||||
@{verified=$true;read_only=$true;filesystem_or_acl_mutations=$false;service_changes=$false;cases=$rows}|ConvertTo-Json -Depth 6 -Compress
|
||||
'''
|
||||
|
||||
PREPARE=r'''$ErrorActionPreference='Stop'
|
||||
$p=([Console]::In.ReadLine()|ConvertFrom-Json)
|
||||
if($p.sha -notmatch '^[a-f0-9]{64}$' -or $p.name -notin @('HelperPeerControls.exe','PeerControls.ps1')){throw 'Fixed control artifact'}
|
||||
$root='C:\ProgramData\RustDiscoveryPeerControls'
|
||||
$agent=(New-Object Security.Principal.NTAccount('NT SERVICE','RmmDiscoveryWindows')).Translate([Security.Principal.SecurityIdentifier]).Value
|
||||
$readers=@($agent,$p.control_sid)
|
||||
if($p.control_sid -notmatch '^S-1-5-80-([0-9]+-){4}[0-9]+$'){throw 'Fixed control SID'}
|
||||
function Check($path){$i=Get-Item -LiteralPath $path -Force;if($i.Attributes-band[IO.FileAttributes]::ReparsePoint){throw 'Control reparse'};$a=Get-Acl -LiteralPath $path;if($a.GetOwner([Security.Principal.SecurityIdentifier]).Value-notin@('S-1-5-18','S-1-5-32-544')){throw 'Control owner'};foreach($r in $a.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier])){if($r.AccessControlType-ne'Allow'){throw 'Control deny'};if($r.IdentityReference.Value-in@('S-1-5-18','S-1-5-32-544')){continue};if($r.IdentityReference.Value-notin$readers-or([int64]$r.FileSystemRights-band(-bnot 1179817))){throw 'Control reader'}}}
|
||||
if(!(Test-Path -LiteralPath $root)){
|
||||
New-Item -ItemType Directory -Path $root|Out-Null;$a=New-Object Security.AccessControl.DirectorySecurity;$a.SetAccessRuleProtection($true,$false);$a.SetOwner((New-Object Security.Principal.SecurityIdentifier('S-1-5-32-544')))
|
||||
foreach($id in @('S-1-5-18','S-1-5-32-544')+$readers){$right=if($id-in$readers){'ReadAndExecute'}else{'FullControl'};$a.AddAccessRule((New-Object Security.AccessControl.FileSystemAccessRule((New-Object Security.Principal.SecurityIdentifier($id)),$right,'ContainerInherit,ObjectInherit','None','Allow')))};Set-Acl -LiteralPath $root -AclObject $a
|
||||
}
|
||||
Check $root;$version=Join-Path $root $p.sha;if(!(Test-Path -LiteralPath $version)){New-Item -ItemType Directory -Path $version|Out-Null};Check $version
|
||||
$file=Join-Path $version $p.name;$exists=Test-Path -LiteralPath $file;if($exists){Check $file;if((Get-FileHash -LiteralPath $file -Algorithm SHA256).Hash.ToLowerInvariant()-cne$p.sha){throw 'Immutable control artifact'}}
|
||||
@{exists=$exists;sha=$p.sha}|ConvertTo-Json -Compress
|
||||
'''
|
||||
SCRIPT=r'''$ErrorActionPreference='Stop'
|
||||
$p=$global:RmmPeerControlPayload
|
||||
if($p.action-notin@('prepare','admin','service','parent','cleanup','readback')-or([guid]::ParseExact($p.id,'D').ToString())-cne$p.id-or$p.binary-notmatch'^[a-f0-9]{64}$'-or$p.source-notmatch'^[a-f0-9]{64}$'){throw 'Fixed control intent'}
|
||||
$root='C:\ProgramData\RustDiscoveryPeerControls';$case=Join-Path $root $p.id;$controller=Join-Path $case 'controller';$exe=Join-Path (Join-Path $root $p.binary) 'HelperPeerControls.exe'
|
||||
$agentName='RmmDiscoveryWindows';$helperName='RmmDiscoverySystemHelper';$name='RmmDiscoveryPeerControl';$parentName='RmmDiscoveryPeerParent'
|
||||
$agentSid=(New-Object Security.Principal.NTAccount('NT SERVICE',$agentName)).Translate([Security.Principal.SecurityIdentifier]).Value
|
||||
$controlSid=$p.control_sid
|
||||
function Hash($path){return (Get-FileHash -LiteralPath $path -Algorithm SHA256).Hash.ToLowerInvariant()}
|
||||
function WriteNew($path,$data){$b=[Text.Encoding]::UTF8.GetBytes(($data|ConvertTo-Json -Depth 24 -Compress));$f=[IO.File]::Open($path,'CreateNew','Write','Read');try{$f.Write($b,0,$b.Length);$f.Flush($true)}finally{$f.Dispose()}}
|
||||
function Check($path,[bool]$directory,[string[]]$readers,[string[]]$writers){
|
||||
$i=Get-Item -LiteralPath $path -Force;if($i.PSIsContainer-ne$directory-or($i.Attributes-band[IO.FileAttributes]::ReparsePoint)){throw 'Fixed regular control path'}
|
||||
$a=Get-Acl -LiteralPath $path;$owner=$a.GetOwner([Security.Principal.SecurityIdentifier]).Value
|
||||
if($owner-notin@('S-1-5-18','S-1-5-32-544')){throw 'SYSTEM/Admin report ownership required'}
|
||||
$rules=@($a.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier]));if(!$rules.Count){throw 'Empty control DACL'}
|
||||
foreach($r in $rules){
|
||||
$id=$r.IdentityReference.Value;$mask=[int64]$r.FileSystemRights
|
||||
if($r.AccessControlType-ne'Allow'){throw 'Unexpected control ACE'}
|
||||
if($id-in@('S-1-5-18','S-1-5-32-544')){if($mask-ne2032127){throw 'Exact controller administrative rights'}}
|
||||
elseif($id-in$writers){if($mask-ne1180063-or$directory){throw 'Writer only on fixed precreated output leaf'}}
|
||||
elseif($id-in$readers){if($mask-band(-bnot 1179817)){throw 'Reader-only role'}}
|
||||
else{throw 'Foreign control/report principal'}
|
||||
}
|
||||
}
|
||||
function Protect($path,[bool]$directory,[string[]]$readers,[string[]]$writers){
|
||||
$a=if($directory){[Security.AccessControl.DirectorySecurity]::new()}else{[Security.AccessControl.FileSecurity]::new()};$a.SetAccessRuleProtection($true,$false);$a.SetOwner([Security.Principal.SecurityIdentifier]::new('S-1-5-32-544'))
|
||||
foreach($id in (ControlIdentities $readers $writers)){
|
||||
$rule=ControlRule $id $directory ($id-in$readers) ($id-in$writers)
|
||||
$a.AddAccessRule($rule)
|
||||
}
|
||||
Set-Acl -LiteralPath $path -AclObject $a;Check $path $directory $readers $writers
|
||||
}
|
||||
function ReportPath($name){
|
||||
if($name-in@('admin-token','admin-result')){return Join-Path (Join-Path $case 'admin') ($name+'.json')}
|
||||
if($name-in@('service-token','service-result')){return Join-Path (Join-Path $case 'service') ($name+'.json')}
|
||||
if($name-in@('child-token','child-sdk-prechecks','child-result')){return Join-Path (Join-Path $case 'child') ($name+'.json')}
|
||||
return Join-Path $controller ($name+'.json')
|
||||
}
|
||||
function Metadata($path){$i=Get-Item -LiteralPath $path -Force;if($i.Attributes-band[IO.FileAttributes]::ReparsePoint){throw 'Existing component reparse'};return [ordered]@{name=$i.Name;length=$i.Length;created=$i.CreationTimeUtc.Ticks;written=$i.LastWriteTimeUtc.Ticks;sddl=(Get-Acl -LiteralPath $path).Sddl}}
|
||||
function Baseline {
|
||||
$services=[ordered]@{}
|
||||
foreach($pair in @(@($agentName,$p.agent_pid,'NT AUTHORITY\LocalService',$p.agent_binary,'C:\Program Files\RustDiscovery\rmm-agent-windows.exe'),@($helperName,$p.helper_pid,'LocalSystem',$p.helper_binary,'C:\Program Files\RustDiscovery\rmm-helper-windows.exe'))){
|
||||
$s=Get-CimInstance Win32_Service -Filter ("Name='"+$pair[0]+"'") -OperationTimeoutSec 10
|
||||
if($s.State-cne'Running'-or$s.ProcessId-ne$pair[1]-or$s.StartName-cne$pair[2]-or(Hash $pair[4])-cne$pair[3]){throw 'Original current agent/helper identity'}
|
||||
$process=Get-CimInstance Win32_Process -Filter ('ProcessId='+$s.ProcessId) -OperationTimeoutSec 10
|
||||
$owner=(Invoke-CimMethod -InputObject $process -MethodName GetOwnerSid -OperationTimeoutSec 10).Sid;$expected=if($pair[0]-ceq$agentName){'S-1-5-19'}else{'S-1-5-18'}
|
||||
if($owner-cne$expected-or$process.ExecutablePath-cne$pair[4]){throw 'Original running process identity'}
|
||||
$services[$pair[0]]=[ordered]@{pid=$s.ProcessId;path=$s.PathName;start_mode=$s.StartMode;account=$s.StartName;owner_sid=$owner;creation_filetime=$process.CreationDate.ToUniversalTime().ToFileTimeUtc();binary_sha256=(Hash $pair[4])}
|
||||
}
|
||||
$settings='C:\ProgramData\RustDiscoverySystem\helper.json';$pin='C:\ProgramData\RustDiscoverySystem\agent-pin.json'
|
||||
if((Hash $settings)-cne$p.policy-or(Hash $pin)-cne$p.pin_sha256){throw 'Original passive helper public pin'}
|
||||
$cfg=Get-Content -LiteralPath $settings -Raw|ConvertFrom-Json
|
||||
if($cfg.enable_effects-ne$false-or$cfg.allow_reboot-ne$false-or@($cfg.allowed_services).Count-ne0){throw 'Empty passive policy only'}
|
||||
$files=@(Get-ChildItem -LiteralPath 'C:\ProgramData\RustDiscoverySystem\state' -File -Force|Sort-Object Name|ForEach-Object{Metadata $_.FullName})
|
||||
# Metadata only: never read/hash/copy private ledger or key contents.
|
||||
return [ordered]@{services=$services;private_helper_metadata=$files;agent_config=(Metadata 'C:\ProgramData\RustDiscovery\config.json');agent_config_sha256=(Hash 'C:\ProgramData\RustDiscovery\config.json');device_key_metadata=(Metadata 'C:\ProgramData\RustDiscovery\state\device.key');helper_public_pin_sha256=(Hash $pin);helper_public_settings_sha256=(Hash $settings);helper_private_bytes_read=$false}
|
||||
}
|
||||
function Same($before,$after){if(($before|ConvertTo-Json -Depth 24 -Compress)-cne($after|ConvertTo-Json -Depth 24 -Compress)){throw 'Original agent/helper or private file metadata changed'}}
|
||||
function ReadIntent{Check $case $true @($agentSid,$controlSid) @();Check $controller $true @() @();Check (Join-Path $controller 'intent.json') $false @() @();$i=Get-Content -LiteralPath (Join-Path $controller 'intent.json') -Raw|ConvertFrom-Json;foreach($field in @('id','binary','source','agent_pid','helper_pid','agent_binary','helper_binary','policy','pin_sha256','control_sid')){if($i.payload.$field-cne$p.$field){throw 'Exact retained control intent'}};return $i}
|
||||
if((Hash $exe)-cne$p.binary){throw 'Exact control executable'}
|
||||
if($p.action-ceq'prepare'){
|
||||
if((Test-Path -LiteralPath $case)-or(Get-Service -Name $name -ErrorAction SilentlyContinue)-or(Get-Service -Name $parentName -ErrorAction SilentlyContinue)){throw 'No preexisting control case/services'}
|
||||
$before=Baseline;New-Item -ItemType Directory -Path $case|Out-Null;Protect $case $true @($agentSid,$controlSid) @()
|
||||
foreach($dir in @('controller','admin','service','child')){
|
||||
$path=Join-Path $case $dir;New-Item -ItemType Directory -Path $path|Out-Null
|
||||
$readers=if($dir-ceq'service'){@($controlSid)}elseif($dir-ceq'child'){@($agentSid)}else{@()}
|
||||
Protect $path $true $readers @()
|
||||
}
|
||||
WriteNew (Join-Path $controller 'intent.json') @{payload=$p;before=$before;no_jobs=$true}
|
||||
# Precreate fixed leaves before ANY actor starts. Their owner stays Admin;
|
||||
# no actor may create files in a report directory or acquire owner WRITE_DAC.
|
||||
foreach($report in @('admin-token','admin-result','service-token','service-result','child-token','child-sdk-prechecks','child-result')){
|
||||
$path=ReportPath $report;$f=[IO.File]::Open($path,'CreateNew','Write','Read');$f.Dispose()
|
||||
$writers=if($report.StartsWith('service-')){@($controlSid)}elseif($report.StartsWith('child-')){@($agentSid)}else{@()}
|
||||
Protect $path $false @() $writers
|
||||
}
|
||||
$pin=Get-Content -LiteralPath 'C:\ProgramData\RustDiscoverySystem\agent-pin.json' -Raw|ConvertFrom-Json
|
||||
WriteNew (Join-Path $case 'input.json') @{schema_version=1;case_id=$p.id;pin=$pin;expected_agent_pid=$p.agent_pid;expected_helper_pid=$p.helper_pid;expected_agent_creation=$before.services.RmmDiscoveryWindows.creation_filetime;control_binary_sha256=$p.binary};Protect (Join-Path $case 'input.json') $false @($agentSid,$controlSid) @()
|
||||
@{prepared=$true;baseline=$before;no_jobs=$true}|ConvertTo-Json -Depth 24 -Compress;exit 0
|
||||
}
|
||||
$intent=ReadIntent;Same $intent.before (Baseline)
|
||||
if($p.action-ceq'admin'){
|
||||
WriteNew (Join-Path $controller 'admin-start-intent.json') @{once=$true;raw_probe_only=$true}
|
||||
$si=New-Object Diagnostics.ProcessStartInfo;$si.FileName=$exe;$si.Arguments='--admin '+$p.id;$si.UseShellExecute=$false;$si.CreateNoWindow=$true;$si.RedirectStandardError=$true;$si.RedirectStandardOutput=$true
|
||||
$proc=New-Object Diagnostics.Process;$proc.StartInfo=$si
|
||||
if(!$proc.Start()){throw 'Own administrator probe start'}
|
||||
try{$out=$proc.StandardOutput.ReadToEndAsync();$err=$proc.StandardError.ReadToEndAsync();if(!$proc.WaitForExit(20000)){$proc.Kill();$proc.WaitForExit(5000)|Out-Null;throw 'Own administrator probe timeout'};WriteNew (Join-Path $controller 'admin-exit.json') @{pid=$proc.Id;exit_code=$proc.ExitCode;stdout_bytes=$out.Result.Length;stderr_bytes=$err.Result.Length};if($proc.ExitCode-ne0){throw 'Own administrator probe incomplete'}}finally{$proc.Dispose()}
|
||||
}
|
||||
if($p.action-in@('service','parent')){
|
||||
$kind=$p.action;$serviceName=if($kind-ceq'service'){$name}else{$parentName};$mode=if($kind-ceq'service'){'--service'}else{'--parent'};$command='"'+$exe+'" '+$mode+' '+$p.id
|
||||
if(Get-Service -Name $serviceName -ErrorAction SilentlyContinue){throw 'Existing control service: readback only'}
|
||||
WriteNew (Join-Path $controller ($kind+'-start-intent.json')) @{once=$true;service=$serviceName;command=$command;probe_only=$true;no_jobs=$true}
|
||||
if($kind-ceq'service'){$credential=New-Object Management.Automation.PSCredential('NT AUTHORITY\LocalService',(New-Object Security.SecureString));New-Service -Name $serviceName -BinaryPathName $command -StartupType Manual -Credential $credential|Out-Null}
|
||||
else{New-Service -Name $serviceName -BinaryPathName $command -StartupType Manual|Out-Null}
|
||||
& "$env:WINDIR\System32\sc.exe" sidtype $serviceName unrestricted|Out-Null;if($LASTEXITCODE-ne0){throw 'Own control service SID'}
|
||||
Start-Service -Name $serviceName
|
||||
}
|
||||
$deadline=[DateTime]::UtcNow.AddSeconds(35)
|
||||
foreach($kind in @('service','parent')){
|
||||
$serviceName=if($kind-ceq'service'){$name}else{$parentName};$mode=if($kind-ceq'service'){'--service'}else{'--parent'};$command='"'+$exe+'" '+$mode+' '+$p.id
|
||||
$s=Get-CimInstance Win32_Service -Filter ("Name='"+$serviceName+"'") -OperationTimeoutSec 10
|
||||
if($s){
|
||||
$expected=if($kind-ceq'service'){'NT AUTHORITY\LocalService'}else{'LocalSystem'}
|
||||
if($s.PathName-cne$command-or$s.StartName-cne$expected-or$s.StartMode-cne'Manual'){throw 'Exact own control service only'}
|
||||
while($s.State-cne'Stopped'-and[DateTime]::UtcNow-lt$deadline){Start-Sleep -Milliseconds 100;$s=Get-CimInstance Win32_Service -Filter ("Name='"+$serviceName+"'") -OperationTimeoutSec 10}
|
||||
if($p.action-in@('service','parent','cleanup')){
|
||||
if($s.State-cne'Stopped'){throw 'Own control still active: retain and readback only'}
|
||||
$cleanup=Join-Path $controller ($kind+'-cleanup-intent.json')
|
||||
if(!(Test-Path -LiteralPath $cleanup)){WriteNew $cleanup @{service=$serviceName;command=$command;remove_only_own_stopped_service=$true}}
|
||||
else{Check $cleanup $false @() @();$c=Get-Content -LiteralPath $cleanup -Raw|ConvertFrom-Json;if($c.service-cne$serviceName-or$c.command-cne$command){throw 'Retained cleanup intent'}}
|
||||
& "$env:WINDIR\System32\sc.exe" delete $serviceName|Out-Null;if($LASTEXITCODE-ne0){throw 'Exact stopped own service cleanup'}
|
||||
}
|
||||
}
|
||||
}
|
||||
Same $intent.before (Baseline)
|
||||
$reports=[ordered]@{};$reportTrust=[ordered]@{}
|
||||
foreach($name in @('admin-token','admin-result','service-token','service-result','parent-token','parent-result','child-create-intent','child-started','child-token','child-sdk-prechecks','child-result')){
|
||||
$path=ReportPath $name;$reports[$name]=$null
|
||||
$writers=if($name-in@('service-token','service-result')){@($controlSid)}elseif($name-in@('child-token','child-sdk-prechecks','child-result')){@($agentSid)}else{@()}
|
||||
$readers=if($name-in@('service-token','service-result')){@($controlSid)}elseif($name-in@('child-token','child-sdk-prechecks','child-result')){@($agentSid)}else{@()}
|
||||
Check ([IO.Path]::GetDirectoryName($path)) $true $readers @()
|
||||
if(Test-Path -LiteralPath $path){Check $path $false @() $writers;$i=Get-Item -LiteralPath $path -Force;if($i.Length-gt8192){throw 'Bounded own report'};if($i.Length-gt0){$reports[$name]=Get-Content -LiteralPath $path -Raw|ConvertFrom-Json;$reportTrust[$name]=@{owner_sid=(Get-Acl -LiteralPath $path).GetOwner([Security.Principal.SecurityIdentifier]).Value;allowed_actor_writers=$writers;provenance=$(if($name-in@('child-token','child-sdk-prechecks','child-result')){'agent_token_assertion'}elseif($name-in@('service-token','service-result')){'control_service_assertion'}else{'system_or_bootstrap_administrator'})}}}
|
||||
}
|
||||
@{readback=$true;id=$p.id;reports=$reports;report_trust=$reportTrust;writer_binding_checked=$true;original_preserved=$true;own_services_removed=(!(Get-Service -Name 'RmmDiscoveryPeerControl' -ErrorAction SilentlyContinue)-and!(Get-Service -Name 'RmmDiscoveryPeerParent' -ErrorAction SilentlyContinue));no_jobs=$true;no_private_data_read=$true}|ConvertTo-Json -Depth 24 -Compress
|
||||
'''
|
||||
SCRIPT=ACL_CONSTRUCTORS+SCRIPT
|
||||
LAUNCH=base.LAUNCH_SCRIPT.replace('TransportAcceptance.ps1','PeerControls.ps1').replace('RmmTransportPayload','RmmPeerControlPayload').replace('RustDiscoveryBootstrap','RustDiscoveryPeerControls')
|
||||
|
||||
|
||||
def sources():
|
||||
value=feature.source_files();value['deploy/windows/helper_peer_controls.py']=helper.sha(__file__)
|
||||
return dict(sorted(value.items()))
|
||||
|
||||
|
||||
def build():
|
||||
os.umask(0o077);helper.private_dir(STATE);folder=STATE/('build-'+str(uuid.uuid4()));folder.mkdir(mode=0o700)
|
||||
before=sources();helper.store(folder,'source-before.json',before)
|
||||
target=cb.ROOT/'devstate/windows-peer-controls-target';target.mkdir(mode=0o700,parents=True,exist_ok=True)
|
||||
command='cargo clippy --locked --offline --target '+feature.TARGET+' -p rmm-agent-windows --features system-helper --all-targets -- -D warnings && cargo build --locked --offline --release --target '+feature.TARGET+' -p rmm-agent-windows --features system-helper --example helper_peer_controls'
|
||||
feature.previous.command(['docker','run','--rm','--network','none','--read-only','--tmpfs','/tmp:rw,size=512m','-v',str(cb.ROOT)+':/src:ro','-v',str(target)+':/target','-e','CARGO_TARGET_DIR=/target','--entrypoint','sh',feature.IMAGE,'-c',command])
|
||||
require(before==sources(),'control source unchanged during build')
|
||||
path=folder/'HelperPeerControls.exe';shutil.copyfile(target/feature.TARGET/'release/examples/helper_peer_controls.exe',path);path.chmod(0o600)
|
||||
manifest=dict(schema_version=1,type='rmm.windows.helper-peer-controls',source_files=before,system_helper_feature=True,artifact=dict(path=str(path.resolve()),sha256=helper.sha(path)),cross_clippy_D_warnings=True,all_targets_checked=True,release_build=True,native_tested=False,no_jobs=True)
|
||||
helper.store(folder,'manifest.json',manifest);print(json.dumps({'manifest':str((folder/'manifest.json').resolve()),'native_tested':False}))
|
||||
|
||||
|
||||
def stage(path,name):
|
||||
digest=helper.sha(path);payload=dict(sha=digest,name=name,control_sid=helper.service_sid(NAME));exists=cb.powershell(PREPARE,payload)
|
||||
if not exists['exists']:
|
||||
access=cb.contract.protected_json(cb.ROOT/'credentials/windows-dev-access.json')['ssh_prefix'];args=['sftp']+[p for p in access[1:-1] if p!='-T']+['-b','-',access[-1]]
|
||||
target='/C:/ProgramData/RustDiscoveryPeerControls/'+digest+'/'+name
|
||||
transferred=subprocess.run(args,input=('put '+json.dumps(str(path.resolve()))+' '+json.dumps(target)+'\n').encode(),capture_output=True,timeout=120)
|
||||
require(transferred.returncode==0 and cb.powershell(PREPARE,payload)['exists'],'exact staged control artifact')
|
||||
return digest
|
||||
|
||||
|
||||
def prepare(manifest_path,helper_case):
|
||||
manifest=cb.contract.protected_json(manifest_path)
|
||||
require(manifest['type']=='rmm.windows.helper-peer-controls' and manifest['system_helper_feature'] is True and manifest['source_files']==sources() and helper.sha(manifest['artifact']['path'])==manifest['artifact']['sha256'],'new source-bound control artifact, not old 27-unit proof')
|
||||
index,association,native=helper.current_runtime()
|
||||
require(str(uuid.UUID(helper_case))==helper_case,'exact existing passive helper case')
|
||||
helper_intent=cb.contract.protected_json(cb.EVIDENCE/'system-helper-bootstrap'/helper_case/'intent.json');profile=helper_intent['payload']
|
||||
require(profile['agent_sha256']==index['binary_sha256'] and profile['helper_sha256']==helper.HELPER_SHA,'exact retained current helper/agent association')
|
||||
ident=str(uuid.uuid4());helper.private_dir(STATE);folder=STATE/ident;folder.mkdir(mode=0o700)
|
||||
source=folder/'PeerControls.ps1';fd=os.open(source,os.O_CREAT|os.O_EXCL|os.O_WRONLY|os.O_NOFOLLOW,0o600)
|
||||
with os.fdopen(fd,'wb') as out:out.write(SCRIPT.encode());out.flush();os.fsync(out.fileno())
|
||||
payload=dict(id=ident,binary=manifest['artifact']['sha256'],source=hashlib.sha256(SCRIPT.encode()).hexdigest(),control_sid=helper.service_sid(NAME),agent_pid=native['service']['process_id'],helper_pid=6240,agent_binary=index['binary_sha256'],helper_binary=helper.HELPER_SHA,policy=profile['policy_sha256'],pin_sha256=profile['pin_sha256'])
|
||||
require(payload['agent_pid']==5140,'explicit current accepted agent process; no silent PID adoption')
|
||||
intent=dict(payload=payload,source_file_sha256=helper.sha(__file__),manifest_path=str(manifest_path.resolve()),manifest_sha256=helper.sha(manifest_path),runtime_index=association,helper_case=helper_case,no_jobs=True)
|
||||
helper.store(folder,'intent.json',intent);helper.store(folder,'prepare-attempt.json',{'create_once':True})
|
||||
stage(Path(manifest['artifact']['path']),'HelperPeerControls.exe');stage(source,'PeerControls.ps1')
|
||||
before=dict(counts=auto.scopes(),flags=auto.status());helper.store(folder,'server-before.json',before)
|
||||
report=cb.powershell(LAUNCH,{'sha256':payload['source'],'payload':dict(payload,action='prepare')},timeout=90,remote_signed=True)
|
||||
helper.store(folder,'prepared.json',report);print(json.dumps({'id':ident,'prepared':True,'no_jobs':True}))
|
||||
|
||||
|
||||
def run(ident,action):
|
||||
require(str(uuid.UUID(ident))==ident,'same canonical control case')
|
||||
folder=STATE/ident;intent=cb.contract.protected_json(folder/'intent.json');payload=intent['payload']
|
||||
require(helper.sha(__file__)==intent['source_file_sha256'] and payload['source']==hashlib.sha256(SCRIPT.encode()).hexdigest(),'exact prepared source; no case rebase')
|
||||
require(helper.sha(intent['manifest_path'])==intent['manifest_sha256'] and helper.sha(intent['runtime_index']['path'])==intent['runtime_index']['sha256'],'retained control manifest and current runtime index')
|
||||
cb.contract.protected_json(folder/'prepared.json')
|
||||
if action!='readback':helper.store(folder,action+'-attempt.json',{'once':True,'probe_only':True})
|
||||
report=cb.powershell(LAUNCH,{'sha256':payload['source'],'payload':dict(payload,action=action)},timeout=90,remote_signed=True)
|
||||
helper.store(folder,action+'-readback-'+str(uuid.uuid4())+'.json',report)
|
||||
before=cb.contract.protected_json(folder/'server-before.json');require(auto.scopes()==before['counts'] and auto.status()==before['flags'],'all Windows/Linux job counts and server policy flags unchanged')
|
||||
if action=='readback':
|
||||
print(json.dumps({'id':ident,'read_only':True,'native':report,'no_jobs':True}));return
|
||||
result=summarize(report,payload,ident)
|
||||
helper.store(folder,'result-'+str(uuid.uuid4())+'.json',result);print(json.dumps(result))
|
||||
|
||||
def summarize(report,payload,ident):
|
||||
require(report.get('writer_binding_checked') is True,'native owner and exact writer-role checks required')
|
||||
require(report['original_preserved'] is True and report['own_services_removed'] is True,'original services/files preserved and own stopped services removed')
|
||||
result={'id':ident,'original_preserved':True,'own_services_removed':True,'no_jobs':True,'parent_diagnostic':report['reports'].get('parent-result'),'parent_token':report['reports'].get('parent-token'),'report_trust':report.get('report_trust',{}),'controls':{}}
|
||||
for kind in ('admin','service'):
|
||||
value=report['reports'].get(kind+'-result')
|
||||
if value:
|
||||
require(value['pipe']['sdk_self_check_used'] is False,'raw peer test, never SDK self-refusal')
|
||||
require(value.get('case_id')==ident and value.get('mode')==kind and value.get('no_jobs') is True and value.get('read_only') is True,'exact native control receipt')
|
||||
if kind=='admin':require(value['token']['administrator_enabled'] is True and value['token']['user_sid'] not in ('S-1-5-18','S-1-5-19'),'actual bootstrap administrator')
|
||||
if kind=='service':require(value['token']['user_sid']=='S-1-5-19' and value['token']['control_service_sid_enabled'] is True and value['token']['agent_service_sid_enabled'] is False,'actual distinct LocalService service-SID')
|
||||
error=value['pipe'].get('win32_error');opened=value['pipe'].get('opened')
|
||||
require(value['pipe']['rejected'] is True and ((opened is False and error==5) or (opened is True and error in (109,232,233) and value['pipe'].get('actual_server_pid')==payload['helper_pid'])),'BUSY/timeout/response is inconclusive, never claim a denied peer')
|
||||
result['controls'][kind]={'verified_negative':True,'pipe':value['pipe'],'token':value['token']}
|
||||
if report['reports'].get('child-result'):
|
||||
value=report['reports']['child-result'];require(value['token']['user_sid']=='S-1-5-19' and value['token']['agent_service_sid_enabled'] is True and value['token']['actual_process_id']!=payload['agent_pid'],'actual wrong-PID/image child with Agent primary identity')
|
||||
require(value['pipe'].get('received_reply') is False,'impostor unexpectedly received a helper reply')
|
||||
result['controls']['agent_token_child']={'diagnostic_only':True,'report':value,'parent':report['reports'].get('parent-result'),'prechecks':report['reports'].get('child-sdk-prechecks')}
|
||||
return result
|
||||
|
||||
|
||||
def main():
|
||||
p=argparse.ArgumentParser(description=__doc__);p.add_argument('action',choices=['build-local','memory-guard','prepare','admin','service','parent','cleanup','readback']);p.add_argument('--manifest',type=Path);p.add_argument('--helper-case');p.add_argument('--id');a=p.parse_args()
|
||||
if a.action=='build-local':build()
|
||||
elif a.action=='memory-guard':
|
||||
value=cb.powershell(MEMORY_GUARD,{},timeout=30);require(value.get('verified') is True and value.get('filesystem_or_acl_mutations') is False,'actual memory-only ACL constructor guard');print(json.dumps(value))
|
||||
elif a.action=='prepare':require(a.manifest is not None and a.helper_case is not None,'new control manifest and explicit existing passive helper case required');prepare(a.manifest,a.helper_case)
|
||||
else:require(a.id is not None,'existing explicit control case required');run(a.id,a.action)
|
||||
|
||||
|
||||
if __name__=='__main__':main()
|
||||
@@ -0,0 +1,57 @@
|
||||
"""Only local fixtures for peer-control reporting and exactly-once starts."""
|
||||
import copy
|
||||
import hashlib
|
||||
from pathlib import Path
|
||||
import tempfile
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
import uuid
|
||||
|
||||
import helper_peer_controls as control
|
||||
|
||||
|
||||
class PeerControlGuards(unittest.TestCase):
|
||||
def fixture(self):
|
||||
ident=str(uuid.uuid4());payload={'helper_pid':6240,'agent_pid':5140}
|
||||
value=dict(schema_version=1,case_id=ident,mode='service',token={'user_sid':'S-1-5-19','control_service_sid_enabled':True,'agent_service_sid_enabled':False},pipe={'sdk_self_check_used':False,'rejected':True,'opened':False,'win32_error':5},no_jobs=True,read_only=True)
|
||||
report={'writer_binding_checked':True,'original_preserved':True,'own_services_removed':True,'reports':{'service-result':value}}
|
||||
return report,payload,ident
|
||||
|
||||
def test_busy_timeout_or_sdk_self_refusal_is_never_server_peer_proof(self):
|
||||
report,payload,ident=self.fixture()
|
||||
self.assertTrue(control.summarize(report,payload,ident)['controls']['service']['verified_negative'])
|
||||
unbound=copy.deepcopy(report);unbound['writer_binding_checked']=False
|
||||
with self.assertRaises(Exception):control.summarize(unbound,payload,ident)
|
||||
for field,value in [('win32_error',231),('win32_error',1460),('sdk_self_check_used',True),('rejected',False)]:
|
||||
bad=copy.deepcopy(report);bad['reports']['service-result']['pipe'][field]=value
|
||||
with self.assertRaises(Exception,msg=field):control.summarize(bad,payload,ident)
|
||||
bad=copy.deepcopy(report);bad['reports']['service-result']['token']['agent_service_sid_enabled']=True
|
||||
with self.assertRaises(Exception):control.summarize(bad,payload,ident)
|
||||
|
||||
def test_raw_closed_pipe_must_name_the_original_helper_process(self):
|
||||
report,payload,ident=self.fixture();pipe=report['reports']['service-result']['pipe'];pipe.update(opened=True,win32_error=109,actual_server_pid=6240)
|
||||
self.assertTrue(control.summarize(report,payload,ident)['controls']['service']['verified_negative'])
|
||||
pipe['actual_server_pid']=999
|
||||
with self.assertRaises(Exception):control.summarize(report,payload,ident)
|
||||
|
||||
def test_lost_service_start_reply_cannot_repeat_service_operation(self):
|
||||
with tempfile.TemporaryDirectory() as temporary:
|
||||
state=Path(temporary);ident=str(uuid.uuid4());folder=state/ident;folder.mkdir(mode=0o700)
|
||||
manifest=control.helper.store(state,'manifest.json',{'fixture':True});index=control.helper.store(state,'index.json',{'fixture':True})
|
||||
intent={'payload':{'id':ident,'source':hashlib.sha256(control.SCRIPT.encode()).hexdigest()},'source_file_sha256':control.helper.sha(control.__file__),'manifest_path':str(manifest),'manifest_sha256':control.helper.sha(manifest),'runtime_index':{'path':str(index),'sha256':control.helper.sha(index)}}
|
||||
control.helper.store(folder,'intent.json',intent);control.helper.store(folder,'prepared.json',{'prepared':True})
|
||||
with patch.object(control,'STATE',state),patch.object(control.cb,'powershell',side_effect=RuntimeError('lost reply')) as rpc:
|
||||
with self.assertRaisesRegex(RuntimeError,'lost reply'):control.run(ident,'service')
|
||||
with self.assertRaises(FileExistsError):control.run(ident,'service')
|
||||
self.assertEqual(rpc.call_count,1)
|
||||
|
||||
def test_remote_readback_has_no_cleanup_mutation_and_explicit_cleanup_is_separate(self):
|
||||
# The complete remote script is parsed separately. This guard fixes the
|
||||
# security-critical mutation dispatch: readback must not enter cleanup.
|
||||
self.assertIn("if($p.action-in@('service','parent','cleanup')){",control.SCRIPT)
|
||||
self.assertNotIn("if($p.action-in@('service','parent','cleanup','readback'))",control.SCRIPT)
|
||||
self.assertIn("Protect $case $true @($agentSid,$controlSid) @()",control.SCRIPT)
|
||||
self.assertIn("if($mask-ne1180063-or$directory)",control.SCRIPT)
|
||||
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
@@ -53,6 +53,16 @@ Zugänge und private Rohbelege bleiben gitignoriert.
|
||||
|
||||
## Aktuelle Windowsfortsetzung
|
||||
|
||||
Helper-Peer-Kontrollfall `603c2f9d…`: native Windows5-Speicherproben der
|
||||
ACL-Konstruktoren, geschützte Vorbereitung und rohe Administratorkontrolle
|
||||
bestanden (Pipeöffnen verweigert5, echte Adminidentität, kein SDK-Selbstcheck).
|
||||
Originale Agent-/Helperprozesse5140/6240 und Windows0/0/0/0/Linux30/30/26/0
|
||||
erhalten. LocalService-/Parentphase und positive Agentverbindung noch offen.
|
||||
Vorheriger Fall `4a60d264…` scheiterte vor Dienststart an einer exakt nativ
|
||||
reproduzierten Null-Collection aus leerem PowerShell-IF-Zweig; weder
|
||||
allgemeiner Konstruktorfehler noch nachträglicher Erfolg behauptet.
|
||||
[Kontrollbericht](windows-helper-peer-controls.md).
|
||||
|
||||
Zentrale getrennte SYSTEM-Policy implementiert, lokal und anschließend13 reine
|
||||
Policyguards nativ auf Cloud-Linux bestanden, Fall `13b11ce4…`, Binary `ca1df8b2…`.
|
||||
Rootrecht ist kein SYSTEM-Recht, exakte Geräte-/Helperpins und enge Fixture-SCM-
|
||||
|
||||
@@ -0,0 +1,112 @@
|
||||
# Windows-Bootidentität: Bestandsquelle und unqualifizierter Kandidat
|
||||
|
||||
Stand 2026-11-14: Die neue Strecke ist **nur als separate Diagnosequelle
|
||||
implementiert, lokal geprüft und crossgebaut**. Es wurden **keine nativen
|
||||
Boot-API-Aufrufe**, keine LocalService-Probe, keine Zeitänderung und kein
|
||||
OS-Reboot damit ausgeführt. `job_binding_qualified` ist in jedem Ergebnis
|
||||
`false`. Die produktive Agent-/Helper-Bootquelle wurde nicht geändert; es wird
|
||||
keine zusätzliche Capability angeboten.
|
||||
|
||||
## Bestehende CIM-Quelle
|
||||
|
||||
Der bestehende Windowscode liest mit einem festen passiven CIM-Aufruf
|
||||
`Win32_OperatingSystem.LastBootUpTime`, wandelt den Wert in UTC-Ticks um und
|
||||
bildet daraus einen UUID-förmigen Hash mit dem Namensraum
|
||||
`rmm.windows.boot.cim.ticks.v1`. Agent und Helper verwenden diese bestehende
|
||||
Quelle. Die dokumentierte CIM-Eigenschaft bezeichnet den Zeitpunkt des letzten
|
||||
Betriebssystemstarts; sie ist ein Zeitwert und kein dokumentierter opaker
|
||||
Boot-Identifier. [Microsoft: Win32_OperatingSystem](https://learn.microsoft.com/en-us/windows/win32/cimwin32prov/win32-operatingsystem).
|
||||
|
||||
Übereinstimmende wiederholte CIM-Abfragen belegen ausschließlich die beobachtete
|
||||
Übereinstimmung. Sie sind kein Nachweis, dass die Ableitung einen Prozessneustart,
|
||||
einen Wanduhrsprung, Suspend/Resume, Fast Startup oder einen tatsächlichen
|
||||
OS-Neustart korrekt voneinander unterscheidet. Hier wurde insbesondere **kein
|
||||
Fehlerverhalten bei einem Zeitsprung beobachtet oder nachgewiesen**. Aus dem
|
||||
fehlenden Stabilitätsnachweis folgt weder die Behauptung, CIM ändere sich bei
|
||||
jedem Zeitsprung, noch eine belastbare Garantie, dass dies niemals geschieht.
|
||||
|
||||
Für gespeichertes passives Inventar bleibt die Herkunft damit nachvollziehbar.
|
||||
Eine zukünftige Job-/Rebootbindung benötigt einen eigenständig qualifizierten
|
||||
Vertrag. Ein bloßer Wechsel vom bisherigen Hash zu einer anderen GUID darf nicht
|
||||
als tatsächlicher Neustart ausgegeben werden; historische Bindungen bleiben
|
||||
historisch und werden nicht nachträglich umgedeutet.
|
||||
|
||||
## Getrennter nativer Diagnosekandidat
|
||||
|
||||
Der unexportierte [native_boot.rs](../crates/agent-windows/src/native_boot.rs)
|
||||
fragt ausschließlich einen experimentellen Kandidaten ab. Der Decoder ist auf
|
||||
**Windows 11, x86-64, Build 26300** beschränkt. Fehlendes API-Symbol, andere Builds,
|
||||
Architekturen, Rückgabelängen oder ungültige Werte bleiben `unsupported`;
|
||||
Zugangsverweigerung wird als `permission_denied` ausgewiesen. Es gibt keinen
|
||||
Fallback auf Wanduhr-/Uptime-Subtraktion oder einen Registry-Bootzähler.
|
||||
|
||||
Die Implementierung löst `NtQuerySystemInformation` und `RtlGetVersion` dynamisch
|
||||
im bereits geladenen `ntdll.dll` auf. Sie verwendet Klassenwert 90 und einen
|
||||
festen, ausgerichteten 32-Byte-Puffer. Nur Status 0, exakt 32 zurückgemeldete Bytes,
|
||||
eine nichtleere GUID aus den ersten 16 Bytes und ein passender Firmwaretyp an
|
||||
Offset 16 werden als **Kandidatenbeobachtung** akzeptiert. Der Firmwaretyp wird
|
||||
zusätzlich mit `GetFirmwareType` gelesen. Andere Pufferinhalte werden nicht
|
||||
exportiert. Der Kandidat wird nicht aus einem Zeitwert berechnet.
|
||||
|
||||
Dabei sind API-Nachweis und Interpretation klar getrennt:
|
||||
|
||||
- Microsoft dokumentiert den allgemeinen dynamisch aufzulösenden
|
||||
`NtQuerySystemInformation`-Einstieg, warnt aber vor Änderungen interner
|
||||
Strukturen und nennt **keinen öffentlichen Vertrag für Klasse 90 und deren
|
||||
BootIdentifier-Layout**. Die hier gewählte Feldinterpretation ist deshalb
|
||||
ausdrücklich eine zu qualifizierende Hypothese, keine allgemeine Windowszusage.
|
||||
[Microsoft: NtQuerySystemInformation](https://learn.microsoft.com/en-us/windows/win32/api/winternl/nf-winternl-ntquerysysteminformation).
|
||||
- Die WDK-Dokumentation beschreibt die Versionsstruktur von `RtlGetVersion`;
|
||||
sie garantiert damit nicht selbst einen unterstützten user-mode Boot-Identifier
|
||||
aus `ntdll`. Fehlende Exporte werden verweigert.
|
||||
[Microsoft: RtlGetVersion](https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/nf-wdm-rtlgetversion).
|
||||
- `GetFirmwareType` ist eine dokumentierte lokale Win32-Abfrage. Ihr Abgleich
|
||||
prüft die Plausibilität eines Feldes; er beweist weder die GUID-Semantik noch
|
||||
deren Lebenszyklus.
|
||||
[Microsoft: GetFirmwareType](https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-getfirmwaretype).
|
||||
|
||||
Auch zwei gleiche Kandidatenwerte bleiben `candidate_unqualified`. Weder
|
||||
`job_binding_qualified` noch `public_class_90_abi_documented` werden dadurch wahr.
|
||||
|
||||
## Vorbereitete LocalService-Probe, noch nicht ausgeführt
|
||||
|
||||
[boot_probe.rs](../deploy/windows/boot_probe.rs) ist ein eigenständiges
|
||||
SCM-Diagnoseprogramm, kein zusätzlicher RMM-Agent. Es akzeptiert ausschließlich
|
||||
seinen eigenen Serviceaufruf, prüft den tatsächlichen Prozess als LocalService
|
||||
`S-1-5-19`, verwirft Thread-Impersonation und aktivierte Administratorrolle und
|
||||
schreibt zwei begrenzte Kandidatenbeobachtungen in einen neuen privaten Fall.
|
||||
Ein Administrator-Konsolenaufruf ersetzt diesen Nachweis nicht.
|
||||
|
||||
[BootIdentifierProbe.ps1](../deploy/windows/BootIdentifierProbe.ps1) bereitet
|
||||
gehashte Artefakte vor und kann später ausdrücklich einen eigenen temporären
|
||||
Manual-/LocalService-Dienst anlegen. Diese SCM-Registrierung ist ausschließlich
|
||||
Bootstrap für die Probe; es werden keine Registry-Bootzähler, permanenten
|
||||
Agent-/Helperdienste, Zeiteinstellungen, Privilegien oder Truststores verändert.
|
||||
Create-only Intents verhindern wiederholtes Starten nach unklarem Reply.
|
||||
`Readback` liest nur; `Cleanup` entfernt ausschließlich den gebundenen, bereits
|
||||
beendeten Probedienst. Alte Fälle und Berichte bleiben erhalten.
|
||||
|
||||
Zwei unabhängig gestartete frische Fälle könnten später Prozessunabhängigkeit
|
||||
beobachtbar machen. Auch das ersetzt weder einen tatsächlichen genehmigten
|
||||
OS-Reboot noch den noch fehlenden Nachweis der behaupteten Zeitsprungsemantik.
|
||||
Diese Schritte sind hier **geplant, nicht ausgeführt**. Ein produktiver Wechsel
|
||||
ist dadurch nicht freigegeben.
|
||||
|
||||
## Tatsächlich ausgeführte Prüfungen und eingefrorene Quellen
|
||||
|
||||
Ein lokaler Decoder-/Fehlerpfadtest bestand ohne Ignorieren: Status, Länge,
|
||||
Firmware-Abweichung, GUID-Byteordnung und leere GUID führen nicht zu einer
|
||||
Jobqualifikation. Windows-GNU-Clippy aller Targets mit `-D warnings`, Release-Link
|
||||
und PowerShell-Parser bestanden. Die resultierende Windows-EXE wurde nicht
|
||||
nativ ausgeführt. Private Qualifikation:
|
||||
`devstate/windows-boot-probe/qualification.json`.
|
||||
|
||||
| Quelle | SHA-256 |
|
||||
| --- | --- |
|
||||
| `crates/agent-windows/src/native_boot.rs` | `4f4dfcce2ec57b7f901dec878ec19f985f6d86379ec90ef7b582be8218eda18f` |
|
||||
| `deploy/windows/boot_probe.rs` | `f150fc81b4a5f3d9cfdc5f83ec96209a315bc72d2170d04ec59f899f01c34fe8` |
|
||||
| `deploy/windows/BootIdentifierProbe.ps1` | `60b6787ab77caebbbea4b39689dd9b80cd618517f9292ec8ca9c1ba8ac3bd539` |
|
||||
|
||||
Der eigenständige Release-Link hat SHA-256
|
||||
`7cd57577e8a75b408c9119a6f2f2bf325c0a8978c3f1be1800f254088cfeeb9e`.
|
||||
Das ist ein Buildnachweis, kein nativer Boot- oder Reboot-Abnahmenachweis.
|
||||
@@ -0,0 +1,155 @@
|
||||
# Read-only Helper-Peer-Kontrollen und SDK-Diagnose
|
||||
|
||||
Stand 2026-11-14: **Implementiert, lokal gebaut und quellgeprüft; native
|
||||
Vorbereitung und Administratorkontrolle bestanden.** Die positive Verbindung
|
||||
des tatsächlichen Agenten ist weiterhin offen: der laufende Agent schrieb nur
|
||||
`HELPER_NOT_AVAILABLE`. Ein laufender SYSTEM-Helper allein belegt keine
|
||||
funktionierende gegenseitige Peerprüfung. Der neue Kontrollbuild ersetzt weder
|
||||
die alte native 21+6-Unitqualifikation noch eine positive Agent-Pipeabnahme.
|
||||
|
||||
Der neue `helper_peer_controls.py` bindet 60 vollständige Build-/Runnerquellen
|
||||
und erstellt einen eigenen Manifest. Windows-GNU-Alltargets-Clippy mit
|
||||
`-D warnings`, Release-Link, vier lokale Reporting-/Create-once-Guards und
|
||||
PowerShell-Parser einschließlich des gemeinsamen speicherinternen Guards
|
||||
bestanden. Der qualifizierte lokale
|
||||
Fall ist `build-40f9d096-8532-45a3-b362-62b4983569bc`; sein EXE-SHA256 lautet
|
||||
`c25243ff6af4d06c578840c929788d74657377a520b856a7fd96791e52bf406e`.
|
||||
Der native Kontrollfall ist `603c2f9d-a2aa-42cb-b113-ad484cac5b7a`.
|
||||
Vier tatsächliche Windows-PowerShell5.1-Speicherproben der verwendeten ACL-
|
||||
Konstruktoren bestanden mit exakten Masken. Die anschließende Vorbereitung
|
||||
erstellte nur den geschützten eigenen Kontrollfall; keine RMM-Wirkung.
|
||||
Die Administratorkontrolle (PID9520, echte aktivierte Administratorgruppe,
|
||||
keine Agent-Service-SID) erhielt beim rohen Pipeöffnen `ACCESS_DENIED`5.
|
||||
Sie hat keinen SDK-Selbstcheck benutzt. Originale Agent-/Helperprozesse5140/6240,
|
||||
Konfiguration, Schlüsselmetadaten, private Helperdateimetadaten, Serverflags und
|
||||
Jobzähler blieben erhalten: Windows0/0/0/0, Linux30/30/26/0.
|
||||
LocalService- und Parent-/Childdiagnose sind noch nicht ausgeführt.
|
||||
|
||||
Der frühere Fall `4a60d264…` bleibt vor jedem Kontrolldienststart fehlgeschlagen.
|
||||
Nach einem verlorenen SSH-Reply bei der Stagingprüfung wurden ausschließlich
|
||||
die bereits übertragenen Hashes und das Fehlen eines entfernten Kontrollfalls
|
||||
gelesen. Erst dann wurde die noch nicht erreichte erste Fallvorbereitung
|
||||
fortgesetzt. Diese scheiterte beim ACL-Konstruktor: Ein leerer PowerShell-
|
||||
`if`-Zweig ergab `$null`, Arrayaddition erzeugte einen Null-SID-Eintrag für das
|
||||
Controllerverzeichnis. Exakte speicherinterne Windows5-Proben reproduzierten
|
||||
den Fehler; allgemeine/nestende Konstruktoraufrufe ohne diesen Nulleintrag
|
||||
bestanden. Der Fix normalisiert ausschließlich leere Collections und verweigert
|
||||
weiterhin ungültige einzelne SIDs. Alter Teilfall und alte Artefakte bleiben
|
||||
erhalten; der korrigierte Lauf hat einen neuen Manifest und neuen Fall.
|
||||
|
||||
## Ausschließlich feste interne Probeoperation
|
||||
|
||||
`examples/helper_peer_controls.rs` enthält drei getrennte Kontrollarten:
|
||||
|
||||
1. Ein Bootstrap-Administrator sendet einen **rohen**, gültig gerahmten
|
||||
`Probe {}`-Call. Der SDK-Selbstcheck wird absichtlich nicht benutzt und daher
|
||||
niemals als serverseitige Ablehnung gewertet.
|
||||
2. Ein kurzlebiger eigener Dienst `RmmDiscoveryPeerControl` läuft als
|
||||
LocalService mit seiner eigenen enabled Service-SID. Der tatsächliche Token
|
||||
muss User-SID19, seine eigene Service-SID und keine Agent-Service-SID enthalten.
|
||||
Auch dieser Akteur sendet nur den rohen Probe-Frame. Es werden weder Pin noch
|
||||
bestehende DACLs gelockert, um ihm eine Verbindung zu ermöglichen.
|
||||
3. Der ausdrücklich erlaubte eigene SYSTEM-Dienst `RmmDiscoveryPeerParent`
|
||||
bindet den tatsächlichen laufenden Agenten über festen SCM-Namen, PID,
|
||||
Prozessgeburtszeit, gehaltenes Prozesshandle und Imagepfad/-hash. Er fordert
|
||||
ausschließlich ProcessQueryLimited/Synchronize und am Originaltoken
|
||||
Query/Duplicate an. Ein duplizierter PRIMARYtoken startet nur dieselbe feste
|
||||
Kontroll-EXE mit `--agent-child <Fall-UUID>`, ohne Shell, freie Argumente,
|
||||
Profilimport, SeDebug oder eigene Privileg-/DACLänderungen. Die Erzeugung mit
|
||||
`CreateProcessAsUserW` und `STARTUPINFOEX/JOB_LIST` bindet den Child bereits
|
||||
atomar an den vorher konfigurierten eigenen Kill-on-close-Job mit genau einem
|
||||
erlaubten Prozess; es gibt keine nachträgliche Zuweisungslücke. Der dauerhafte
|
||||
Child-Create-Intent steht vor dem API-Aufruf, die tatsächliche Jobmitgliedschaft
|
||||
wird vor Resume geprüft. Die API kann ihre notwendigen Privilegien ausschließlich
|
||||
während dieses Aufrufs am eigenen SYSTEM-Token aktivieren. Nach 20 Sekunden beendet der Controller nur
|
||||
diesen eigenen Job und prüft den unveränderten Originalagenten erneut.
|
||||
|
||||
Der Child zeichnet die tatsächliche SID19-/Agent-Service-SID-Identität auf. Er
|
||||
prüft ausschließlich seine eigene SDK-Rolle, die öffentliche Root-/Pin-ACL,
|
||||
Helper-SCM-QueryConfig/QueryStatus, Helperprozess-/TokenQuery sowie öffentliche
|
||||
Image-/Parent-ACL und Imagehash. Danach ruft er das unveränderte SDK mit einer
|
||||
Probe auf. Aufgezeichnet werden nur begrenzte statische SDK-Fehlercodes und
|
||||
unmittelbar bei den separaten WinAPI-Prechecks gewonnene numerische Fehlercodes.
|
||||
Keine privaten Tokenhandles, Schlüssel, Agentdateien oder privaten Ledgerbytes
|
||||
werden gelesen, exportiert oder geloggt. Dies ermöglicht die Eingrenzung eines
|
||||
fehlgeschlagenen Client-Sicherheitschecks ohne Änderung des tatsächlichen Agenten.
|
||||
Kontrolle3 bleibt **diagnostic_only**: Ein SDK-Fehler wird nicht zu einer
|
||||
unbeobachteten serverseitigen Fehlerklasse umbenannt. Jede erhaltene Antwort des
|
||||
Helpers ist für diesen fremden PID-/Image-Child ein Testfehler.
|
||||
|
||||
## Beweis- und Cleanupgrenzen
|
||||
|
||||
Nur `ACCESS_DENIED` beim Öffnen oder eine geschlossene Pipe nach Kontakt mit der
|
||||
exakten ursprünglichen Helper-PID gelten bei den rohen Kontrollen als negative
|
||||
Verbindung. BUSY, Timeout, irgendeine Antwort oder SDK-Selbstverweigerung sind
|
||||
keine positive Negativabnahme. Die eigene Tokenrolle und der konkrete Fall müssen
|
||||
zum gespeicherten nativen Ergebnis passen.
|
||||
|
||||
Controllerbelege und Intents liegen in einem ausschließlich für SYSTEM und
|
||||
Administratoren schreibbaren Unterordner. Die übrigen Fallverzeichnisse sind für
|
||||
Agent-/Control-SID nur lesbar. Bootstrap erstellt vor dem ersten Akteurstart genau
|
||||
die festen Ausgabe-Leaves mit SYSTEM-/Admin-Owner: Controlausgaben sind ausschließlich
|
||||
für die eigene Control-SID, Childausgaben ausschließlich für die tatsächliche
|
||||
Agent-SID schreibbar. Keine dieser Rollen erhält gegenseitige Writerrechte oder
|
||||
Directory-Create-Rechte; SID19 kann dadurch kein Owner-WRITE_DAC an selbst erzeugten
|
||||
Reports erlangen. Native Ausgabe öffnet nur den vorerstellten leeren Leaf, validiert
|
||||
seinen Pin und überschreibt keinen vorhandenen Beleg. Readback prüft Owner und
|
||||
exakte Writerrolle vor dem JSONlesen und benennt Childausgaben ausdrücklich als
|
||||
`agent_token_assertion`, niemals als unabhängigen SYSTEM-Beweis.
|
||||
|
||||
Der Runner vergleicht vor und nach jedem Schritt ursprüngliche Agent-/Helper-PID,
|
||||
Prozessgeburt, Konto, Image, Konfiguration und öffentliche Helperpin-/Policyhashes.
|
||||
Private Helperdateien und der Geräteschlüssel werden nur anhand ihrer Metadaten
|
||||
verglichen; es erfolgt keine Zeilenabfrage des privaten Helperledgers. Windows-
|
||||
und Linux-Jobzähler sowie Serverflags müssen unverändert bleiben. Policyallowlist
|
||||
bleibt leer, `enable_effects=false`, `allow_reboot=false`, Uhr und Fähigkeiten
|
||||
bleiben geschlossen. Es gibt keinen Execute-, Snapshot- oder Applyaufruf und
|
||||
keinen SCM-Fixturejob.
|
||||
|
||||
Vor jeder nativen Phase steht lokal und remote ein create-only Intent. Ein
|
||||
verlorener SSH-Ausgang erlaubt ausschließlich `readback --id <derselbe Fall>`.
|
||||
Der Runner wiederholt keinen Dienst-/Childstart. `readback` liest ausschließlich;
|
||||
es erzeugt remote keine Intents, ACLänderungen oder Dienstlöschungen. Nur als Teil
|
||||
der Startphase oder durch die gesonderte explizite `cleanup`-Phase löscht der Runner
|
||||
seine eigenen exakt gebundenen bereits gestoppten Testdienste nach dauerhaftem Cleanupintent;
|
||||
bestehende Agent-/Helperdienste werden nicht gestoppt, neu gestartet oder verändert.
|
||||
Aktive Testdienste werden nach dem begrenzten Readbackfenster erhalten und
|
||||
explizit als unvollständig gemeldet.
|
||||
|
||||
Die fünf Sekunden begrenzen Pipe-Frame-I/O; synchrone SCM-/Datei-/Tokenabfragen
|
||||
haben dadurch keine harte Gesamtlaufzeitgrenze. Der Child hat den genannten
|
||||
separaten Prozess-Job; für einen im synchronen Vorlauf hängenden temporären
|
||||
SYSTEM-Elterndienst ist gegebenenfalls ein eigener, eng geprüfter Cleanupschritt
|
||||
nötig. Diese Grenze darf nicht als nachgewiesener harter Diensttimeout oder als
|
||||
vollständig abgeschlossene native Abnahme dargestellt werden.
|
||||
|
||||
Geplant, **nicht ausgeführt**: eigener neuer `prepare --manifest … --helper-case …`
|
||||
und anschließend die getrennten Phasen `admin`, `service`, `parent` mit derselben
|
||||
Kontrollfall-ID. Der bestehende tatsächliche Helperfall, aktuelle Runtimeindex
|
||||
und deren Hashes sind Pflicht; der Runner übernimmt keine fremden PID-/Imagewerte.
|
||||
Root führt diese Phasen erst nach unabhängigem Review aus. Die
|
||||
WebUI-Genehmigungsgrenze bleibt für sämtliche tatsächlichen RMM-Jobs unverändert.
|
||||
|
||||
Die atomare Jobliste und ihre Handlelebensdauer folgen
|
||||
[UpdateProcThreadAttribute](https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-updateprocthreadattribute);
|
||||
Form und Aufrufflag folgen
|
||||
[STARTUPINFOEXW](https://learn.microsoft.com/en-us/windows/win32/api/winbase/ns-winbase-startupinfoexw)
|
||||
und [CreateProcessAsUserW](https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessasuserw).
|
||||
Die vorherige ungestartete Kontrollversion mit nachträglicher Jobzuweisung bleibt
|
||||
historisch erhalten und ist für die native Parentphase nicht freigegeben.
|
||||
|
||||
Die erste tatsächliche Prepare-Ausführung des vorherigen Quellstands stoppte im
|
||||
Fall `4a60d264…` vor jedem SCM-/Kontrollstart. Die unabhängige WindowsPS5-
|
||||
Speicherprobe reproduzierte den konkreten Fehler: `else {@()}` lieferte bei der
|
||||
Controller-Verzeichnis-Leserliste `$null`; Array-Plus fügte daraus eine dritte,
|
||||
ungültige Null-SID nach SYSTEM/Administratoren an. Der allgemeine Fünfargument-
|
||||
Konstruktor und auch die verschachtelte SID-Konstruktion bestanden separat alle
|
||||
sechs Rollen-/Inheritancekombinationen und sind keine nachgewiesene Ursache.
|
||||
|
||||
Der neue Quellstand normalisiert nur Null-**Collections** vor der Identitätsliste
|
||||
zu leeren Arrays; einzelne ungültige SIDwerte werden weiterhin verweigert.
|
||||
`Protect` und der speicherinterne Guard benutzen dieselben `ControlIdentities`-
|
||||
und typisierten `ControlRule`-Funktionen. Der echte lokale pwsh7-Test mit leerer
|
||||
IF-Pipeline bestand; die reine WindowsPS5-Konstruktorphase `memory-guard` ist für
|
||||
Root vorbereitet, noch kein behauptetes natives Ergebnis. Der alte partielle
|
||||
Fall bleibt erhalten und wird nicht mit geänderter Quelle erneut vorbereitet.
|
||||
Reference in New Issue
Block a user