NtCancelSynchronousIoFile

Prototype

NTSTATUS NtCancelSynchronousIoFile(
  HANDLE           ThreadHandle,
  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 95 00 00 00      mov eax, 0x95
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

Le cousin de NtCancelIoFileEx qui cible l'I/O *synchrone* — des appels comme `ReadFile` sur un handle ouvert sans `FILE_FLAG_OVERLAPPED`, où le thread appelant est assis dans le noyau à attendre la complétion de l'IRP et ne peut lui-même traiter une annulation. Le wrapper Win32 `CancelSynchronousIo` ne prend que le handle de thread ; la variante ciblant l'IO_STATUS_BLOCK n'est accessible qu'à travers l'API native. Le SSN dérive modestement (`0x91` 1803–1909, `0x93` 2004–23H2, `0x95` 24H2 / Server 2025). L'appeler sur un thread qui n'est pas en attente synchrone d'I/O renvoie `STATUS_NOT_FOUND` (0xC0000225) — bénin.

Usage courant par les malwares

Moins couramment armé que NtCancelIoFileEx mais avec un cas d'usage distinctif : **débloquer un thread scanner d'EDR**. Certains EDR user-mode font tourner un worker qui lit synchroniquement son pipe IPC (`\\.\pipe\<vendor>`) en attente de messages de commande. Si un attaquant peut obtenir un handle équivalent à THREAD_TERMINATE vers ce worker et que la protection de l'EDR est déjà neutralisée, `NtCancelSynchronousIoFile` ramène le worker en user mode avec `STATUS_CANCELLED` — potentiellement mettant le sensor dans un état dégradé sans tuer le processus (ce qui déclencherait l'auto-protection). Aussi utilisé par l'outillage red-team pour décoincer un thread qu'il a injecté dans la cible et qui s'est retrouvé bloqué sur une I/O synchrone longue (ex. un NetUserGetInfo contre un DC lent) afin que l'injection puisse être démontée proprement sans orpheliner le thread.

Opportunités de détection

Vraiment rare dans le logiciel bénin. L'usage légitime emblématique est le chemin de déconnexion de lecteur réseau épinglé d'Explorer (Explorer déclenche NtCancelSynchronousIoFile pour décoincer le thread I/O bloqué sur un partage SMB mort). Hors ce contexte étroit, les appels sont suspects. Le signal haute fidélité est *cross-process* : le thread A dans le processus X appelle NtCancelSynchronousIoFile avec un handle vers le thread B dans le processus Y, où Y est un service ou un composant EDR. ETW `Microsoft-Windows-Kernel-Process` plus les événements d'ouverture de handle cross-process de `Microsoft-Windows-Kernel-Audit-API-Calls` corrèlent la paire open + cancel. Resserrer les ACL sur les threads de service EDR (pour qu'un non-SYSTEM ne puisse pas acquérir THREAD_TERMINATE) défait le bypass avant que le syscall ne soit atteignable.

Exemples de syscalls directs

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

// Free a thread we injected into a target process that ended up blocked
// in a synchronous I/O wait, so the injection can be cleanly unwound.
#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 *pNtCancelSynchronousIoFile)(
    HANDLE ThreadHandle, PIO_STATUS_BLOCK IoRequestToCancel,
    PIO_STATUS_BLOCK IoStatusBlock);

NTSTATUS Unstick(HANDLE h_thread) {
    pNtCancelSynchronousIoFile NtCancelSynchronousIoFile =
        (pNtCancelSynchronousIoFile)GetProcAddress(
            GetModuleHandleA("ntdll.dll"), "NtCancelSynchronousIoFile");
    IO_STATUS_BLOCK out = {0};
    return NtCancelSynchronousIoFile(h_thread, NULL, &out);
}

// Defensive use: cancel a synchronous IO blocking a worker thread we own.
use windows_sys::Win32::Foundation::HANDLE;
use windows_sys::Win32::System::IO::CancelSynchronousIo;

pub unsafe fn cancel_blocked(h_thread: HANDLE) -> bool {
    // CancelSynchronousIo(h) wraps NtCancelSynchronousIoFile with IRP=NULL.
    CancelSynchronousIo(h_thread) != 0
}

Mappings MITRE ATT&CK

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