//! UNWIRED diagnostic candidate, never a job-capable BootSource. //! //! Microsoft's public NtQuerySystemInformation contract explicitly permits API //! changes and recommends dynamic lookup. It does NOT specify class90 or the //! BootIdentifier layout used below. The fixed32-byte/GUID-prefix hypothesis //! therefore remains unqualified, even when samples agree on Windows11/26300. //! No CIM timestamp, wall clock, uptime subtraction or registry counter is used. //! https://learn.microsoft.com/en-us/windows/win32/api/winternl/nf-winternl-ntquerysysteminformation //! https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/nf-wdm-rtlgetversion //! https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-getfirmwaretype use serde::Serialize; use uuid::Uuid; pub const CANDIDATE_BUILD: u32 = 26300; #[derive(Clone, Debug, Serialize)] pub struct Observation { pub source: &'static str, pub quality: &'static str, pub code: &'static str, pub windows_build: Option, pub nt_status: Option, pub returned_bytes: Option, pub candidate_identifier: Option, pub firmware_type: Option, pub job_binding_qualified: bool, pub public_class_90_abi_documented: bool, } impl Observation { fn unsupported(code: &'static str) -> Self { Self { source: "ntdll/NtQuerySystemInformation/class90/experimental32", quality: "unsupported", code, windows_build: None, nt_status: None, returned_bytes: None, candidate_identifier: None, firmware_type: None, job_binding_qualified: false, public_class_90_abi_documented: false, } } } #[cfg(any(windows, test))] fn decode(status: i32, returned: u32, bytes: [u8; 32], firmware: u32) -> Option { if status != 0 || returned != 32 || !matches!(firmware, 1 | 2) || u32::from_le_bytes(bytes[16..20].try_into().ok()?) != firmware { return None; } let id = Uuid::from_bytes_le(bytes[..16].try_into().ok()?); (!id.is_nil()).then_some(id) } /// Actual bounded native read, but no qualification/capability follows from it. pub fn observe_candidate() -> Observation { #[cfg(windows)] { windows::observe() } #[cfg(not(windows))] { Observation::unsupported("BOOT_CANDIDATE_WINDOWS_ONLY") } } #[cfg(windows)] mod windows { use super::*; use std::mem::{size_of, zeroed}; use windows_sys::Win32::System::{ LibraryLoader::{GetModuleHandleW, GetProcAddress}, SystemInformation::{ GetFirmwareType, GetNativeSystemInfo, OSVERSIONINFOEXW, PROCESSOR_ARCHITECTURE_AMD64, SYSTEM_INFO, }, }; type RtlVersion = unsafe extern "system" fn(*mut OSVERSIONINFOEXW) -> i32; type Query = unsafe extern "system" fn(i32, *mut core::ffi::c_void, u32, *mut u32) -> i32; pub(super) fn observe() -> Observation { let mut out = Observation::unsupported("BOOT_CANDIDATE_API_UNAVAILABLE"); // ntdll is already loaded by the OS. No path/search-based DLL loading. let name: Vec = "ntdll.dll".encode_utf16().chain(Some(0)).collect(); let module = unsafe { GetModuleHandleW(name.as_ptr()) }; if module.is_null() { return out; } let Some(version) = (unsafe { GetProcAddress(module, c"RtlGetVersion".as_ptr().cast()) }) else { return out; }; let Some(query) = (unsafe { GetProcAddress(module, c"NtQuerySystemInformation".as_ptr().cast()) }) else { return out; }; // Public entrypoint calling conventions; class90's returned layout is // explicitly experimental and checked as bytes, not a dereferenced ABI. let version: RtlVersion = unsafe { std::mem::transmute(version) }; let query: Query = unsafe { std::mem::transmute(query) }; let mut os: OSVERSIONINFOEXW = unsafe { zeroed() }; os.dwOSVersionInfoSize = size_of::() as u32; if unsafe { version(&mut os) } != 0 { return out; } out.windows_build = Some(os.dwBuildNumber); let mut system: SYSTEM_INFO = unsafe { zeroed() }; unsafe { GetNativeSystemInfo(&mut system) }; if os.dwMajorVersion != 10 || os.dwMinorVersion != 0 || os.dwBuildNumber != CANDIDATE_BUILD || os.wProductType != 1 || unsafe { system.Anonymous.Anonymous.wProcessorArchitecture } != PROCESSOR_ARCHITECTURE_AMD64 { out.code = "BOOT_CANDIDATE_BUILD_OR_ARCHITECTURE_UNSUPPORTED"; return out; } let mut firmware = 0; if unsafe { GetFirmwareType(&mut firmware) } == 0 { out.code = "BOOT_CANDIDATE_FIRMWARE_CROSSCHECK_UNAVAILABLE"; return out; } // Fixed aligned32-byte capacity; no remote length/allocation or fallback. let mut data = [0u64; 4]; let mut returned = 0; let status = unsafe { query(90, data.as_mut_ptr().cast(), 32, &mut returned) }; out.nt_status = Some(status); out.returned_bytes = Some(returned); out.firmware_type = Some(firmware as u32); if status == 0xC0000022u32 as i32 { out.quality = "permission_denied"; out.code = "BOOT_CANDIDATE_ACCESS_DENIED"; return out; } let mut bytes = [0u8; 32]; for (i, value) in data.iter().enumerate() { bytes[i * 8..i * 8 + 8].copy_from_slice(&value.to_ne_bytes()); } if let Some(id) = decode(status, returned, bytes, firmware as u32) { out.candidate_identifier = Some(id); out.quality = "candidate_unqualified"; out.code = "BOOT_CANDIDATE_REQUIRES_ABI_AND_NATIVE_LIFECYCLE_QUALIFICATION"; } else { out.code = "BOOT_CANDIDATE_STATUS_LENGTH_OR_LAYOUT_UNSUPPORTED"; } // Neither raw BootFlags nor unrelated native memory is exposed. out } } #[cfg(test)] mod tests { use super::*; #[test] fn candidate_layout_and_status_never_imply_job_qualification() { let id = Uuid::parse_str("12345678-9abc-4def-8123-456789abcdef").unwrap(); let mut bytes = [0u8; 32]; bytes[..16].copy_from_slice(&id.to_bytes_le()); bytes[16..20].copy_from_slice(&2u32.to_le_bytes()); assert_eq!(decode(0, 32, bytes, 2), Some(id)); assert_eq!(decode(-1, 32, bytes, 2), None); assert_eq!(decode(0, 31, bytes, 2), None); assert_eq!(decode(0, 32, bytes, 1), None); bytes[..16].fill(0); assert_eq!(decode(0, 32, bytes, 2), None); let out = Observation::unsupported("TEST"); assert!(!out.job_binding_qualified); assert!(!out.public_class_90_abi_documented); } }