Verify Windows ACL regression fix and native denied administrator probe
Rust development slice / linux (push) Failing after 7s
Rust development slice / linux (push) Failing after 7s
This commit is contained in:
@@ -0,0 +1,170 @@
|
||||
//! 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<u32>,
|
||||
pub nt_status: Option<i32>,
|
||||
pub returned_bytes: Option<u32>,
|
||||
pub candidate_identifier: Option<Uuid>,
|
||||
pub firmware_type: Option<u32>,
|
||||
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<Uuid> {
|
||||
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<u16> = "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::<OSVERSIONINFOEXW>() 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);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user