NtQuerySystemInformation

Prototype

NTSTATUS NtQuerySystemInformation(
  SYSTEM_INFORMATION_CLASS SystemInformationClass,
  PVOID                    SystemInformation,
  ULONG                    SystemInformationLength,
  PULONG                   ReturnLength
);

Arguments

IDs de syscalls par version de Windows

Stub du syscall

4C 8B D1            mov r10, rcx
B8 36 00 00 00      mov eax, 0x36
F6 04 25 08 03 FE 7F 01   test byte ptr [0x7FFE0308], 1
75 03               jne short +3
0F 05               syscall
C3                  ret
CD 2E               int 2Eh
C3                  ret

Notes non documentées

Autre poids lourd à SSN figé : 0x36 de Windows 10 1507 jusqu'à Windows 11 24H2. L'énumération de classes est énorme (200+ valeurs dans les noyaux récents) et constitue la base de presque toute API Win32 « énumérer l'état système » : EnumProcesses (classe 5), GetSystemInfo (classe 0), GetNativeSystemInfo, EnumDeviceDrivers (classe 11), et le non-officiellement-exposé NtQuerySystemInformation(SystemHandleInformation=16). La classe 16 est le format de handle 16 bits legacy ; la classe 64 (SystemExtendedHandleInformation) est la variante large moderne — les outils modernes devraient utiliser cette dernière. Le pattern d'appel canonique est une boucle de dimensionnement : appeler avec NULL/0 pour obtenir la taille requise dans ReturnLength, allouer, rappeler, recommencer si le système a grossi sous vos pieds (STATUS_INFO_LENGTH_MISMATCH sur race).

Usage courant par les malwares

Trois usages OPSEC et de reconnaissance à fort impact. (1) SystemProcessInformation (5) renvoie une liste contiguë unique de chaque processus et de *tous ses threads* — utilisée pour trouver des cibles d'injection sans toucher au chemin bruyant CreateToolhelp32Snapshot ; aussi la primitive de découverte derrière « trouver le TID lsass.exe avec attente ALERTABLE » pour Early Bird APC. (2) SystemHandleInformation / SystemExtendedHandleInformation (16/64) énumère chaque handle dans chaque processus — utilisée par les outils furtifs de credential-dumping (HandleKatz, variantes NanoDump) pour trouver un handle PROCESS_VM_READ existant vers lsass.exe détenu par un autre processus et *le dupliquer* via NtDuplicateObject, contournant complètement NtOpenProcess sur lsass. (3) SystemModuleInformation (11) énumère les modules kernel chargés avec leurs adresses de base — défait KASLR pour tout appelant non-LowIL, utilisée par les attaques BYOVD pour calculer les offsets en mémoire des fonctions de pilote ciblées, et par les détecteurs de rootkits. SystemCodeIntegrityInformation (103) permet à un payload de détecter si HVCI / DSE est appliqué avant de tenter de charger un pilote non signé. SystemBootEnvironmentInformation (90) révèle si le chemin de boot est BIOS ou UEFI Secure Boot et est échantillonné par les bootkits pour conditionner leur stratégie de persistance.

Opportunités de détection

Le volume de la classe 5 (SystemProcessInformation) est énorme en usage normal — c'est ainsi que Task Manager, Process Explorer, tout agent de monitoring et le runtime lui-même énumèrent. Le discriminateur est le numéro de classe plus la confiance du processus appelant : les classes 16/64 (énumération de handles) et 11 (énumération de modules) depuis tout processus non-système et non signé Microsoft sont suspectes. ETW Microsoft-Windows-Threat-Intelligence n'expose PAS ce syscall finement ; il faut instrumenter via ETW côté ntdll (Microsoft-Windows-Win32k-Threat-Intelligence) ou un callback noyau. Le signal le plus fort est le comportement post-appel : un processus qui appelle NtQuerySystemInformation(64) et appelle quelques millisecondes plus tard NtDuplicateObject avec un handle source dont le PID est lsass.exe fait presque certainement du credential-dumping.

Exemples de syscalls directs

// Classic two-step: ask for size, allocate, ask for data.
ULONG len = 0x10000;
PVOID buf = NULL;
NTSTATUS st;
for (;;) {
    buf = HeapAlloc(GetProcessHeap(), 0, len);
    st = NtQuerySystemInformation(SystemExtendedHandleInformation /*64*/,
                                  buf, len, &len);
    if (st != STATUS_INFO_LENGTH_MISMATCH) break;
    HeapFree(GetProcessHeap(), 0, buf);
    len *= 2;
}
// buf now holds SYSTEM_HANDLE_INFORMATION_EX with NumberOfHandles + entries
// Iterate and find an entry with UniqueProcessId == lsass_pid and
// GrantedAccess == PROCESS_VM_READ | PROCESS_QUERY_INFORMATION -> dup it.

// Discloses every loaded kernel module's base address from medium-IL or higher.
// Used by BYOVD attacks to compute target driver function offsets.
RTL_PROCESS_MODULES *mods = HeapAlloc(GetProcessHeap(), 0, 0x10000);
ULONG ret = 0;
NtQuerySystemInformation(SystemModuleInformation /*11*/,
                         mods, 0x10000, &ret);
for (ULONG i = 0; i < mods->NumberOfModules; i++) {
    if (strstr((char*)mods->Modules[i].FullPathName, "ntoskrnl.exe")) {
        // mods->Modules[i].ImageBase = current ntoskrnl base — KASLR defeated.
    }
}

// Returns SYSTEM_CODEINTEGRITY_INFORMATION { Length, CodeIntegrityOptions }.
// Check options for CODEINTEGRITY_OPTION_ENABLED | HVCI_ENABLED before
// even attempting an unsigned-driver load.
use windows_sys::Wdk::System::SystemInformation::*;

#[repr(C)] struct CodeIntegrityInfo { length: u32, options: u32 }
let mut ci = CodeIntegrityInfo { length: 8, options: 0 };
let mut ret = 0u32;
unsafe {
    nt_query_system_information(103 /*SystemCodeIntegrityInformation*/,
        &mut ci as *mut _ as *mut _, 8, &mut ret);
}
let hvci_on = ci.options & 0x400 != 0;

Mappings MITRE ATT&CK

• T1057Process Discoverymitre ↗
• T1014Rootkitmitre ↗
• T1003.001OS Credential Dumping: LSASS Memorymitre ↗
• T1106Native APImitre ↗