Files
rust-discovery/deploy/windows/boot_probe.rs
2026-11-14 04:54:20 +01:00

196 lines
6.9 KiB
Rust

//! 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()
)
}