NtSetTimer2

Prototype

NTSTATUS NtSetTimer2(
  HANDLE              TimerHandle,
  PLARGE_INTEGER      DueTime,
  PLARGE_INTEGER      Period,
  PT2_SET_PARAMETERS  Parameters
);

Arguments

IDs de syscalls par version de Windows

Stub du syscall

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

Là où l'ancien `NtSetTimer` prenait la routine APC et son contexte comme paramètres `PTIMER_APC_ROUTINE` / `PVOID` séparés, `NtSetTimer2` regroupe tout ce qui *modifie* l'état armé dans un unique bloc `T2_SET_PARAMETERS`. La structure porte `Version`, un `TolerableDelay` (utilisé par le scheduler de coalescence), un `NoWakeTolerance` optionnel (évite de sortir le CPU des C-states), et une union choisissant entre *callback workitem* (utilisé par `SetThreadpoolTimer`) et *callback APC* (utilisé quand le timer pilote un wait alertable). Côté noyau c'est `ExpSetTimer2` → `KiSetTimer2` et le timer est réarmé via `KiTimerExpiration` exécuté sur la file de seconde génération du `PRCB`. La coalescence est la vraie raison d'être de Timer2 : un flux de petits timers à travers de nombreux threads peut être fusionné à l'expiration pour réduire les wakeups d'un ordre de grandeur.

Usage courant par les malwares

Dans les sleep masks qui ont adopté Timer2 (Cronos / Zilean et plusieurs kits red-team privés), `NtSetTimer2` est l'appel qui *arme effectivement* le timer : le champ `T2_SET_PARAMETERS::Callback.Routine` pointe vers le premier gadget ROP de la chaîne de chiffrement, et un `DueTime` court (typiquement 1-5 ms relatif) plus une `Period` non nulle font que la chaîne se réarme elle-même. Mettre `NoWakeTolerance` à une valeur élevée réduit les wakeups CPU, rendant la posture idle de l'implant indiscernable d'un consommateur threadpool normal comme Edge ou Teams. Certaines variantes de **PoolParty** passent `Parameters` pointant vers la mémoire d'un *autre processus* via un work-item smuggled, abusant du worker factory du threadpool pour délivrer l'exécution.

Opportunités de détection

Côté télémétrie, `NtSetTimer2` est le point de passage critique car `NtCreateTimer2` est trop bruyant en apps légitimes. ETW-TI (`Microsoft-Windows-Threat-Intelligence`) n'émet *pas* actuellement d'événement dédié à l'armement de Timer2 ; ETW `Microsoft-Windows-Kernel-Process` et `Microsoft-Windows-Threading` ensemble permettent de reconstruire l'événement. Le signal fort est : `Parameters->Callback.Routine` en mémoire non-backed / RWX `MEM_PRIVATE`, `DueTime` court (< 100 ms) combiné à une `Period` qui matche la cadence Ekko-dérivée de 50-100 ms, et un thread appelant dont l'entry point lui-même est en mémoire privée. CrowdStrike, Defender for Endpoint et Elastic détectent tous Ekko *via la conséquence* — l'alertable wait en mémoire RWX — plutôt que via ce syscall lui-même.

Exemples de syscalls directs

; Direct syscall stub for NtSetTimer2 (SSN 0x1C0 on Win11 24H2 / Server 2025)
NtSetTimer2 PROC
    mov  r10, rcx          ; syscall convention
    mov  eax, 1C0h         ; SSN — drifts; resolve dynamically for portability
    syscall
    ret
NtSetTimer2 ENDP

// Arm the Timer2 created earlier; APC delivery will run the ROP chain that
// flips implant memory between encrypted RW and executable RX.
typedef struct _T2_SET_PARAMETERS_V0 {
    ULONG Version;
    ULONG Reserved;
    LONG64 NoWakeTolerance;
} T2_SET_PARAMETERS, *PT2_SET_PARAMETERS;

LARGE_INTEGER due    = { .QuadPart = -50000 };          // 5 ms relative
LARGE_INTEGER period = { .QuadPart = 50 };               // 50 ms
T2_SET_PARAMETERS p = { .Version = 0, .NoWakeTolerance = 50 * 10000 };

NTSTATUS st = NtSetTimer2(hTimer, &due, &period, &p);

// Cargo: windows-sys = "0.59" (Win32_System_Threading, Win32_Foundation)
use windows_sys::Win32::System::Threading::{SetThreadpoolTimer, PTP_TIMER};
use windows_sys::Win32::Foundation::FILETIME;

unsafe fn arm(t: PTP_TIMER) {
    let mut due: FILETIME = std::mem::zeroed();
    // Negative => relative 100ns; -50_000 == 5 ms.
    let rel: i64 = -50_000;
    due.dwLowDateTime  = (rel as u64) as u32;
    due.dwHighDateTime = ((rel as u64) >> 32) as u32;
    SetThreadpoolTimer(t, &due, 50 /* period ms */, 100 /* tolerance ms */);
}

Mappings MITRE ATT&CK

• T1027.011Fileless Storagemitre ↗
• T1106Native APImitre ↗
• T1029Scheduled Transfermitre ↗