//! Passive native machine inventory. Never queries Win32_Product or executes //! uninstall commands; registry entries are evidence, not verified MSI state. use anyhow::{Result, ensure}; use chrono::Utc; use rmm_domain::inventory_document::{ CpuTimes, DeviceType, SOFTWARE_OBSERVATION_MAX_BYTES, firmware_identifier, }; use serde_json::{Value, json}; use std::{ mem::{size_of, zeroed}, ptr, time::{Duration, Instant}, }; use windows_sys::Win32::{ Foundation::{ERROR_FILE_NOT_FOUND, ERROR_NO_MORE_ITEMS, ERROR_SUCCESS, FILETIME}, System::{ Registry::*, SystemInformation::*, Threading::{GetActiveProcessorGroupCount, GetSystemTimes}, }, }; struct Registry(HKEY); impl Drop for Registry { fn drop(&mut self) { unsafe { RegCloseKey(self.0); } } } fn open(parent: HKEY, name: &str, flags: u32) -> Result { let mut key = ptr::null_mut(); let name = crate::native::wide(name); ensure!( unsafe { RegOpenKeyExW(parent, name.as_ptr(), 0, KEY_READ | flags, &mut key) } == ERROR_SUCCESS, "REGISTRY_INVENTORY_ACCESS" ); Ok(Registry(key)) } fn text(key: HKEY, name: &str) -> Result> { let name = crate::native::wide(name); let mut data = [0u16; 512]; let mut bytes = size_of::<[u16; 512]>() as u32; let result = unsafe { RegGetValueW( key, ptr::null(), name.as_ptr(), RRF_RT_REG_SZ, ptr::null_mut(), data.as_mut_ptr().cast(), &mut bytes, ) }; if result == ERROR_FILE_NOT_FOUND { return Ok(None); } ensure!( result == ERROR_SUCCESS && bytes >= 2 && bytes as usize <= size_of::<[u16; 512]>() && bytes.is_multiple_of(2), "REGISTRY_INVENTORY_STRING" ); let count = bytes as usize / 2; ensure!( data[count - 1] == 0 && !data[..count - 1].contains(&0), "REGISTRY_STRING_TERMINATION" ); Ok(Some(String::from_utf16(&data[..count - 1])?)) } #[cfg(target_arch = "x86_64")] fn non_microsoft_hypervisor() -> bool { use std::arch::x86_64::__cpuid; if __cpuid(1).ecx & (1 << 31) == 0 { return false; } let vendor = __cpuid(0x4000_0000); // The Microsoft hypervisor can also be active on physical VBS machines. [vendor.ebx, vendor.ecx, vendor.edx] != [ u32::from_le_bytes(*b"Micr"), u32::from_le_bytes(*b"osof"), u32::from_le_bytes(*b"t Hv"), ] } #[cfg(not(target_arch = "x86_64"))] fn non_microsoft_hypervisor() -> bool { false } fn classify_machine( hyper_v_host: bool, guest_hypervisor: bool, manufacturer: Option<&str>, product: Option<&str>, ) -> Option { if hyper_v_host { return Some(DeviceType::Hypervisor); } let manufacturer = manufacturer.unwrap_or_default().trim().to_ascii_lowercase(); let product = product.unwrap_or_default().trim().to_ascii_lowercase(); let virtual_firmware = [ "qemu", "vmware", "virtualbox", "xen", "parallels", "bhyve", "kvm", "virtual machine", "virtual platform", ] .iter() .any(|prefix| manufacturer.starts_with(prefix) || product.starts_with(prefix)); if guest_hypervisor || virtual_firmware { return Some(DeviceType::Virtual); } (!manufacturer.is_empty() && !product.is_empty()).then_some(DeviceType::Physical) } fn machine_type(manufacturer: Option<&str>, product: Option<&str>) -> Option { let hyper_v_host = open( HKEY_LOCAL_MACHINE, r"SYSTEM\CurrentControlSet\Services\vmms", KEY_WOW64_64KEY, ) .is_ok(); classify_machine( hyper_v_host, non_microsoft_hypervisor(), manufacturer, product, ) } fn memory_status() -> Result { let mut memory: MEMORYSTATUSEX = unsafe { zeroed() }; memory.dwLength = size_of::() as u32; ensure!( unsafe { GlobalMemoryStatusEx(&mut memory) } != 0 && memory.ullTotalPhys > 0 && memory.ullAvailPhys <= memory.ullTotalPhys && memory.dwMemoryLoad <= 100, "NATIVE_HARDWARE_QUERY" ); Ok(memory) } pub fn physical_memory() -> Option<(u64, u64)> { let memory = memory_status().ok()?; Some((memory.ullAvailPhys, memory.ullTotalPhys)) } pub fn cpu_times() -> Option { // GetSystemTimes on a multi-group machine only reports the caller's group. if unsafe { GetActiveProcessorGroupCount() } != 1 { return None; } let (mut idle, mut kernel, mut user) = ( FILETIME::default(), FILETIME::default(), FILETIME::default(), ); if unsafe { GetSystemTimes(&mut idle, &mut kernel, &mut user) } == 0 { return None; } let ticks = |time: FILETIME| (u64::from(time.dwHighDateTime) << 32) | u64::from(time.dwLowDateTime); // Windows includes idle time in the kernel counter. Some(CpuTimes { total: ticks(kernel).checked_add(ticks(user))?, idle: ticks(idle), }) } fn hardware() -> Result { let mut system: SYSTEM_INFO = unsafe { zeroed() }; unsafe { GetNativeSystemInfo(&mut system); } ensure!(system.dwNumberOfProcessors > 0, "NATIVE_HARDWARE_QUERY"); let memory = memory_status()?; let cpu_model = open( HKEY_LOCAL_MACHINE, r"HARDWARE\DESCRIPTION\System\CentralProcessor\0", KEY_WOW64_64KEY, ) .ok() .and_then(|key| text(key.0, "ProcessorNameString").ok().flatten()) .map(|name| name.trim().to_owned()) .filter(|name| !name.is_empty()); let bios = open( HKEY_LOCAL_MACHINE, r"HARDWARE\DESCRIPTION\System\BIOS", KEY_WOW64_64KEY, ) .ok(); let read = |name| { bios.as_ref() .and_then(|key| text(key.0, name).ok().flatten()) }; let manufacturer = read("SystemManufacturer").and_then(|value| firmware_identifier(&value)); let product = read("SystemProductName"); let bios_serial_number = read("SystemSerialNumber") .and_then(|value| firmware_identifier(&value)) .or_else(crate::inventory_sources::bios_serial); Ok( json!({"cpu_model":cpu_model, "logical_processors_visible":system.dwNumberOfProcessors, "memory_total_bytes":memory.ullTotalPhys,"memory_available_bytes":memory.ullAvailPhys, "memory_load_percent":memory.dwMemoryLoad, "device_type":machine_type(manufacturer.as_deref(),product.as_deref()), "manufacturer":manufacturer,"bios_serial_number":bios_serial_number}), ) } fn software() -> Result { let began = Instant::now(); let mut entries = Vec::new(); let mut entry_bytes = 0; let mut errors = 0u32; let mut scanned = 0u32; let mut truncated = false; let mut views = Vec::new(); for (view, label) in [ (KEY_WOW64_64KEY, "machine_registry_64"), (KEY_WOW64_32KEY, "machine_registry_32"), ] { views.push(label); let key = match open( HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall", view, ) { Ok(key) => key, Err(_) => { errors += 1; continue; } }; for index in 0..2048 { if began.elapsed() > Duration::from_millis(250) { truncated = true; break; } let mut name = [0u16; 256]; let mut length = name.len() as u32; let result = unsafe { RegEnumKeyExW( key.0, index, name.as_mut_ptr(), &mut length, ptr::null(), ptr::null_mut(), ptr::null_mut(), ptr::null_mut(), ) }; if result == ERROR_NO_MORE_ITEMS { break; } scanned += 1; if result != ERROR_SUCCESS || length as usize >= name.len() { errors += 1; continue; } let entry = (|| -> Result> { let name = String::from_utf16(&name[..length as usize])?; let child = open(key.0, &name, view)?; let Some(display) = text(child.0, "DisplayName")?.filter(|v| !v.is_empty()) else { return Ok(None); }; // No arbitrary path, username, uninstall string or installer // execution is inventoried. Missing version stays null. Ok(Some( json!({"display_name":display,"version":text(child.0,"DisplayVersion")?, "publisher":text(child.0,"Publisher")?,"source":label, "installation_context":"machine","installed_state":"registry_entry_only"}), )) })(); match entry { Ok(Some(entry)) => { entry_bytes += serde_json::to_vec(&entry)?.len() + 1; if entry_bytes > SOFTWARE_OBSERVATION_MAX_BYTES - 2048 { truncated = true; break; } entries.push(entry); } Ok(None) => {} Err(_) => errors += 1, } if index == 2047 { truncated = true; } } if truncated { break; } } ensure!( errors < 2 || !entries.is_empty(), "SOFTWARE_REGISTRY_UNAVAILABLE" ); Ok( json!({"entries":entries,"scanned_keys":scanned,"read_errors":errors,"truncated":truncated,"views_queried":views, "scope":"machine_registry_only","per_user_inventory":"unsupported", "msi_state_verification":"not_collected","appx_inventory":"not_collected"}), ) } /// Each provider is isolated. Missing permissions never fabricate an empty, /// complete software inventory or hide the last valid stored observation. pub fn observations() -> Vec { type Provider = fn() -> Result; [ ( "windows.hardware", "windows.win32:GetNativeSystemInfo+GlobalMemoryStatusEx+GetSystemFirmwareTable;registry:CentralProcessor,BIOS,vmms;cpuid", hardware as Provider, ), ( "windows.software", "windows.registry:HKLM.Uninstall:64+32", software as Provider, ), ("windows.interfaces", "windows.win32:GetAdaptersAddresses", crate::inventory_sources::interfaces as Provider), ("windows.users", "windows.win32:WTSEnumerateSessions", crate::inventory_sources::users as Provider), ] .into_iter() .map(|(scope, source, collect)| { let data = collect(); let observed = Utc::now(); match data { Ok(data) => { let truncated = data .get("truncated") .and_then(Value::as_bool) .unwrap_or(false); json!({"scope":scope,"source_id":source,"observed_at":observed,"quality":"valid", "completeness":"partial","truncated":truncated,"error_code":null,"data":data}) } Err(_) => json!({"scope":scope,"source_id":source,"observed_at":observed, "quality":"error","completeness":"unknown","truncated":false, "error_code":"NATIVE_PROVIDER_UNAVAILABLE","data":null}), } }) .collect() } #[cfg(test)] mod tests { use super::*; #[test] fn machine_type_distinguishes_hyper_v_hosts_from_guests() { let guest = (Some("Microsoft Corporation"), Some("Virtual Machine")); assert_eq!( classify_machine(false, false, guest.0, guest.1), Some(DeviceType::Virtual) ); assert_eq!( classify_machine(true, false, guest.0, guest.1), Some(DeviceType::Hypervisor) ); assert_eq!( classify_machine(false, false, Some("QEMU"), Some("Standard PC")), Some(DeviceType::Virtual) ); assert_eq!( classify_machine(false, true, None, None), Some(DeviceType::Virtual) ); assert_eq!( classify_machine(false, false, Some("Dell Inc."), Some("Precision")), Some(DeviceType::Physical) ); assert_eq!(classify_machine(false, false, None, None), None); } }