NtAlertThreadByThreadId

Prototyp

NTSTATUS NtAlertThreadByThreadId(
  HANDLE ThreadId
);

Argumente

Syscall-IDs pro Windows-Version

Syscall-Stub

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

In Windows 8 eingeführt und ab Windows 10 stark genutzt als Kernel-Fundament von `WakeByAddressSingle` / `WakeByAddressAll`. Zusammen mit `NtWaitForAlertByThreadId` realisiert das Paar Per-Thread-Alerts, die *kein* benanntes Kernel-Objekt benötigen (kein Event, kein Mutex, kein Semaphor). Der Synchronisationszustand ist nur eine User-Mode-Adresse, die der Kernel in eine per-Prozess-Wait-Table hasht; der Kernel braucht nur die Ziel-TID und macht keinerlei Object-Manager-Lookup, der Dispatch-Pfad ist daher sehr günstig. Slim-Reader/Writer-Locks, das neue `WaitOnAddress` und die moderne Condition-Variable-Implementierung in ntdll sitzen alle auf dieser Primitive.

Häufige Malware-Nutzung

Signalarme Sync für Sleep-Masks, Beacon-Scheduling und Befehls-Pumps. Da kein Kernel-Objekt erzeugt oder benannt wird, gibt es keine `\BaseNamedObjects\…`-Artefakte, die Tools wie ProcessHacker / SystemInformer anzeigen könnten — der Hauptvorteil gegenüber `NtSetEvent` / `NtWaitForSingleObject`. Einige von Cobalt Strike abgeleitete Sleep-Mask-Varianten und neuere Sliver-Scheduling-Backends nutzen `WaitOnAddress` (und damit diesen Syscall), um Worker-Threads zwischen Beacon-Zyklen zu parken. Mitte 2026 ist es weiterhin ein *signalarmes* Malware-Syscall: Derselbe Pfad wird von jedem modernen Win32-Programm benutzt, das SRWLOCK oder std::mutex unter MSVC verwendet — die legitime Last erschlägt jeden bösartigen Anteil.

Erkennungs­möglichkeiten

Praktisch nicht eigenständig erkennbar — `NtAlertThreadByThreadId` wird vom SRWLOCK-Release, Condition-Variable-Wake und jedem `std::mutex`-Unlock unter C++17/20 mit Waiter aufgerufen. EDRs hooken es nicht, weil der Geräuschpegel enorm ist. Der einzig sinnvolle Winkel ist die *Kombination* mit Sleep-Mask-Telemetrie: kurze, periodische Rückkehren von NtWaitForAlertByThreadId gepaart mit NtAlertThreadByThreadId aus einem einzelnen Nicht-System-Thread in einem Prozess, der zusätzlich Beaconing betreibt, *plus* eine reine RX-Code-Region — dort ist der Syscall ein bestätigendes, nie primäres Signal.

Direkte Syscall-Beispiele

// Replace SetEvent on a globally named event with WaitOnAddress/WakeByAddressSingle
// to avoid creating an object visible to handle-listers.
typedef NTSTATUS(NTAPI* fnNtAlertThreadByThreadId)(HANDLE);

void PokeWorker(DWORD workerTid) {
    HMODULE n = GetModuleHandleA("ntdll.dll");
    fnNtAlertThreadByThreadId p = (fnNtAlertThreadByThreadId)
        GetProcAddress(n, "NtAlertThreadByThreadId");
    p((HANDLE)(ULONG_PTR)workerTid);
}

; SSN 0x71 on win11-24h2 / winserver-2025. 0x70 on most prior 20H2+ builds.
NtAlertThreadByThreadId PROC
    mov  r10, rcx
    mov  eax, 71h
    syscall
    ret
NtAlertThreadByThreadId ENDP

// Wake a worker parked in NtWaitForAlertByThreadId without ever instantiating
// a named kernel object. Useful in implants that want to look like a normal
// Win32 program using SRWLOCK.
use windows_sys::Win32::System::LibraryLoader::{GetModuleHandleA, GetProcAddress};

type NtAlertThreadByThreadId = unsafe extern "system" fn(tid: isize) -> i32;

pub unsafe fn wake_worker(tid: u32) -> i32 {
    let n = GetModuleHandleA(b"ntdll.dll\0".as_ptr());
    let addr = GetProcAddress(n, b"NtAlertThreadByThreadId\0".as_ptr()).unwrap();
    let f: NtAlertThreadByThreadId = std::mem::transmute(addr);
    f(tid as isize)
}

MITRE ATT&CK-Mappings

• T1106Native APImitre ↗
• T1027Obfuscated Files or Informationmitre ↗