NtCancelSynchronousIoFile

Prototyp

NTSTATUS NtCancelSynchronousIoFile(
  HANDLE           ThreadHandle,
  PIO_STATUS_BLOCK IoRequestToCancel,
  PIO_STATUS_BLOCK IoStatusBlock
);

Argumente

Syscall-IDs pro Windows-Version

Syscall-Stub

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

Undokumentierte Hinweise

Der Cousin von NtCancelIoFileEx, der *synchrone* I/O anvisiert — Aufrufe wie `ReadFile` auf einem Handle, das ohne `FILE_FLAG_OVERLAPPED` geöffnet wurde, wo der aufrufende Thread im Kernel auf den Abschluss des IRP wartet und selbst keinen Cancel verarbeiten kann. Der Win32-Wrapper `CancelSynchronousIo` nimmt nur den Thread-Handle; die IO_STATUS_BLOCK-gezielte Variante ist nur über die native API erreichbar. Die SSN driftet moderat (`0x91` 1803–1909, `0x93` 2004–23H2, `0x95` 24H2 / Server 2025). Aufruf auf einem Thread, der aktuell nicht in einer synchronen I/O-Wartestellung ist, gibt `STATUS_NOT_FOUND` (0xC0000225) zurück — harmlos.

Häufige Malware-Nutzung

Seltener bewaffnet als NtCancelIoFileEx, aber mit einem markanten Anwendungsfall: **einen EDR-Scanner-Thread freigeben**. Manche User-Mode-EDRs lassen einen Worker laufen, der synchron seine IPC-Pipe (`\\.\pipe\<vendor>`) auf Befehlsnachrichten liest. Kann ein Angreifer ein THREAD_TERMINATE-äquivalentes Handle auf diesen Worker erlangen und ist der EDR-Schutz bereits neutralisiert, bringt `NtCancelSynchronousIoFile` den Worker mit `STATUS_CANCELLED` zurück in den User-Mode — potenziell setzt das den Sensor in einen degradierten Zustand, ohne den Prozess zu töten (was Selbstschutz auslösen würde). Auch von Red-Team-Tooling genutzt, um einen in das Ziel injizierten Thread, der in einer langen synchronen I/O hängt (z. B. ein NetUserGetInfo gegen einen langsamen DC), zwangsweise freizugeben, damit die Injektion sauber zurückgerollt werden kann, ohne den Thread zu verwaisen.

Erkennungs­möglichkeiten

In gutartiger Software wirklich selten. Der prominente legitime Einsatz ist Explorers Pinned-Network-Drive-Disconnect-Pfad (Explorer feuert NtCancelSynchronousIoFile, um den I/O-Thread freizubekommen, der auf einer toten SMB-Freigabe hängt). Außerhalb dieses engen Kontexts sind Aufrufe verdächtig. Das hochauflösende Signal ist *cross-process*: Thread A in Prozess X ruft NtCancelSynchronousIoFile mit einem Handle auf Thread B in Prozess Y auf, wobei Y ein Service oder eine EDR-Komponente ist. ETW `Microsoft-Windows-Kernel-Process` plus die cross-process-Handle-Open-Events aus `Microsoft-Windows-Kernel-Audit-API-Calls` korrelieren das Open-+-Cancel-Paar. Verschärfte ACLs auf EDR-Service-Threads (sodass Nicht-SYSTEM kein THREAD_TERMINATE bekommt) schlagen den Bypass, bevor der Syscall überhaupt erreichbar ist.

Direkte Syscall-Beispiele

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

MITRE ATT&CK-Mappings

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