NtQueryInformationThread

Prototype

NTSTATUS NtQueryInformationThread(
  HANDLE          ThreadHandle,
  THREADINFOCLASS ThreadInformationClass,
  PVOID           ThreadInformation,
  ULONG           ThreadInformationLength,
  PULONG          ReturnLength
);

Arguments

IDs de syscalls par version de Windows

Stub du syscall

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

SSN `0x25` depuis Windows 10 1507 — un ancrage remarquablement stable. Deux classes dominent l'usage offensif. ThreadBasicInformation (0) renvoie une `THREAD_BASIC_INFORMATION` dont `TebBaseAddress` expose le TEB du thread cible, voie canonique pour dériver PEB / liste de modules quand on évite les lectures GS-relatives (par ex. avec EAF — Export Address Filter — activé). ThreadHideFromDebugger (17) renvoie un BYTE indiquant si le bit hide est positionné ; cette relecture est au cœur du *check anti-anti-debug* — si votre flag hide est mystérieusement à 0, un EDR ou un outil d'analyste l'a retiré. ThreadIsTerminated (14) sert dans les boucles sleep-mask pour se réveiller dès qu'un arrêt est demandé.

Usage courant par les malwares

Cinq recettes pratiques. (1) Contournement d'EAF : lire le TEB via ThreadBasicInformation au lieu de `gs:[0x30]` pour éviter le breakpoint matériel posé par la mitigation EAF sur l'accès PEB. (2) Anti-anti-debug : poser ThreadHideFromDebugger, puis le relire — si la relecture est 0, un ntdll instrumenté avale silencieusement le set. (3) Réveil sleep-mask : sonder ThreadIsTerminated sur un thread frère pour coordonner l'arrêt sans event. (4) Sonde ThreadStartAddress (classe 9) pour parcourir d'autres threads et choisir des cibles d'injection qui ressemblent à des workers légitimes (RPC, RuntimeBroker). (5) Parcourir EPROCESS via TEB → PEB → LDR pour énumérer les modules sans toucher à kernel32!GetModuleHandle.

Opportunités de détection

Pas de signal ETW par appel pour les requêtes (contrairement à NtSetInformationThread posant ThreadHideFromDebugger, qui est journalisé). La détection doit cibler les effets de bord : énumérations touchant chaque thread d'un processus distant, ou séquences NtSetInformationThread(17) suivies *immédiatement* de NtQueryInformationThread(17) sur le même handle en quelques microsecondes — pattern anti-anti-debug typique. Les règles ASR / Network Protection de Defender ne le couvrent pas ; le signal le plus propre est un hook EDR sur ntdll!NtQueryInformationThread filtré par ThreadInformationClass == 0 ou == 0x11 provenant d'appelants hors DLL système.

Exemples de syscalls directs

// Set the hide flag, then query it back. If the readback returns 0,
// an EDR or analysis tool is silently neutralizing NtSetInformationThread —
// strong signal we're being analyzed.
typedef NTSTATUS(NTAPI* fnSet)(HANDLE, ULONG, PVOID, ULONG);
typedef NTSTATUS(NTAPI* fnQuery)(HANDLE, ULONG, PVOID, ULONG, PULONG);

BOOL HideFlagSurvived(void) {
    HMODULE n = GetModuleHandleA("ntdll.dll");
    fnSet pSet = (fnSet)GetProcAddress(n, "NtSetInformationThread");
    fnQuery pQuery = (fnQuery)GetProcAddress(n, "NtQueryInformationThread");
    pSet((HANDLE)-2, 0x11 /* ThreadHideFromDebugger */, NULL, 0);
    BOOLEAN hidden = FALSE;
    ULONG  rl = 0;
    pQuery((HANDLE)-2, 0x11, &hidden, sizeof(hidden), &rl);
    return hidden != 0;
}

; SSN 0x25 across all modern builds.
NtQueryInformationThread PROC
    mov  r10, rcx
    mov  eax, 25h
    syscall
    ret
NtQueryInformationThread ENDP

// Cargo: windows-sys = "0.59"
use windows_sys::Win32::System::LibraryLoader::{GetModuleHandleA, GetProcAddress};

#[repr(C)]
struct ThreadBasicInformation {
    exit_status: i32,
    teb_base_address: *mut u8,
    client_id: [usize; 2],
    affinity_mask: usize,
    priority: i32,
    base_priority: i32,
}

type NtQueryInformationThread = unsafe extern "system" fn(
    thread: isize, class: u32, info: *mut u8, len: u32, ret_len: *mut u32,
) -> i32;

pub unsafe fn get_self_teb() -> Option<*mut u8> {
    let n = GetModuleHandleA(b"ntdll.dll\0".as_ptr());
    let addr = GetProcAddress(n, b"NtQueryInformationThread\0".as_ptr())?;
    let f: NtQueryInformationThread = std::mem::transmute(addr);
    let mut tbi = ThreadBasicInformation {
        exit_status: 0, teb_base_address: core::ptr::null_mut(),
        client_id: [0; 2], affinity_mask: 0, priority: 0, base_priority: 0,
    };
    let mut rl = 0u32;
    if f(-2, 0 /* ThreadBasicInformation */, &mut tbi as *mut _ as *mut u8,
         core::mem::size_of::<ThreadBasicInformation>() as u32, &mut rl) == 0 {
        Some(tbi.teb_base_address)
    } else { None }
}

Mappings MITRE ATT&CK

• T1622Debugger Evasionmitre ↗
• T1057Process Discoverymitre ↗
• T1106Native APImitre ↗