NtQueryObject

Prototype

NTSTATUS NtQueryObject(
  HANDLE                   Handle,
  OBJECT_INFORMATION_CLASS ObjectInformationClass,
  PVOID                    ObjectInformation,
  ULONG                    ObjectInformationLength,
  PULONG                   ReturnLength
);

Arguments

IDs de syscalls par version de Windows

Stub du syscall

4C 8B D1            mov r10, rcx
B8 10 00 00 00      mov eax, 0x10
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

Le SSN `0x10` est stable de 1507 à 24H2 — bon candidat au hardcode. Les quatre classes d'information ont des rôles très différents : `ObjectBasicInformation` renvoie OBJECT_BASIC_INFORMATION avec **HandleCount** et **PointerCount** (utilisé pour détecter les objets debugger), `ObjectNameInformation` renvoie le chemin device (ex. `\Device\HarddiskVolume3\foo`) — la manière canonique de convertir un handle fichier/section/clé en chemin, `ObjectTypeInformation` renvoie OBJECT_TYPE_INFORMATION pour le type d'un handle unique, et `ObjectTypesInformation` (classe 3) renvoie OBJECT_TYPES_INFORMATION — tableau compacté décrivant tous les types d'objet connus du noyau. Le layout compact a historiquement exigé des parcours `ALIGN_UP_BY(p + sizeof(OBJECT_TYPE_INFORMATION_V2) + name.MaximumLength, sizeof(PVOID))` ; phnt fixe les offsets par build.

Usage courant par les malwares

Deux abus phares. **Anti-débogage via ObjectTypesInformation** : parcourir la table de types pour l'entrée `DebugObject` et inspecter `TotalNumberOfObjects` / `TotalNumberOfHandles` — valeurs non nulles = quelqu'un a un objet debug actif (débogueur attaché quelque part). Vue OS, ce qui attrape aussi les débogueurs sur processus voisins. Pas cher, sans exception, et plus difficile à mentir que PEB.BeingDebugged. **Énumération de handles pour accès aux credentials** : les dumpers LSASS soucieux d'OPSEC post-2022 (NanoDump, forks NanoDump-like, variantes Dumpert) itèrent `SystemHandleInformation` via NtQuerySystemInformation, puis appellent NtQueryObject(ObjectTypeInformation) pour ne garder que les handles Process, puis NtQueryObject(ObjectBasicInformation) + GrantedAccess pour trouver un handle LSASS déjà ouvert avec assez d'accès — et le dupliquer plutôt que d'ouvrir LSASS eux-mêmes.

Opportunités de détection

NtQueryObject(ObjectNameInformation) sur des handles fichier est banal dans le code légitime (Process Explorer, antivirus). Le signal fort est **la classe 3 (ObjectTypesInformation) appelée par un processus non système et non débogueur** — il n'y a presque aucune raison légitime pour du code non privilégié d'énumérer la table de types globale. Les EDR surveillent ce numéro de classe dans leur stub hooké. Contourner via syscall direct supprime la trace usermode mais laisse ETW Microsoft-Windows-Kernel-Audit-API-Calls visible ; les vendors corrèlent aussi `NtQuerySystemInformation(SystemHandleInformation)` suivi immédiatement d'une rafale d'appels `NtQueryObject` — l'empreinte canonique du parcours de la handle-table.

Exemples de syscalls directs

; Direct syscall stub for NtQueryObject (SSN 0x10, all builds)
NtQueryObject PROC
    mov  r10, rcx          ; syscall convention
    mov  eax, 10h          ; SSN
    syscall
    ret
NtQueryObject ENDP

// Walk the global object-type table looking for the "DebugObject" entry
// and report its TotalNumberOfObjects. Non-zero = a debugger exists somewhere.
#include <windows.h>
#include <winternl.h>

#define ObjectTypesInformation 3

typedef struct _OBJECT_TYPE_INFORMATION_V2 {
    UNICODE_STRING TypeName;
    ULONG TotalNumberOfObjects;
    ULONG TotalNumberOfHandles;
    ULONG TotalPagedPoolUsage;
    ULONG TotalNonPagedPoolUsage;
    ULONG TotalNamePoolUsage;
    ULONG TotalHandleTableUsage;
    ULONG HighWaterNumberOfObjects;
    // ... truncated for brevity
} OBJECT_TYPE_INFORMATION_V2;

typedef struct _OBJECT_TYPES_INFORMATION {
    ULONG NumberOfTypes;
} OBJECT_TYPES_INFORMATION;

typedef NTSTATUS (NTAPI *pNtQueryObject)(
    HANDLE, ULONG, PVOID, ULONG, PULONG);

BOOL HasDebugObjects(void) {
    pNtQueryObject NtQueryObject = (pNtQueryObject)GetProcAddress(
        GetModuleHandleA("ntdll.dll"), "NtQueryObject");
    ULONG need = 0;
    NtQueryObject(NULL, ObjectTypesInformation, NULL, 0, &need);
    PBYTE buf = (PBYTE)LocalAlloc(LPTR, need + 0x1000);
    if (!NT_SUCCESS(NtQueryObject(NULL, ObjectTypesInformation,
                                  buf, need + 0x1000, &need))) return FALSE;
    // Caller responsibility: walk the packed array with proper alignment.
    // Search for TypeName == L"DebugObject" and read TotalNumberOfObjects.
    LocalFree(buf);
    return TRUE;
}

// Cargo: windows-sys = "0.59", ntapi = "0.4"
use ntapi::ntobapi::{NtQueryObject, ObjectNameInformation};
use windows_sys::Win32::Foundation::HANDLE;

pub unsafe fn handle_to_nt_path(h: HANDLE) -> Option<String> {
    let mut need: u32 = 0;
    let _ = NtQueryObject(h as _, ObjectNameInformation,
                          std::ptr::null_mut(), 0, &mut need);
    let mut buf = vec![0u8; need as usize + 0x100];
    let st = NtQueryObject(h as _, ObjectNameInformation,
                           buf.as_mut_ptr() as _, buf.len() as u32, &mut need);
    if st < 0 { return None; }
    // OBJECT_NAME_INFORMATION: UNICODE_STRING followed by buffer
    let name = &*(buf.as_ptr() as *const ntapi::ntobapi::OBJECT_NAME_INFORMATION);
    let slice = std::slice::from_raw_parts(
        name.Name.Buffer, (name.Name.Length / 2) as usize);
    Some(String::from_utf16_lossy(slice))
}

Mappings MITRE ATT&CK

• T1622Debugger Evasionmitre ↗
• T1003.001OS Credential Dumping: LSASS Memorymitre ↗
• T1106Native APImitre ↗