NtGetCurrentProcessorNumber

Prototipo

ULONG NtGetCurrentProcessorNumber(VOID);

Argumentos

IDs de syscalls por versión de Windows

Stub del syscall

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

Uno de los syscalls más baratos de la tabla NT. El handler del lado kernel lee `KPCR.Prcb.Number` para el CPU actual y lo devuelve como `ULONG` — sin validación de parámetros, sin locking. El equivalente Win32 `GetCurrentProcessorNumber` (en `kernel32.dll`) *no* pasa por este syscall en x64; lee el índice CPU directamente del cache GS-based `KUSER_SHARED_DATA::XState` o vía las instrucciones `RDTSCP` / `LSL` en sistemas donde son fiables, recurriendo al syscall solo en arquitecturas donde el atajo user-mode no es usable. Como resultado, *ver* `NtGetCurrentProcessorNumber` realmente dispararse como syscall es en sí una pequeña anomalía — la mayoría de apps que quieren este valor usan el wrapper Win32 y nunca cruzan a kernel mode.

Uso común por malware

Building block barato y fiable para **detección sandbox / VM**. La técnica: girar un bucle apretado que emita `NtGetCurrentProcessorNumber`, opcionalmente intercalado con `SwitchToThread` o `Sleep(0)`, y trackear el conjunto de números CPU distintos observados. Los hosts bare-metal modernos tienen 4-32 procesadores lógicos y un hilo sin afinidad flotará por la mayoría en milisegundos. Muchas sandboxes (Cuckoo viejo, ciertos perfiles Any.Run, setups VirtualBox por defecto, sandboxes Hyper-V mínimas) exponen solo 1-2 vCPUs al sample analizado para ahorrar recursos — el conjunto observado satura a 1 o 2 números distintos y el implante concluye "sandbox, suprimir". Una variante más sofisticada usa `SetThreadAffinityMask` para *intentar* cada índice CPU y reporta lo que `NtGetCurrentProcessorNumber` devuelve después; en una sandbox restringida el conjunto de afinidad se fuerza hacia abajo. Visto en stages loader **Emotet**, **IcedID**, **Qakbot**, **Smoke Loader**, y una larga cola de crypters commodity. Es *uno entre varios* checks; solo es demasiado ruidoso para accionar.

Oportunidades de detección

La telemetría por llamada es impráctica — `NtGetCurrentProcessorNumber` es demasiado barato y demasiado raro como syscall (vs. el fast path user-mode) para que un evento sea significativo. La señal conductual que funciona es *la combinación*: proceso de corta duración, RDTSC + RDTSCP + CPUID + NtGetCurrentProcessorNumber + NtQuerySystemInformation(SystemBasicInformation) emitidos desde el mismo hilo dentro de los primeros cientos de milisegundos es una huella de probe de sandbox. Defender for Endpoint puntúa esto en la familia de reglas `EvasiveTechnique:Sandbox`. El provider ETW `Microsoft-Windows-Kernel-Audit-API-Calls` no expone este syscall, así que los EDR con callbacks kernel hacen la mayoría del trabajo vía stack-walk del lado syscall raro.

Ejemplos de syscalls directos

; Direct syscall stub for NtGetCurrentProcessorNumber (SSN 0xFC on Win11 24H2 / Server 2025)
NtGetCurrentProcessorNumber PROC
    mov  r10, rcx          ; syscall convention (no args, but follow ABI)
    mov  eax, 0FCh         ; SSN — drifts; resolve dynamically for portability
    syscall
    ret
NtGetCurrentProcessorNumber ENDP

// Spread across CPUs and count how many distinct numbers we ever see.
// Bare-metal: usually saturates to 4+ within a few ms.
// Sandbox: often stuck at 1 or 2.
#include <intrin.h>

int observe_unique_cpus(int budget_iters) {
    unsigned char seen[256] = { 0 };
    int distinct = 0;
    for (int i = 0; i < budget_iters; ++i) {
        ULONG cpu = NtGetCurrentProcessorNumber();
        if (cpu < 256 && !seen[cpu]) { seen[cpu] = 1; distinct++; }
        SwitchToThread();
    }
    return distinct;
}

if (observe_unique_cpus(2000) <= 2) {
    // Likely sandbox. Bail out silently.
    ExitProcess(0);
}

// Cargo: windows-sys = "0.59" (Win32_System_SystemInformation)
// The wrapper avoids the syscall on x64 unless the fast path is unavailable.
use windows_sys::Win32::System::SystemInformation::GetCurrentProcessorNumber;

fn current_cpu() -> u32 {
    unsafe { GetCurrentProcessorNumber() }
}

// Sandbox probe: sample many times and count distinct values.
fn distinct_cpus(samples: usize) -> usize {
    use std::collections::HashSet;
    let mut seen: HashSet<u32> = HashSet::new();
    for _ in 0..samples {
        seen.insert(current_cpu());
        std::thread::yield_now();
    }
    seen.len()
}

Mapeos MITRE ATT&CK

• T1497.001System Checksmitre ↗
• T1497Virtualization/Sandbox Evasionmitre ↗
• T1106Native APImitre ↗