NtSetInformationVirtualMemory

Prototype

NTSTATUS NtSetInformationVirtualMemory(
  HANDLE                          ProcessHandle,
  VIRTUAL_MEMORY_INFORMATION_CLASS VmInformationClass,
  ULONG_PTR                       NumberOfEntries,
  PMEMORY_RANGE_ENTRY             VirtualAddresses,
  PVOID                           VmInformation,
  ULONG                           VmInformationLength
);

Arguments

IDs de syscalls par version de Windows

Stub du syscall

4C 8B D1            mov r10, rcx
B8 B0 01 00 00      mov eax, 0x1B0
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 le cadre de l'API d'avis VM multi-plage de Windows 10 et substantiellement étendu à chaque release. Les classes d'information les plus intéressantes opérationnellement sont : **VmPrefetchInformation** — préchauffe un vecteur de plages d'adresses avant accès (la dorsale noyau de PrefetchVirtualMemory/OfferVirtualMemory) ; **VmPagePriorityInformation** — définit les hints de priorité de pagination ; **VmCfgCallTargetInformation** — marque des adresses spécifiques dans un module CFG comme cibles d'appel indirect valides, le mécanisme noyau derrière SetProcessValidCallTargets et l'unique voie sanctionnée pour qu'un JIT publie du code fraîchement émis vers un processus protégé par CFG ; **VmImageHotPatchInformation** — utilisé par HotPatch sur Server 2022+ / 24H2.

Usage courant par les malwares

Deux histoires d'abus distinctes. (1) **Recherche de bypass CFG** : VmCfgCallTargetInformation est la porte légitime pour indiquer à CFG qu'une adresse arbitraire est désormais une cible d'appel valide. Si un attaquant ayant déjà obtenu un read/write arbitraire dans un processus protégé par CFG peut l'appeler — ou forger sa mise à jour de bitmap côté noyau — il peut réhabiliter des gadgets arbitraires comme destinations d'appel indirect légitimes. Plusieurs writeups publics de bypass CFG (Yarden Shafir, anciennes notes de j00ru) couvrent cette surface. Le durcissement moderne associe CFG à Xtended Flow Guard (XFG) et Arbitrary Code Guard précisément pour neutraliser cela. (2) **Couverture d'injection JIT** : les navigateurs et .NET légitimes utilisent VmCfgCallTargetInformation en permanence, donc un loader de payload qui imite la même forme d'appel (allocation exécutable, écriture du code, appel à NtSetInformationVirtualMemory avec VmCfgCallTargetInformation) se fond dans la télémétrie de référence à l'intérieur d'un processus de classe navigateur. Moins courant mais documenté.

Opportunités de détection

Les EDR devraient signaler les appels VmCfgCallTargetInformation provenant de processus sans JIT (tout hors chrome.exe, msedge.exe, firefox.exe, dotnet.exe / apps hôtes coreclr, javaw.exe, hôtes utilisant JScript9.dll). L'ETW Microsoft-Windows-Threat-Intelligence émet des événements de changement d'état mémoire couplés aux transitions de pages exécutables. Sysmon ne couvre pas directement ce syscall ; s'appuyer sur le callback syscall du capteur EDR (Kernel-Microsoft-Antimalware-AMFilter sur systèmes instrumentés AMSI). La surface Win32 (SetProcessValidCallTargets, PrefetchVirtualMemory) est hookée par tous les grands EDR.

Exemples de syscalls directs

; Direct syscall stub for NtSetInformationVirtualMemory (SSN 0x1B0, Win11 24H2)
NtSetInformationVirtualMemory PROC
    mov  r10, rcx
    mov  eax, 1B0h
    syscall
    ret
NtSetInformationVirtualMemory ENDP

// JIT just emitted callable code at `jit_buf` (size = jit_len). Tell CFG it's legal
// to indirect-call into the new entrypoints. Mirrors what V8 / CoreCLR do.
typedef struct _CFG_CALL_TARGET_INFO {
    ULONG_PTR Offset;
    ULONG_PTR Flags;
} CFG_CALL_TARGET_INFO;

typedef struct _MEMORY_RANGE_ENTRY {
    PVOID    VirtualAddress;
    SIZE_T   NumberOfBytes;
} MEMORY_RANGE_ENTRY;

#define VmCfgCallTargetInformation 2
#define CFG_CALL_TARGET_VALID      0x01

MEMORY_RANGE_ENTRY range = { jit_buf, jit_len };
CFG_CALL_TARGET_INFO targets[] = {
    { (ULONG_PTR)entry0 - (ULONG_PTR)jit_buf, CFG_CALL_TARGET_VALID },
    { (ULONG_PTR)entry1 - (ULONG_PTR)jit_buf, CFG_CALL_TARGET_VALID },
};

NTSTATUS s = NtSetInformationVirtualMemory(
    NtCurrentProcess(),
    VmCfgCallTargetInformation,
    1,
    &range,
    targets,
    sizeof(targets));

// Warm a list of memory ranges before the latency-sensitive work touches them.
// VmPrefetchInformation = 0.
#[repr(C)]
struct MemoryRangeEntry { addr: *mut u8, bytes: usize }

extern "system" {
    fn NtSetInformationVirtualMemory(
        process: isize,
        class: u32,
        n: usize,
        ranges: *const MemoryRangeEntry,
        info: *const u32,
        info_len: u32,
    ) -> i32;
}

unsafe fn prefetch(ranges: &[MemoryRangeEntry]) -> i32 {
    let flags: u32 = 0;
    NtSetInformationVirtualMemory(
        -1, 0, ranges.len(), ranges.as_ptr(),
        &flags, std::mem::size_of::<u32>() as u32)
}

Mappings MITRE ATT&CK

• T1574Hijack Execution Flowmitre ↗
• T1055Process Injectionmitre ↗
• T1106Native APImitre ↗