NtDeviceIoControlFile

Prototipo

NTSTATUS NtDeviceIoControlFile(
  HANDLE           FileHandle,
  HANDLE           Event,
  PIO_APC_ROUTINE  ApcRoutine,
  PVOID            ApcContext,
  PIO_STATUS_BLOCK IoStatusBlock,
  ULONG            IoControlCode,
  PVOID            InputBuffer,
  ULONG            InputBufferLength,
  PVOID            OutputBuffer,
  ULONG            OutputBufferLength
);

Argumentos

IDs de syscalls por versión de Windows

Stub del syscall

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

Misma forma I/O de 9 argumentos que NtReadFile/NtWriteFile/NtFsControlFile — sólo cambia el significado del slot intermedio (código IOCTL en lugar de offset). Despachada en el kernel a `IopXxxControlFile`, que construye un IRP con código mayor `IRP_MJ_DEVICE_CONTROL` y lo enruta a la dispatch table del device. El propio valor IOCTL codifica tipo de device, función, método de transferencia (METHOD_BUFFERED, METHOD_IN_DIRECT, METHOD_OUT_DIRECT, METHOD_NEITHER) y acceso requerido — los drivers METHOD_NEITHER suelen confiar en punteros de usuario sin sondear, justamente la clase de bug que sostiene el BYOVD.

Uso común por malware

Primitiva de comunicación con drivers del kernel abusada por **BYOVD (Bring Your Own Vulnerable Driver)**. El patrón es invariante: soltar un driver vulnerable pero firmado por Microsoft (RTCore64.sys / Micro-Star MSI Afterburner, gdrv.sys / Gigabyte, mhyprot2.sys / Genshin Impact, dbutil_2_3.sys / Dell, Procexp152.sys), llamar a `OpenSCManager`+`CreateService`+`StartService` (o `NtLoadDriver`), abrir `\\.\<DeviceName>` y emitir IOCTLs que exponen R/W arbitrario al kernel (p. ej. RTCore64 0x80002048 = primitiva MmMapIoSpace, dbutil_2_3 0x9B0C1EC8 = R/W físico arbitrario). Con esa primitiva el malware parchea `_EPROCESS.Token` para SYSTEM, vacía los arrays de callbacks de EDR (`PsSetCreateProcessNotifyRoutineEx`, `CmRegisterCallbackEx`, `ObRegisterCallbacks`) o desengancha ntoskrnl. También se usa como señal **kill switch AMSI/ETW** en HVNC y herramientas tipo EDRSilencer, y como vía IOCTL al `mimidrv.sys` incluido de Mimikatz para manipulación de tokens.

Oportunidades de detección

Los proveedores ETW Microsoft-Windows-Kernel-PnP y Microsoft-Windows-Kernel-Audit-API-Calls registran cargas de drivers — combinar con Sysmon Event ID 6 (Driver loaded) que expone firma, firmante, hash y ruta. La Vulnerable Driver Blocklist de Microsoft (`HVCI`/Code Integrity `SiPolicy.p7b`, activa por defecto desde Win11 22H2) bloquea por hash las familias BYOVD publicadas — sólo si está habilitada. Los sensores EDR registran `PsSetLoadImageNotifyRoutine` para imágenes de driver y `IoRegisterFsRegistrationChange` para filtros FS; ambos disparan pre-ejecución. En el lado IOCTL, el ETW de kernel es pobre; las señales más fiables son (1) image-load de un hash de driver malo conocido, (2) apertura de handle a un device name de driver no usado por producto legítimo en el host, (3) tokens de procesos cuyo puntero `Token` repentinamente iguala al de lsass.exe (detección de token swap). LOLDrivers.io es la lista de hashes de referencia.

Ejemplos de syscalls directos

// Pattern: \\.\RTCore64 opened, send the IOCTL that maps physical memory.
#define RTCORE64_MEMORY_READ_IOCTL  0x80002048

typedef struct _RTCORE_PAYLOAD {
    UINT64 dst;
    UINT64 src;
    UINT32 read_size;
    // ... driver-specific layout
} RTCORE_PAYLOAD;

RTCORE_PAYLOAD p = {0};
p.src       = 0xFFFFF80000000000ULL;       // target kernel addr
p.read_size = sizeof(UINT64);

IO_STATUS_BLOCK iosb = {0};
UINT64 out = 0;
NTSTATUS s = NtDeviceIoControlFile(
    hRtcore, NULL, NULL, NULL, &iosb,
    RTCORE64_MEMORY_READ_IOCTL,
    &p,  sizeof(p),
    &out, sizeof(out));

; NtDeviceIoControlFile takes 10 args. Caller must reserve 32-byte home space
; PLUS room for args 5..10 on the stack before calling this stub.
NtDeviceIoControlFile PROC
    mov  r10, rcx
    mov  eax, 07h
    syscall
    ret
NtDeviceIoControlFile ENDP

// Cargo: ntapi = "0.4", winapi = { version = "0.3", features = ["ntdef"] }
use ntapi::ntioapi::{NtDeviceIoControlFile, IO_STATUS_BLOCK};
use winapi::shared::ntdef::HANDLE;

pub unsafe fn ioctl(
    h_dev: HANDLE,
    code: u32,
    inp: &[u8],
    out: &mut [u8],
) -> (i32, usize) {
    let mut iosb: IO_STATUS_BLOCK = core::mem::zeroed();
    let s = NtDeviceIoControlFile(
        h_dev, core::ptr::null_mut(),
        None, core::ptr::null_mut(),
        &mut iosb,
        code,
        inp.as_ptr() as *mut _, inp.len() as u32,
        out.as_mut_ptr() as *mut _, out.len() as u32,
    );
    (s, *iosb.u.Status_mut() as usize)
}

Mapeos MITRE ATT&CK

• T1068Exploitation for Privilege Escalationmitre ↗
• T1562.001Impair Defenses: Disable or Modify Toolsmitre ↗
• T1014Rootkitmitre ↗
• T1106Native APImitre ↗