//! Read-only Windows APIs. The kernel's recorded startup time identifies the boot. use anyhow::{Context, Result, ensure}; use chrono::{DateTime, Utc}; use serde_json::{Value, json}; use sha2::{Digest, Sha256}; use std::{ffi::c_void, os::windows::ffi::OsStrExt, path::Path, ptr, time::Duration}; use windows_sys::Win32::{ Foundation::LocalFree, Security::{ self, ACCESS_ALLOWED_ACE, ACL, Authorization::{ConvertSidToStringSidW, GetNamedSecurityInfoW, SE_FILE_OBJECT}, DACL_SECURITY_INFORMATION, OWNER_SECURITY_INFORMATION, }, Storage::FileSystem::{FILE_ATTRIBUTE_REPARSE_POINT, GetDiskFreeSpaceExW}, System::{Registry::*, SystemInformation::*}, }; pub fn wide(value: impl AsRef) -> Vec { value.as_ref().encode_wide().chain(Some(0)).collect() } fn sid_string(sid: *mut c_void) -> Result { let mut text = ptr::null_mut(); // SAFETY: SID was returned by the Windows security API; API allocates text. ensure!( unsafe { ConvertSidToStringSidW(sid, &mut text) } != 0, "SID_CONVERSION" ); let mut len = 0; unsafe { while *text.add(len) != 0 { len += 1; } } let result = String::from_utf16(unsafe { std::slice::from_raw_parts(text, len) })?; unsafe { LocalFree(text.cast()); } Ok(result) } /// Verify the actual SCM process token; an administrator probe cannot stand in /// for this check. No account switching or SYSTEM fallback exists. pub fn require_local_service() -> Result<()> { use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle}; use windows_sys::Win32::System::Threading::{GetCurrentProcess, OpenProcessToken}; let mut token = ptr::null_mut(); ensure!( unsafe { OpenProcessToken(GetCurrentProcess(), Security::TOKEN_QUERY, &mut token) } != 0, "SERVICE_TOKEN_REQUIRED" ); let token = unsafe { OwnedHandle::from_raw_handle(token) }; // Native structures require alignment, even though GetTokenInformation // accepts a void pointer. Allocate pointer-aligned storage, with fixed cap. let mut storage = vec![0usize; 256]; let mut size = 0; ensure!( unsafe { Security::GetTokenInformation( token.as_raw_handle(), Security::TokenUser, storage.as_mut_ptr().cast(), (storage.len() * std::mem::size_of::()) as u32, &mut size, ) } != 0, "SERVICE_TOKEN_USER" ); let user = unsafe { &*storage.as_ptr().cast::() }; ensure!( sid_string(user.User.Sid)? == "S-1-5-19", "LOCAL_SERVICE_REQUIRED" ); // A native SCM probe showed LocalService's unfiltered service token reports // TokenElevation=1, type=Default, while SID19 has no enabled administrator // membership. UAC elevation alone is not an account/administrator check. // Reject thread impersonation before querying effective membership. use windows_sys::Win32::{ Foundation::{ERROR_NO_TOKEN, GetLastError}, System::Threading::{GetCurrentThread, OpenThreadToken}, }; let mut thread_token = ptr::null_mut(); if unsafe { OpenThreadToken( GetCurrentThread(), Security::TOKEN_QUERY, 1, &mut thread_token, ) } != 0 { let _thread_token = unsafe { OwnedHandle::from_raw_handle(thread_token) }; anyhow::bail!("IMPERSONATED_EXECUTOR_FORBIDDEN"); } ensure!( unsafe { GetLastError() } == ERROR_NO_TOKEN, "THREAD_TOKEN_UNVERIFIED" ); let mut admin_sid = [0usize; 16]; let mut admin_size = std::mem::size_of_val(&admin_sid) as u32; ensure!( unsafe { Security::CreateWellKnownSid( Security::WinBuiltinAdministratorsSid, ptr::null_mut(), admin_sid.as_mut_ptr().cast(), &mut admin_size, ) } != 0, "ADMINISTRATOR_SID_QUERY" ); let mut admin_member = 0; ensure!( unsafe { Security::CheckTokenMembership( ptr::null_mut(), admin_sid.as_mut_ptr().cast(), &mut admin_member, ) } != 0 && admin_member == 0, "ADMINISTRATOR_EXECUTOR_FORBIDDEN" ); Ok(()) } pub fn service_sid() -> Result { let account = wide(format!("NT SERVICE\\{}", crate::SERVICE_NAME)); let mut sid_len = 0; let mut domain_len = 0; let mut use_type = 0; unsafe { Security::LookupAccountNameW( ptr::null(), account.as_ptr(), ptr::null_mut(), &mut sid_len, ptr::null_mut(), &mut domain_len, &mut use_type, ); } ensure!( sid_len > 0 && sid_len <= 256 && domain_len <= 256, "SERVICE_SID_REQUIRED" ); let mut sid = vec![0u8; sid_len as usize]; let mut domain = vec![0u16; domain_len as usize]; ensure!( unsafe { Security::LookupAccountNameW( ptr::null(), account.as_ptr(), sid.as_mut_ptr().cast(), &mut sid_len, domain.as_mut_ptr(), &mut domain_len, &mut use_type, ) } != 0, "SERVICE_SID_LOOKUP" ); sid_string(sid.as_mut_ptr().cast()) } pub fn private_path(path: &Path, directory: bool) -> Result<()> { use std::os::windows::fs::MetadataExt; let metadata = std::fs::symlink_metadata(path)?; ensure!( metadata.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT == 0 && metadata.is_dir() == directory, "PRIVATE_PATH_TYPE" ); let allowed = [ "S-1-5-18".to_owned(), "S-1-5-32-544".to_owned(), service_sid()?, ]; let name = wide(path); let mut owner = ptr::null_mut(); let mut dacl: *mut ACL = ptr::null_mut(); let mut descriptor = ptr::null_mut(); // SAFETY: API writes pointers into one allocated descriptor, released below. let status = unsafe { GetNamedSecurityInfoW( name.as_ptr(), SE_FILE_OBJECT, OWNER_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION, &mut owner, ptr::null_mut(), &mut dacl, ptr::null_mut(), &mut descriptor, ) }; ensure!(status == 0, "PRIVATE_PATH_SECURITY"); let result = (|| { ensure!( !owner.is_null() && !dacl.is_null(), "PRIVATE_PATH_NULL_DACL" ); let owner = sid_string(owner)?; ensure!( allowed.contains(&owner) || (!directory && owner == "S-1-5-19"), "PRIVATE_PATH_OWNER" ); ensure!(unsafe { (*dacl).AceCount } > 0, "PRIVATE_PATH_EMPTY_DACL"); for n in 0..unsafe { (*dacl).AceCount } { let mut ace = ptr::null_mut(); ensure!( unsafe { Security::GetAce(dacl, u32::from(n), &mut ace) } != 0, "PRIVATE_PATH_ACE" ); let ace = unsafe { &*ace.cast::() }; ensure!( ace.Header.AceType == 0 && usize::from(ace.Header.AceSize) >= std::mem::size_of::(), "PRIVATE_PATH_ACE_TYPE" ); let sid = ptr::addr_of!(ace.SidStart).cast_mut().cast(); ensure!( allowed.contains(&sid_string(sid)?), "PRIVATE_PATH_BROAD_ACL" ); } Ok(()) })(); unsafe { LocalFree(descriptor.cast()); } result } fn registry_string(name: &str) -> Result { let key = wide("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion"); let value_name = wide(name); let mut bytes = vec![0u16; 2048]; let mut size = (bytes.len() * 2) as u32; let status = unsafe { RegGetValueW( HKEY_LOCAL_MACHINE, key.as_ptr(), value_name.as_ptr(), RRF_RT_REG_SZ, ptr::null_mut(), bytes.as_mut_ptr().cast(), &mut size, ) }; ensure!(status == 0, "OS_REGISTRY {name} (Win32 {status})"); ensure!( size >= 2 && size % 2 == 0 && size as usize <= bytes.len() * 2, "OS_REGISTRY_SIZE {name}" ); String::from_utf16(&bytes[..size as usize / 2 - 1]) .with_context(|| format!("OS_REGISTRY_ENCODING {name}")) } fn os_inventory(read: impl Fn(&str) -> Result) -> Result<(String, Value)> { let product = read("ProductName")?; let build = read("CurrentBuildNumber")?; // Older Windows releases can omit DisplayVersion. Both version labels are // optional; the product and build still identify the OS without either. let version = |name| read(name).ok().filter(|s| !s.trim().is_empty()); let display = version("DisplayVersion"); let release = if display.is_none() { version("ReleaseId") } else { None }; let os = match (&display, &release) { (Some(display), _) => format!("{product}; DisplayVersion={display}; Build={build}"), (None, Some(release)) => format!("{product}; ReleaseId={release}; Build={build}"), (None, None) => format!("{product}; Build={build}"), }; let mut data = json!({"product_name":product,"display_version":display,"build":build}); if let Some(release) = release { data["release_id"] = json!(release); } Ok((os, data)) } pub(crate) fn computer_name(format: COMPUTER_NAME_FORMAT) -> Result { let mut name = [0u16; 256]; let mut len = name.len() as u32; ensure!( unsafe { GetComputerNameExW(format, name.as_mut_ptr(), &mut len) } != 0 && len > 0 && (len as usize) < name.len(), "HOSTNAME_QUERY" ); Ok(String::from_utf16(&name[..len as usize])?) } fn install_date() -> Option> { let key = wide(r"SOFTWARE\Microsoft\Windows NT\CurrentVersion"); let name = wide("InstallDate"); let mut seconds = 0_u32; let mut bytes = size_of::() as u32; let status = unsafe { RegGetValueW(HKEY_LOCAL_MACHINE,key.as_ptr(),name.as_ptr(),RRF_RT_REG_DWORD, ptr::null_mut(),ptr::from_mut(&mut seconds).cast(),&mut bytes) }; (status == 0 && bytes as usize == size_of::() && seconds > 0) .then(|| DateTime::from_timestamp(i64::from(seconds), 0)) .flatten().filter(|time| *time <= Utc::now()) } pub fn snapshot() -> Result { snapshot_with_boot(None) } fn disk_space(root: &[u16]) -> Option<(u64, u64)> { let (mut available, mut total) = (0, 0); (unsafe { GetDiskFreeSpaceExW(root.as_ptr(), &mut available, &mut total, ptr::null_mut()) } != 0 && total > 0 && available <= total).then_some((available, total)) } fn fixed_volumes(system: &str, available: u64, total: u64) -> Vec { use windows_sys::Win32::Storage::FileSystem::{GetDriveTypeW, GetLogicalDrives}; const DRIVE_FIXED: u32 = 3; let mask = unsafe { GetLogicalDrives() }; let mut rows = vec![json!({"name":system,"free_bytes":available,"total_bytes":total})]; for letter in b'A'..=b'Z' { if mask & (1 << (letter - b'A')) == 0 { continue; } let name = format!("{}:", char::from(letter)); if name.eq_ignore_ascii_case(system) { continue; } let root = wide(format!("{name}\\")); if unsafe { GetDriveTypeW(root.as_ptr()) } != DRIVE_FIXED { continue; } // Retain an identified but unreadable volume without claiming zero usage. let sizes = disk_space(&root); rows.push(json!({"name":name,"free_bytes":sizes.map(|s| s.0),"total_bytes":sizes.map(|s| s.1)})); } rows } pub fn snapshot_with_boot(booted_at: Option>) -> Result { let started = Utc::now(); let hostname = computer_name(ComputerNameDnsHostname)?; let system = std::env::var("SystemDrive").context("SYSTEM_DRIVE")?.to_ascii_uppercase(); let (available, total) = disk_space(&wide(format!("{system}\\"))).context("VOLUME_QUERY")?; let volumes = fixed_volumes(&system, available, total); let (os, mut os_data) = os_inventory(registry_string)?; os_data["installed_at"] = json!(install_date()); os_data["booted_at"] = json!(booted_at); let completed = Utc::now(); let mut snapshot = json!({"os":os,"hostname":hostname,"architecture":std::env::consts::ARCH,"root_total_bytes":total,"root_available_bytes":available,"root_available_inodes":null, "collection_started_at":started,"collection_completed_at":completed, "observations":[ {"scope":"windows.os","source_id":"windows.registry:CurrentVersion;GetComputerNameExW;Kernel-General/12","observed_at":completed,"quality":"valid","completeness":"partial","truncated":false,"error_code":null,"data":os_data}, {"scope":"windows.volumes","source_id":"windows.win32:GetLogicalDrives;GetDriveTypeW;GetDiskFreeSpaceExW","observed_at":completed,"quality":"valid","completeness":"partial","truncated":false,"error_code":null,"data":{"system_volume_total_bytes":total,"system_volume_available_bytes":available,"drives":volumes}}, {"scope":"windows.inodes","source_id":"windows.win32","observed_at":completed,"quality":"unsupported","completeness":"unknown","truncated":false,"error_code":"NOT_APPLICABLE","data":null} ]}); snapshot["observations"] .as_array_mut() .context("INVENTORY_OBSERVATIONS")? .extend(crate::inventory::observations()); snapshot["collection_completed_at"] = json!(Utc::now()); Ok(snapshot) } pub async fn boot_identity() -> Result<(String, DateTime)> { // Fixed passive query only. Never interpolates a job or caller-supplied code. // Avoid Win32_Product: it can cause MSI consistency checks and repairs. let executable = Path::new(&std::env::var("SystemRoot")?) .join("System32/WindowsPowerShell/v1.0/powershell.exe"); let mut command = tokio::process::Command::new(executable); // LastBootUpTime is adjusted by W32Time while the machine is running. // Kernel-General records StartTime once at startup. Use the newest record // in log order and its invariant UTC payload, not its localized message. const START_TIME: &str = r#" $ErrorActionPreference = 'Stop' $filter = @{LogName='System'; ProviderName='Microsoft-Windows-Kernel-General'; Id=12} $event = Get-WinEvent -FilterHashtable $filter -MaxEvents 1 if ($event.ProviderId -ne [Guid]'a68ca8b7-004f-d7b6-a698-07e2de0f1f5d') { throw 'BOOT_PROVIDER' } $nodes = @(([xml]$event.ToXml()).Event.EventData.Data | Where-Object { $_.Name -ceq 'StartTime' }) if ($nodes.Count -ne 1) { throw 'BOOT_START_TIME' } [Xml.XmlConvert]::ToDateTimeOffset($nodes[0].InnerText).UtcTicks.ToString([Globalization.CultureInfo]::InvariantCulture) "#; command.args(["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", START_TIME]); command.kill_on_drop(true); let output = tokio::time::timeout(Duration::from_secs(15), command.output()).await??; ensure!( output.status.success() && output.stdout.len() <= 128 && output.stderr.is_empty(), "BOOT_TIME_QUERY" ); let text = std::str::from_utf8(&output.stdout)?.trim(); ensure!( (17..=19).contains(&text.len()) && text.bytes().all(|b| b.is_ascii_digit()), "BOOT_TIME_FORMAT" ); // Preserve the wire ID when the old CIM value equals the recorded startup time. let mut bytes: [u8; 16] = Sha256::digest(format!("rmm.windows.boot.cim.ticks.v1:{text}")) .as_slice()[..16] .try_into()?; bytes[6] = (bytes[6] & 15) | 0x80; bytes[8] = (bytes[8] & 63) | 0x80; let ticks = text.parse::()?.checked_sub(621_355_968_000_000_000).context("BOOT_EPOCH")?; let time = DateTime::from_timestamp(ticks.div_euclid(10_000_000), ticks.rem_euclid(10_000_000) as u32 * 100) .context("BOOT_EPOCH")?; Ok((uuid::Uuid::from_bytes(bytes).to_string(),time)) } pub async fn boot_id() -> Result { boot_identity().await.map(|(id, _)| id) } #[cfg(test)] mod tests { fn os_fixture(display: Option<&str>, release: Option<&str>) -> (String, serde_json::Value) { super::os_inventory(|name| { match name { "ProductName" => Some("Windows 10 Enterprise LTSC"), "CurrentBuildNumber" => Some("17763"), "DisplayVersion" => display, "ReleaseId" => release, _ => panic!("unexpected registry value: {name}"), } .map(str::to_owned) .ok_or_else(|| anyhow::anyhow!("missing {name}")) }) .unwrap() } #[test] fn os_inventory_prefers_display_version() { let (os, data) = os_fixture(Some("22H2"), Some("2009")); assert!(os.contains("DisplayVersion=22H2")); assert_eq!(data["display_version"], "22H2"); assert!(data.get("release_id").is_none()); } #[test] fn os_inventory_uses_legacy_release_id_when_display_version_is_missing() { let (os, data) = os_fixture(None, Some("1809")); assert_eq!(os, "Windows 10 Enterprise LTSC; ReleaseId=1809; Build=17763"); assert!(data["display_version"].is_null()); assert_eq!(data["release_id"], "1809"); } #[test] fn os_inventory_keeps_product_and_build_without_version_labels() { for display in [None, Some(" ")] { let (os, data) = os_fixture(display, None); assert_eq!(os, "Windows 10 Enterprise LTSC; Build=17763"); assert!(data["display_version"].is_null()); assert_eq!(data["build"], "17763"); } } #[test] fn native_inventory_has_real_windows_sources_and_no_fake_inodes() { let v = super::snapshot().unwrap(); assert!(v["root_total_bytes"].as_u64().unwrap() > 0); assert!(v["root_available_inodes"].is_null()); assert!(!v["hostname"].as_str().unwrap().is_empty()); let hardware = v["observations"] .as_array() .unwrap() .iter() .find(|o| o["scope"] == "windows.hardware") .unwrap(); assert!(hardware["data"]["memory_total_bytes"].as_u64().unwrap() > 0); assert!( hardware["data"]["logical_processors_visible"] .as_u64() .unwrap() > 0 ); assert!( v["observations"] .as_array() .unwrap() .iter() .all(|o| o["scope"].as_str().unwrap().starts_with("windows.")) ); } #[tokio::test] async fn boot_identity_survives_independent_native_queries() { assert_eq!( super::boot_id().await.unwrap(), super::boot_id().await.unwrap() ); } }