feat: verify native Windows client probe and preserve unknown APT outcome
Rust development slice / linux (push) Failing after 7s
Rust development slice / linux (push) Failing after 7s
This commit is contained in:
@@ -0,0 +1,253 @@
|
||||
//! Read-only Windows APIs. Boot identity comes from Win32_OperatingSystem's
|
||||
//! LastBootUpTime, never from the lifetime of this agent process.
|
||||
use anyhow::{Context, Result, ensure};
|
||||
use chrono::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<std::ffi::OsStr>) -> Vec<u16> {
|
||||
value.as_ref().encode_wide().chain(Some(0)).collect()
|
||||
}
|
||||
fn sid_string(sid: *mut c_void) -> Result<String> {
|
||||
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)
|
||||
}
|
||||
pub fn service_sid() -> Result<String> {
|
||||
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::<ACCESS_ALLOWED_ACE>() };
|
||||
ensure!(
|
||||
ace.Header.AceType == 0
|
||||
&& usize::from(ace.Header.AceSize) >= std::mem::size_of::<ACCESS_ALLOWED_ACE>(),
|
||||
"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<String> {
|
||||
let key = wide("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion");
|
||||
let name = wide(name);
|
||||
let mut bytes = vec![0u16; 2048];
|
||||
let mut size = (bytes.len() * 2) as u32;
|
||||
ensure!(
|
||||
unsafe {
|
||||
RegGetValueW(
|
||||
HKEY_LOCAL_MACHINE,
|
||||
key.as_ptr(),
|
||||
name.as_ptr(),
|
||||
RRF_RT_REG_SZ,
|
||||
ptr::null_mut(),
|
||||
bytes.as_mut_ptr().cast(),
|
||||
&mut size,
|
||||
)
|
||||
} == 0,
|
||||
"OS_REGISTRY"
|
||||
);
|
||||
ensure!(
|
||||
size >= 2 && size as usize <= bytes.len() * 2,
|
||||
"OS_REGISTRY_SIZE"
|
||||
);
|
||||
Ok(String::from_utf16(&bytes[..size as usize / 2 - 1])?)
|
||||
}
|
||||
pub fn snapshot() -> Result<Value> {
|
||||
let started = Utc::now();
|
||||
let mut hostname = vec![0u16; 256];
|
||||
let mut len = hostname.len() as u32;
|
||||
ensure!(
|
||||
unsafe { GetComputerNameExW(ComputerNameDnsHostname, hostname.as_mut_ptr(), &mut len) }
|
||||
!= 0,
|
||||
"HOSTNAME_QUERY"
|
||||
);
|
||||
let hostname = String::from_utf16(&hostname[..len as usize])?;
|
||||
let volume = wide(std::env::var("SystemDrive").context("SYSTEM_DRIVE")? + "\\");
|
||||
let mut available = 0;
|
||||
let mut total = 0;
|
||||
let mut free = 0;
|
||||
ensure!(
|
||||
unsafe { GetDiskFreeSpaceExW(volume.as_ptr(), &mut available, &mut total, &mut free) } != 0,
|
||||
"VOLUME_QUERY"
|
||||
);
|
||||
ensure!(total > 0 && available <= total, "VOLUME_VALUES");
|
||||
let product = registry_string("ProductName")?;
|
||||
let display = registry_string("DisplayVersion")?;
|
||||
let build = registry_string("CurrentBuildNumber")?;
|
||||
let os = format!("{product}; DisplayVersion={display}; Build={build}");
|
||||
let completed = Utc::now();
|
||||
Ok(
|
||||
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","observed_at":completed,"quality":"valid","completeness":"partial","truncated":false,"error_code":null,"data":{"product_name":product,"display_version":display,"build":build}},
|
||||
{"scope":"windows.volumes","source_id":"windows.win32:GetDiskFreeSpaceExW","observed_at":completed,"quality":"valid","completeness":"partial","truncated":false,"error_code":null,"data":{"system_volume_total_bytes":total,"system_volume_available_bytes":available}},
|
||||
{"scope":"windows.inodes","source_id":"windows.win32","observed_at":completed,"quality":"unsupported","completeness":"unknown","truncated":false,"error_code":"NOT_APPLICABLE","data":null}
|
||||
]}),
|
||||
)
|
||||
}
|
||||
pub async fn boot_id() -> Result<String> {
|
||||
// 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);
|
||||
command.args(["-NoLogo","-NoProfile","-NonInteractive","-Command","$ErrorActionPreference='Stop'; (Get-CimInstance -ClassName Win32_OperatingSystem -Property LastBootUpTime).LastBootUpTime.ToUniversalTime().Ticks.ToString([Globalization.CultureInfo]::InvariantCulture)"]);
|
||||
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"
|
||||
);
|
||||
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;
|
||||
Ok(uuid::Uuid::from_bytes(bytes).to_string())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#[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());
|
||||
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()
|
||||
);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user