NtQueryObject

Prototipo

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

Argumentos

IDs de syscalls por versión de Windows

Stub del 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

Notas no documentadas

El SSN `0x10` es estable de 1507 a 24H2 — buen candidato a hardcode. Las cuatro clases de información tienen roles muy distintos: `ObjectBasicInformation` devuelve OBJECT_BASIC_INFORMATION con **HandleCount** y **PointerCount** (usado para detectar objetos debugger), `ObjectNameInformation` devuelve la ruta device (p. ej. `\Device\HarddiskVolume3\foo`) — la forma canónica de convertir un handle de archivo/section/clave en ruta, `ObjectTypeInformation` devuelve OBJECT_TYPE_INFORMATION para el tipo de un único handle, y `ObjectTypesInformation` (clase 3) devuelve OBJECT_TYPES_INFORMATION — array empaquetado que describe todos los tipos de objeto que conoce el kernel. El layout empaquetado ha exigido históricamente recorridos `ALIGN_UP_BY(p + sizeof(OBJECT_TYPE_INFORMATION_V2) + name.MaximumLength, sizeof(PVOID))`; phnt fija los offsets por build.

Uso común por malware

Dos abusos estrella. **Anti-depuración vía ObjectTypesInformation**: recorrer la tabla de tipos buscando la entrada `DebugObject` e inspeccionar `TotalNumberOfObjects` / `TotalNumberOfHandles` — valores no nulos = alguien tiene un objeto debug activo (depurador en alguna parte). Vista a nivel OS, también pilla depuradores en procesos hermanos. Barato, sin excepciones y más difícil de falsear que PEB.BeingDebugged. **Enumeración de handles para acceso a credenciales**: los dumpers LSASS conscientes de OPSEC post-2022 (NanoDump, forks tipo NanoDump, variantes de Dumpert) iteran `SystemHandleInformation` con NtQuerySystemInformation, luego llaman a NtQueryObject(ObjectTypeInformation) para descartar todo lo que no sea handle de Process, y luego NtQueryObject(ObjectBasicInformation) + GrantedAccess para encontrar un handle LSASS ya abierto con acceso suficiente — y duplicarlo en lugar de abrir LSASS ellos mismos.

Oportunidades de detección

NtQueryObject(ObjectNameInformation) sobre handles de archivo es habitual en código legítimo (Process Explorer, antivirus). La señal fuerte es **la clase 3 (ObjectTypesInformation) llamada desde un proceso no de sistema y no depurador** — casi no hay razón legítima para que código no privilegiado enumere la tabla global de tipos. Los EDR vigilan ese número de clase en su stub hookeado. Saltarlo con syscall directa elimina la traza usermode pero deja ETW Microsoft-Windows-Kernel-Audit-API-Calls visible; los vendors correlacionan también `NtQuerySystemInformation(SystemHandleInformation)` seguido inmediatamente de una ráfaga de `NtQueryObject` — la huella canónica del recorrido de handle-table.

Ejemplos de syscalls directos

; 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))
}

Mapeos MITRE ATT&CK

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