NtQueryInformationThread

Prototipo

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

Argumentos

IDs de syscalls por versión de Windows

Stub del 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

Notas no documentadas

SSN `0x25` desde Windows 10 1507 — ancla notablemente estable. Dos clases dominan el uso ofensivo. ThreadBasicInformation (0) devuelve un `THREAD_BASIC_INFORMATION` cuyo `TebBaseAddress` expone el TEB del hilo objetivo, vía canónica para derivar PEB / lista de módulos cuando se evitan lecturas relativas a GS (p. ej. con EAF — Export Address Filter — activada en el objetivo). ThreadHideFromDebugger (17) devuelve un BYTE indicando si el bit de ocultación está puesto; esa relectura es el corazón del *chequeo anti-anti-debug* — si tu flag hide aparece misteriosamente a 0, un EDR o herramienta de analista lo borró. ThreadIsTerminated (14) se usa en bucles sleep-mask para despertar pronto si el padre ordena cierre.

Uso común por malware

Cinco recetas prácticas. (1) Bypass de EAF: leer el TEB vía ThreadBasicInformation en lugar de `gs:[0x30]` para no disparar el breakpoint hardware que la mitigación EAF coloca sobre el acceso al PEB. (2) Anti-anti-debug: establecer ThreadHideFromDebugger y consultarlo justo después — si la relectura es 0, un ntdll instrumentado se está tragando silenciosamente el set. (3) Despertar sleep-mask: sondear ThreadIsTerminated en un hilo hermano para coordinar el cierre sin objeto de evento. (4) Sondeo ThreadStartAddress (clase 9) para recorrer otros hilos y elegir blancos de inyección que parezcan workers legítimos (RPC, RuntimeBroker). (5) Recorrer EPROCESS vía TEB → PEB → LDR para enumerar módulos sin tocar kernel32!GetModuleHandle.

Oportunidades de detección

No hay señal ETW por llamada para las consultas (a diferencia de NtSetInformationThread estableciendo ThreadHideFromDebugger, que sí se registra). La detección debe centrarse en efectos secundarios: enumeraciones que tocan cada hilo de procesos remotos, o secuencias NtSetInformationThread(17) seguidas *inmediatamente* por NtQueryInformationThread(17) sobre el mismo handle en microsegundos — patrón anti-anti-debug típico. Las reglas ASR / Network Protection de Defender no lo cubren; la señal más limpia es un hook EDR sobre ntdll!NtQueryInformationThread filtrado por ThreadInformationClass == 0 o == 0x11 desde llamantes fuera de DLL del sistema.

Ejemplos de syscalls directos

// 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 }
}

Mapeos MITRE ATT&CK

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