NtImpersonateAnonymousToken

Prototipo

NTSTATUS NtImpersonateAnonymousToken(
  HANDLE ThreadHandle
);

Argumentos

IDs de syscalls por versión de Windows

Stub del syscall

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

NtImpersonateAnonymousToken es la primitiva del kernel detrás de `advapi32!ImpersonateAnonymousToken`. Es una de las dos únicas formas en que un hilo puede adoptar una identidad *distinta del token primario de su proceso* sin llamar primero a NtDuplicateToken (la otra es NtImpersonateThread). El SSN deriva en casi cada build — `0xED` en Windows 10 1507, `0x105` en Windows 11 24H2 — porque la tabla de servicios del sistema crece con cada feature release. Desde Windows XP SP2 / Server 2003, el SID `Everyone` **no** está incluido en el token anónimo por defecto (lo controla el valor de registro `EveryoneIncludesAnonymous`); la impersonación produce por tanto un contexto realmente desprivilegiado.

Uso común por malware

Más usado defensivamente que ofensivamente — los implantes lo invocan para *bajar* privilegios temporalmente, p. ej. para comprobar accesos desde una perspectiva no autenticada antes de decidir lanzar una primitiva de elevación. Ofensivamente aparece en algunos exploits de EoP de nicho que abusan de la impersonación en named pipes: un servicio escribe en un pipe bajo impersonación, el cliente malicioso degrada a anonymous a mitad de la conversación para forzar al servicio a un estado de confused deputy. Algunas POC de la familia Potato (notablemente versiones tempranas de SweetPotato y HotPotato) usaron impersonación anonymous como trampolín antes de negociar relay NTLM hacia SYSTEM. Raro en malware commodity.

Oportunidades de detección

Las llamadas a NtImpersonateAnonymousToken desde algo distinto de código RPC/servicio o procesos sandboxed (renderers Chromium, AppContainer) son altamente anómalas y justifican una alerta de alta severidad. El evento Windows Security **4624 con Logon Type 3** y `Account Name: ANONYMOUS LOGON` registra la impersonación resultante. El provider ETW `Microsoft-Windows-Security-Auditing` lo cubre vía la subcategoría Account Logon / Logon Events. Como el SID es bien conocido (S-1-5-7), simples SACL sobre objetos sensibles dirigidas a ANONYMOUS LOGON producen eventos de alta fidelidad. Los EDR hookean comúnmente el thunk de ntdll, pero pocos motores tratan esta llamada como sospechosa por defecto — una detección custom útil.

Ejemplos de syscalls directos

; NOTE: SSN drifts every build — resolve dynamically in production.
NtImpersonateAnonymousToken PROC
    mov  r10, rcx          ; ThreadHandle
    mov  eax, 105h         ; SSN on Win11 24H2
    syscall
    ret
NtImpersonateAnonymousToken ENDP

// Adopt ANONYMOUS LOGON on the current thread to verify that a target
// resource is genuinely unauthenticated-reachable (e.g. SMB null session).
NTSTATUS s = NtImpersonateAnonymousToken(NtCurrentThread());
if (NT_SUCCESS(s)) {
    // The thread is now ANONYMOUS LOGON (S-1-5-7).
    // Any subsequent NtOpenFile / NtOpenKey runs as that identity.
    DoAccessProbe();
    // Revert before doing anything else.
    NtSetInformationThread(NtCurrentThread(),
                           ThreadImpersonationToken,
                           &(HANDLE){NULL}, sizeof(HANDLE));
}

// SSN of NtImpersonateAnonymousToken changes every build — resolve at runtime.
// Halo's Gate falls back to neighbour scanning when ntdll is hooked.
use std::arch::asm;
use std::ffi::CString;
use windows_sys::Win32::System::LibraryLoader::{GetModuleHandleA, GetProcAddress};

unsafe fn ssn_halos_gate(name: &str) -> u32 {
    let ntdll = GetModuleHandleA(b"ntdll.dll\0".as_ptr());
    let c = CString::new(name).unwrap();
    let p = GetProcAddress(ntdll, c.as_ptr() as *const u8) as *const u8;
    if *p == 0x4C && *p.add(3) == 0xB8 {
        // Clean stub: mov r10,rcx ; mov eax,SSN ; ...
        return (*p.add(4) as u32) | ((*p.add(5) as u32) << 8);
    }
    // Hooked: walk neighbours +/- N functions, SSN difference == stub distance/32.
    for n in 1..512u32 {
        for dir in [1i32, -1] {
            let q = p.offset((n as isize) * 32 * dir as isize);
            if *q == 0x4C && *q.add(3) == 0xB8 {
                let neighbour_ssn = (*q.add(4) as u32) | ((*q.add(5) as u32) << 8);
                return ((neighbour_ssn as i32) - (n as i32 * dir)) as u32;
            }
        }
    }
    0
}

#[unsafe(naked)]
unsafe extern "system" fn syscall_thunk(_thread: isize, _ssn: u32) -> i32 {
    asm!("mov r10, rcx", "mov eax, edx", "syscall", "ret", options(noreturn));
}

Mapeos MITRE ATT&CK

• T1134Access Token Manipulationmitre ↗
• T1134.001Token Impersonation/Theftmitre ↗
• T1106Native APImitre ↗