NtLockVirtualMemory

Prototyp

NTSTATUS NtLockVirtualMemory(
  HANDLE  ProcessHandle,
  PVOID  *BaseAddress,
  PSIZE_T RegionSize,
  ULONG   MapType
);

Argumente

Syscall-IDs pro Windows-Version

Syscall-Stub

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

Die Kernel-Implementierung hinter `VirtualLock` (MAP_PROCESS) und der selten genutzten `AllocateUserPhysicalPages`-Kohorte (MAP_SYSTEM). Mit MAP_PROCESS erhöht der Kernel das Working-Set-Minimum des Prozesses, sodass der gesperrte Bereich resident bleibt — entgegen verbreiteter Annahme können Seiten dennoch ausgelagert werden, wenn das Working-Set-Quota später durch andere Allokationen überschritten wird. MAP_SYSTEM verankert tatsächlich Seiten in physischen Frames, erfordert aber SeLockMemoryPrivilege (das standardmäßig nur LocalSystem hält). Die SSN driftet moderat (`0x108` Win10 1903, `0x10D` 2004, `0x117` Win11 24H2 / Server 2025), Hell's-Gate-artige Auflösung ist empfohlen.

Häufige Malware-Nutzung

Der Malware-Headliner ist in **Sleep-Mask**-Designs wie Ekko, Foliage, FOLIAGE-artigen Varianten und Cobalt Strikes `Sleep_Mask`-UDRL-Familie. Das Muster: die `.text`/Heap-Region des Beacons in-place verschlüsseln, N Sekunden schlafen, beim Aufwachen entschlüsseln. Wird die verschlüsselte Region während des Schlafs ausgelagert, kann das OS Chiffrat in das Pagefile schreiben *und* es beim Aufwachen laut zurückfaulten — was sowohl Tarnung als auch Timing zerstört. `NtLockVirtualMemory(MAP_PROCESS)` hält die Region im Working Set, damit der Verschlüsseln-Schlafen-Entschlüsseln-Zyklus vorhersehbar und leise bleibt. Sekundärer Einsatz: Custom-Packer, die die entpackte OEP-Region sperren, um Pagefault-basierte Memory-Introspection-Scanner zu schlagen (z. B. frühe Pafish-artige Erkennung, die EDR-Scan gegen Pagefault-Timing rennt). Hinweis: MAP_SYSTEM ist aus Nicht-SYSTEM-Usercode praktisch unerreichbar, der malwarerelevante Pfad ist daher stets MAP_PROCESS.

Erkennungs­möglichkeiten

VirtualLock selbst ist in legitimer User-Mode-Software extrem selten (Adobe Reader für Lizenzschlüssel-Material, KeePass für Geheimnis-Puffer, OpenSSL FIPS-Modus für Schlüssel — das ist praktisch die gesamte Population). Eine unsignierte Binary, die NtLockVirtualMemory auf eine frisch `NtAllocateVirtualMemory`'d RWX-Region aufruft, dann mehrere Sekunden `NtDelayExecution` macht und danach entsperrt — dieses Muster ist in gutartigem Code weit seltener als in Ekko-/Foliage-Sleep-Masks. ETW Threat Intelligence exponiert Sperr-Events nicht nativ; das verlässlichste Signal ist das Hooken des User-Mode-`VirtualLock`-Thunks und Korrelation mit Allokations-Flags und aufrufendem Modul. EDRs, die periodische Working-Set-Scans durchführen (CrowdStrike, MDE), schlagen den Sleep-Mask-Versteck-Trick effektiv, weil sie die Bytes der Region unabhängig vom Lock-Status lesen.

Direkte Syscall-Beispiele

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

// Sleep-mask skeleton: lock the encrypted region so the kernel can't
// swap ciphertext to disk while we wait on a timer-queue or APC.
#include <windows.h>

typedef NTSTATUS (NTAPI *pNtLockVirtualMemory)(HANDLE, PVOID*, PSIZE_T, ULONG);
typedef NTSTATUS (NTAPI *pNtUnlockVirtualMemory)(HANDLE, PVOID*, PSIZE_T, ULONG);

#define MAP_PROCESS 1

void SleepWithLockedRegion(PVOID base, SIZE_T size, DWORD ms) {
    HMODULE n = GetModuleHandleA("ntdll.dll");
    pNtLockVirtualMemory   NtLock   = (pNtLockVirtualMemory)  GetProcAddress(n, "NtLockVirtualMemory");
    pNtUnlockVirtualMemory NtUnlock = (pNtUnlockVirtualMemory)GetProcAddress(n, "NtUnlockVirtualMemory");

    PVOID  b = base;
    SIZE_T s = size;
    NtLock((HANDLE)-1, &b, &s, MAP_PROCESS);
    // ... XOR-encrypt b[0..s] in place ...
    Sleep(ms);
    // ... XOR-decrypt b[0..s] in place ...
    NtUnlock((HANDLE)-1, &b, &s, MAP_PROCESS);
}

// Defensive use: keep a derived key out of the pagefile.
use windows_sys::Win32::System::Memory::{VirtualLock, VirtualUnlock};

pub struct PinnedSecret { ptr: *mut u8, len: usize }

impl PinnedSecret {
    pub fn new(buf: &mut [u8]) -> std::io::Result<Self> {
        let ptr = buf.as_mut_ptr();
        let len = buf.len();
        if unsafe { VirtualLock(ptr as _, len) } == 0 {
            return Err(std::io::Error::last_os_error());
        }
        Ok(Self { ptr, len })
    }
}

impl Drop for PinnedSecret {
    fn drop(&mut self) {
        unsafe {
            std::ptr::write_bytes(self.ptr, 0, self.len);
            VirtualUnlock(self.ptr as _, self.len);
        }
    }
}

MITRE ATT&CK-Mappings

• T1027.011Obfuscated Files or Information: Fileless Storagemitre ↗
• T1027Obfuscated Files or Informationmitre ↗
• T1106Native APImitre ↗