//! 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 = OnceLock::new(); static STATUS: AtomicUsize = AtomicUsize::new(0); fn wide(s: &str) -> Vec { 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::())]; ensure!( unsafe { GetTokenInformation( raw, TokenUser, data.as_mut_ptr().cast(), needed, &mut needed, ) } != 0, "BOOT_PROBE_USER" ); let user = unsafe { &*data.as_ptr().cast::() }; 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 = 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() ) }