//! Local read-only inventory providers. Each result is bounded independently. use anyhow::{Context, Result, ensure}; use rmm_domain::inventory_document::firmware_identifier; use serde_json::{Value, json}; use std::{ collections::BTreeSet, ffi::c_void, mem::size_of, net::{Ipv4Addr, Ipv6Addr}, ptr, slice, }; use windows_sys::Win32::{ Foundation::{ERROR_BUFFER_OVERFLOW, ERROR_NO_DATA, ERROR_SUCCESS}, NetworkManagement::IpHelper::*, Networking::WinSock::{ AF_INET, AF_INET6, AF_UNSPEC, SOCKADDR_IN, SOCKADDR_IN6, SOCKET_ADDRESS, }, System::{ RemoteDesktop::*, SystemInformation::{GetSystemFirmwareTable, RSMB}, }, }; pub(crate) fn bios_serial() -> Option { let length = unsafe { GetSystemFirmwareTable(RSMB, 0, ptr::null_mut(), 0) }; if !(8..=1024 * 1024).contains(&length) { return None; } let mut data = vec![0; length as usize]; if unsafe { GetSystemFirmwareTable(RSMB, 0, data.as_mut_ptr(), length) } != length { return None; } let count = u32::from_le_bytes(data[4..8].try_into().ok()?) as usize; smbios_serial(data.get(8..)?.get(..count)?) } fn smbios_serial(mut table: &[u8]) -> Option { while let Some(header) = table.get(..4) { let length = usize::from(header[1]); if length < 4 || header[0] == 127 { break; } let strings = table.get(length..)?; let end = strings.windows(2).position(|pair| pair == [0, 0])?; if header[0] == 1 { let offset = usize::from(*table.get(..length)?.get(7)?).checked_sub(1)?; let serial = strings[..end].split(|&c| c == 0).nth(offset)?; return firmware_identifier(std::str::from_utf8(serial).ok()?); } table = strings.get(end + 2..)?; } None } // Pointer fields returned by IP Helper refer into its caller-provided buffer. fn at(buffer: &[u64], pointer: *const T) -> Option<&T> { let offset = (pointer as usize).checked_sub(buffer.as_ptr() as usize)?; if offset.checked_add(size_of::())? > std::mem::size_of_val(buffer) || !pointer.is_aligned() { return None; } Some(unsafe { &*pointer }) } fn wide_name(buffer: &[u64], pointer: *const u16) -> Option { let mut text = Vec::new(); for i in 0..256 { let character = *at(buffer, pointer.wrapping_add(i))?; if character == 0 { return (!text.is_empty()).then(|| String::from_utf16_lossy(&text)); } text.push(character); } None } fn ip_address(buffer: &[u64], address: SOCKET_ADDRESS) -> Option { let sockaddr = at(buffer, address.lpSockaddr)?; match sockaddr.sa_family { AF_INET if address.iSockaddrLength >= size_of::() as i32 => { let ipv4 = at(buffer, address.lpSockaddr.cast::())?; Some(Ipv4Addr::from(unsafe { ipv4.sin_addr.S_un.S_addr }.to_ne_bytes()).to_string()) } AF_INET6 if address.iSockaddrLength >= size_of::() as i32 => { let ipv6 = at(buffer, address.lpSockaddr.cast::())?; let ip = Ipv6Addr::from(unsafe { ipv6.sin6_addr.u.Byte }); let scope = unsafe { ipv6.Anonymous.sin6_scope_id }; Some(if scope == 0 { ip.to_string() } else { format!("{ip}%{scope}") }) } _ => None, } } pub(crate) fn interfaces() -> Result { let mut bytes = 15360_u32; let mut buffer = vec![0_u64; (bytes as usize).div_ceil(8)]; let flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_INCLUDE_ALL_INTERFACES; let mut status = unsafe { GetAdaptersAddresses( u32::from(AF_UNSPEC), flags, ptr::null(), buffer.as_mut_ptr().cast(), &mut bytes, ) }; if status == ERROR_BUFFER_OVERFLOW && bytes <= 1024 * 1024 { buffer.resize((bytes as usize).div_ceil(8), 0); status = unsafe { GetAdaptersAddresses( u32::from(AF_UNSPEC), flags, ptr::null(), buffer.as_mut_ptr().cast(), &mut bytes, ) }; } if status == ERROR_NO_DATA { return Ok(json!({"entries":[],"truncated":false})); } ensure!(status == ERROR_SUCCESS, "ADAPTER_ADDRESSES"); let mut current = buffer.as_ptr().cast::(); let mut entries = Vec::new(); let mut truncated = false; let mut size = 0; while !current.is_null() && entries.len() < 128 { let adapter = at(&buffer, current).context("ADAPTER_POINTER")?; let mut next = adapter.FirstUnicastAddress.cast_const(); let mut addresses = BTreeSet::new(); for _ in 0..64 { if next.is_null() { break; } let address = at(&buffer, next).context("ADAPTER_ADDRESS_POINTER")?; if let Some(ip) = ip_address(&buffer, address.Address) { addresses.insert(ip); } next = address.Next.cast_const(); } truncated |= !next.is_null(); let name = wide_name(&buffer, adapter.FriendlyName) .or_else(|| wide_name(&buffer, adapter.Description)) .unwrap_or_else(|| { format!("Adapter {}", unsafe { adapter.Anonymous1.Anonymous.IfIndex }) }); let mac = adapter .PhysicalAddress .get(..adapter.PhysicalAddressLength as usize) .filter(|bytes| !bytes.is_empty()) .map(|bytes| { bytes .iter() .map(|byte| format!("{byte:02x}")) .collect::>() .join(":") }); let entry = json!({"name":name,"addresses":addresses,"mac":mac}); size += serde_json::to_vec(&entry)?.len() + 1; if size > 30 * 1024 { truncated = true; break; } entries.push(entry); current = adapter.Next.cast_const(); } Ok(json!({"entries":entries,"truncated":truncated || !current.is_null()})) } struct WtsMemory(*mut c_void); impl Drop for WtsMemory { fn drop(&mut self) { if !self.0.is_null() { unsafe { WTSFreeMemory(self.0) }; } } } fn session_text(id: u32, class: WTS_INFO_CLASS) -> Option { let mut text = ptr::null_mut(); let mut bytes = 0; if unsafe { WTSQuerySessionInformationW(ptr::null_mut(), id, class, &mut text, &mut bytes) } == 0 { return None; } let _guard = WtsMemory(text.cast()); if text.is_null() || !(2..=512).contains(&bytes) || bytes % 2 != 0 { return None; } let units = unsafe { slice::from_raw_parts(text, (bytes / 2) as usize) }; String::from_utf16(units.split(|c| *c == 0).next()?).ok() } pub(crate) fn users() -> Result { let mut list = ptr::null_mut(); let mut count = 0; ensure!( unsafe { WTSEnumerateSessionsW(ptr::null_mut(), 0, 1, &mut list, &mut count) } != 0, "SESSION_QUERY" ); let _guard = WtsMemory(list.cast()); let mut entries = BTreeSet::new(); let mut errors = 0; let mut truncated = count > 256; if count != 0 { ensure!(!list.is_null(), "SESSION_LIST"); for session in unsafe { slice::from_raw_parts(list, count.min(256) as usize) } { if session.SessionId == 0 || ![WTSActive, WTSConnected, WTSDisconnected].contains(&session.State) { continue; } match session_text(session.SessionId, WTSUserName) { Some(name) if !name.is_empty() => { let account = match session_text(session.SessionId, WTSDomainName) { Some(domain) if !domain.is_empty() => format!("{domain}\\{name}"), _ => name, }; if entries.len() >= 64 { truncated = true; break; } if account.len() <= 255 && !account.chars().any(char::is_control) { entries.insert(account); } else { errors += 1; } } Some(_) => {} None => errors += 1, } } } ensure!( errors == 0 || !entries.is_empty(), "SESSION_INFORMATION_UNAVAILABLE" ); Ok(json!({"entries":entries,"read_errors":errors,"truncated":truncated})) } #[cfg(test)] mod tests { use super::smbios_serial; #[test] fn reads_the_system_serial_and_rejects_incomplete_entries() { assert_eq!( smbios_serial(b"\x01\x08\x00\x00\x01\x00\x00\x02Vendor\0ABC-123\0\0").as_deref(), Some("ABC-123") ); assert_eq!( smbios_serial(b"\x01\x08\x00\x00\x01\x00\x00\x02Vendor\0ABC-123\0"), None ); } }