267 lines
9.0 KiB
Rust
267 lines
9.0 KiB
Rust
//! 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<String> {
|
|
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<String> {
|
|
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<T>(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::<T>())? > std::mem::size_of_val(buffer) || !pointer.is_aligned()
|
|
{
|
|
return None;
|
|
}
|
|
Some(unsafe { &*pointer })
|
|
}
|
|
|
|
fn wide_name(buffer: &[u64], pointer: *const u16) -> Option<String> {
|
|
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<String> {
|
|
let sockaddr = at(buffer, address.lpSockaddr)?;
|
|
match sockaddr.sa_family {
|
|
AF_INET if address.iSockaddrLength >= size_of::<SOCKADDR_IN>() as i32 => {
|
|
let ipv4 = at(buffer, address.lpSockaddr.cast::<SOCKADDR_IN>())?;
|
|
Some(Ipv4Addr::from(unsafe { ipv4.sin_addr.S_un.S_addr }.to_ne_bytes()).to_string())
|
|
}
|
|
AF_INET6 if address.iSockaddrLength >= size_of::<SOCKADDR_IN6>() as i32 => {
|
|
let ipv6 = at(buffer, address.lpSockaddr.cast::<SOCKADDR_IN6>())?;
|
|
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<Value> {
|
|
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::<IP_ADAPTER_ADDRESSES_LH>();
|
|
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::<Vec<_>>()
|
|
.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<String> {
|
|
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<Value> {
|
|
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
|
|
);
|
|
}
|
|
}
|