NtFlushVirtualMemory

Prototipo

NTSTATUS NtFlushVirtualMemory(
  HANDLE           ProcessHandle,
  PVOID           *BaseAddress,
  PSIZE_T          RegionSize,
  PIO_STATUS_BLOCK IoStatus
);

Argumentos

IDs de syscalls por versión de Windows

Stub del syscall

4C 8B D1            mov r10, rcx
B8 F4 00 00 00      mov eax, 0xF4      ; Win11 24H2 SSN
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

Contraparte de `FlushViewOfFile` para secciones respaldadas por un fichero real en disco. El kernel recorre las PTE del rango solicitado, recolecta las páginas dirty y emite I/O de paging hacia el filesystem subyacente — para un fichero memory-mapped es equivalente a un `fsync` solo del subconjunto modificado. Para regiones respaldadas por pagefile o PAGE_NOACCESS la llamada es efectivamente un no-op. El campo `IoStatus.Information` reporta los bytes realmente escritos.

Uso común por malware

Usado en cadenas de persistencia y ransomware que modifican artefactos en disco vía una vista memory-mapped en lugar de `WriteFile`: el atacante mapea un ejecutable, INI, XML de tarea programada o la lista de LSA Notification Packages como `PAGE_READWRITE`, parchea los bytes y llama a `NtFlushVirtualMemory` para forzar la escritura *ahora* en lugar de esperar al lazy writer — importante cuando el siguiente paso (reinicio, reinicio de servicio o exec inmediato) debe ver el cambio en disco. También visto en cadenas de robo de credenciales estilo `MiniDumpWriteDump` que mapean y editan in-place el fichero de dump. Algunas familias de ransomware tocan esta llamada para asegurar que los bytes cifrados llegan al plato antes de borrar shadow copies y forzar un reinicio.

Oportunidades de detección

Sysmon Event 11 (FileCreate) no se dispara en un flush — el fichero ya existe. La telemetría más fiable es el evento ETW `Microsoft-Windows-Kernel-FileIO` `FileIo/OperationEnd` para operaciones `WRITE` cuyos `IrpFlags` indican paging-IO, correlacionado a un proceso que recientemente obtuvo una sección con escritura sobre un fichero sensible (ejecutable en `\System32`, XML de tarea programada, binario referenciado por `ImagePath` en `\Registry\Machine\System\CurrentControlSet\Services\*`). Los EDR que hookean `NtCreateSection` contra rutas de alto valor y luego siguen los `NtFlushVirtualMemory` subsecuentes contra esas vistas atrapan el patrón de patch in-place.

Ejemplos de syscalls directos

// Persistence helper: patch C:\Windows\System32\target.exe in place.
HANDLE hFile = CreateFileW(L"C:\\Windows\\System32\\target.exe",
    GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ,
    NULL, OPEN_EXISTING, 0, NULL);

HANDLE hMap = CreateFileMappingW(hFile, NULL, PAGE_READWRITE, 0, 0, NULL);
PVOID  view = MapViewOfFile(hMap, FILE_MAP_WRITE, 0, 0, 0);

PatchEntryPoint(view);  // overwrite a few bytes

SIZE_T regionSize = /* SizeOfImage rounded up */ 0;
IO_STATUS_BLOCK iosb;
NTSTATUS s = NtFlushVirtualMemory(
    NtCurrentProcess(),
    &view,
    &regionSize,
    &iosb);
// iosb.Information now holds the number of bytes written back.

; NtFlushVirtualMemory direct stub — SSN 0xF4 on Win11 24H2
NtFlushVirtualMemory PROC
    mov  r10, rcx
    mov  eax, 0F4h
    syscall
    ret
NtFlushVirtualMemory ENDP

use ntapi::ntmmapi::NtFlushVirtualMemory;
use winapi::shared::ntdef::HANDLE;
use winapi::shared::ntdef::PVOID;
use winapi::um::winnt::IO_STATUS_BLOCK;
use std::{mem, ptr::null_mut};

unsafe fn flush(view: PVOID, mut size: usize) -> usize {
    let mut base = view;
    let mut iosb: IO_STATUS_BLOCK = mem::zeroed();
    let s = NtFlushVirtualMemory(
        -1isize as HANDLE,
        &mut base,
        &mut size,
        &mut iosb,
    );
    assert!(s >= 0);
    *iosb.Information() as usize
}

Mapeos MITRE ATT&CK

• T1547Boot or Logon Autostart Executionmitre ↗
• T1027Obfuscated Files or Informationmitre ↗
• T1106Native APImitre ↗