NtQuerySystemTime

Prototype

NTSTATUS NtQuerySystemTime(
  PLARGE_INTEGER SystemTime
);

Arguments

IDs de syscalls par version de Windows

Stub du syscall

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

La plupart du code moderne lit directement `KUSER_SHARED_DATA.SystemTime` (`0x7FFE0014`) sans syscall — `GetSystemTimeAsFileTime` fait exactement cela en user mode. `NtQuerySystemTime` reste utile aux appelants nécessitant une valeur faisant autorité issue du noyau (horodatage cryptographique, débogueurs, tests passant par le dispatcher). Le SSN est resté `0x5A` sur toutes les builds Win10/11 publiées.

Usage courant par les malwares

Usage classique : détection d'accélération de sandbox — associer `NtQuerySystemTime` à `NtDelayExecution` pour vérifier que la progression de l'horloge murale correspond au sleep demandé. Beaucoup de sandboxes automatisées hookent ou sautent `Sleep` pour finir l'analyse plus vite — mais elles falsifient rarement `KeQuerySystemTime`, donc l'écart trahit la fraude. Du malware extra-prudent lit aussi `KUSER_SHARED_DATA.SystemTime` *et* appelle `NtQuerySystemTime` ; un écart suggère une page partagée trafiquée. Sert également de source d'entropie d'apparence anodine pour les RNG des stagers.

Opportunités de détection

Difficile à alerter isolément — c'est l'une des Native API les plus appelées dans le logiciel normal. Le motif intéressant est la *séquence* : `NtDelayExecution` court suivi immédiatement de `NtQuerySystemTime`, en boucle, depuis un processus sans UI. Les traces ETW `Microsoft-Windows-Kernel-Process` combinées au stack-walking peuvent le révéler. Lire `KUSER_SHARED_DATA.SystemTime` en user mode est invisible aux outils de syscall tracing, ce qui explique que le malware évasif préfère cette voie quand une horloge approximative suffit.

Exemples de syscalls directs

; Direct syscall stub for NtQuerySystemTime (SSN 0x5A, all Win10/11 builds)
NtQuerySystemTime PROC
    mov  r10, rcx          ; syscall convention
    mov  eax, 5Ah          ; SSN
    syscall
    ret
NtQuerySystemTime ENDP

// If KUSER_SHARED_DATA.SystemTime and NtQuerySystemTime disagree by
// more than a few seconds, the analysis environment has tampered
// with the shared page or with the syscall path.
#include <windows.h>
#include <winternl.h>

extern "C" NTSTATUS NTAPI NtQuerySystemTime(PLARGE_INTEGER);

BOOL SharedPageTamperedWith(void) {
    LARGE_INTEGER shared, kernel;
    // KUSER_SHARED_DATA.SystemTime is a tick-incrementing 8-byte field
    shared.QuadPart = *(volatile LONGLONG*)0x7FFE0014;
    NtQuerySystemTime(&kernel);
    LONGLONG deltaSec = (kernel.QuadPart - shared.QuadPart) / 10000000LL;
    return deltaSec > 5 || deltaSec < -5;
}

// Pair NtQuerySystemTime with NtDelayExecution to detect sandbox-accelerated sleeps.
use std::arch::asm;

#[unsafe(naked)]
unsafe extern "system" fn nt_query_system_time(_out: *mut i64) -> i32 {
    asm!("mov r10, rcx", "mov eax, 0x5A", "syscall", "ret", options(noreturn));
}
#[unsafe(naked)]
unsafe extern "system" fn nt_delay_execution(_a: u8, _i: *const i64) -> i32 {
    asm!("mov r10, rcx", "mov eax, 0x34", "syscall", "ret", options(noreturn));
}

pub fn sleep_was_skipped(seconds: i64) -> bool {
    let (mut t0, mut t1): (i64, i64) = (0, 0);
    let interval = -seconds * 10_000_000;
    unsafe {
        nt_query_system_time(&mut t0);
        nt_delay_execution(0, &interval);
        nt_query_system_time(&mut t1);
    }
    ((t1 - t0) / 10_000_000) < seconds - 1
}

Mappings MITRE ATT&CK

• T1497Virtualization/Sandbox Evasionmitre ↗
• T1497.003Time Based Evasionmitre ↗
• T1106Native APImitre ↗