NtImpersonateAnonymousToken

Prototype

NTSTATUS NtImpersonateAnonymousToken(
  HANDLE ThreadHandle
);

Arguments

IDs de syscalls par version de Windows

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

Notes non documentées

NtImpersonateAnonymousToken est la primitive noyau derrière `advapi32!ImpersonateAnonymousToken`. C'est l'une des deux seules façons pour un thread d'adopter une identité *autre que le jeton primaire de son processus* sans appeler d'abord NtDuplicateToken (l'autre étant NtImpersonateThread). Le SSN dérive presque à chaque build — `0xED` sur Windows 10 1507, `0x105` sur Windows 11 24H2 — car la table de services système s'agrandit à chaque feature release. Depuis Windows XP SP2 / Server 2003, le SID `Everyone` n'est **pas** inclus dans le jeton anonyme par défaut (la valeur de registre `EveryoneIncludesAnonymous` le contrôle) ; l'impersonation produit donc un contexte réellement déprivilégié.

Usage courant par les malwares

Davantage utilisé défensivement qu'offensivement — les implants l'invoquent pour *réduire* temporairement leurs privilèges, par exemple pour tester un contrôle d'accès depuis une perspective non authentifiée avant de décider de déclencher une primitive d'élévation. Côté offensif, il apparaît dans quelques exploits EoP de niche abusant l'impersonation sur named pipes : un service écrit dans un pipe sous impersonation, le client malveillant rétrograde vers anonymous en cours de conversation pour forcer le service en confused-deputy. Quelques POC de la famille Potato (notamment les premières moutures SweetPotato et HotPotato) utilisaient l'impersonation anonymous comme tremplin avant de négocier un relais NTLM vers SYSTEM. Rare dans le malware commodity.

Opportunités de détection

Les appels à NtImpersonateAnonymousToken depuis tout autre chose que du code RPC/service ou des processus sandboxés (renderers Chromium, AppContainer) sont hautement anormaux et justifient une alerte de haute sévérité. L'événement Windows Security **4624 avec Logon Type 3** et `Account Name: ANONYMOUS LOGON` enregistre l'impersonation résultante. Le provider ETW `Microsoft-Windows-Security-Auditing` le couvre via la sous-catégorie Account Logon / Logon Events. Comme le SID est bien connu (S-1-5-7), de simples SACL sur des objets sensibles ciblant ANONYMOUS LOGON produisent des événements à forte fidélité. Les EDR hookent classiquement le thunk ntdll, mais peu de moteurs traitent cet appel comme suspect par défaut — une détection custom utile.

Exemples de syscalls directs

; 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));
}

Mappings MITRE ATT&CK

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