196 lines
6.9 KiB
Rust
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()
|
|
)
|
|
}
|