NtImpersonateAnonymousToken

Prototyp

NTSTATUS NtImpersonateAnonymousToken(
  HANDLE ThreadHandle
);

Argumente

Syscall-IDs pro Windows-Version

Syscall-Stub

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

Undokumentierte Hinweise

NtImpersonateAnonymousToken ist die Kernel-Primitive hinter `advapi32!ImpersonateAnonymousToken`. Sie ist eine von nur zwei Möglichkeiten, mit denen ein Thread eine andere Identität als das primäre Token seines Prozesses übernehmen kann, ohne zuvor NtDuplicateToken aufzurufen (die andere ist NtImpersonateThread). Der SSN driftet bei nahezu jedem Build — `0xED` auf Windows 10 1507, `0x105` auf Windows 11 24H2 — weil die System-Service-Tabelle mit jedem Feature-Release wächst. Seit Windows XP SP2 / Server 2003 ist die SID `Everyone` standardmäßig **nicht** im anonymen Token enthalten (gesteuert über den Registry-Wert `EveryoneIncludesAnonymous`); die Impersonation liefert daher einen tatsächlich deprivilegierten Kontext.

Häufige Malware-Nutzung

Defensiv weit häufiger als offensiv genutzt — Implants rufen sie auf, um Privilegien temporär *abzusenken*, etwa um Zugriffsprüfungen aus unauthentifizierter Sicht zu testen, bevor entschieden wird, ob eine Eskalations-Primitive ausgelöst wird. Offensiv taucht sie in einigen Nischen-EoP-Exploits auf, die Named-Pipe-Impersonation missbrauchen: Ein Dienst schreibt unter Impersonation in eine Pipe, der bösartige Client degradiert mitten im Gespräch auf anonymous, um den Dienst in einen Confused-Deputy-Zustand zu zwingen. Einige Potato-POCs (insbesondere frühe SweetPotato- und HotPotato-Builds) nutzten anonyme Impersonation als Sprungbrett vor einem NTLM-Relay auf SYSTEM. Selten in Commodity-Malware.

Erkennungs­möglichkeiten

Aufrufe von NtImpersonateAnonymousToken aus anderem Code als RPC/Service oder sandboxed Prozessen (Chromium-Renderer, AppContainer) sind hochgradig anomal und rechtfertigen einen Alert hoher Schwere. Windows-Security-Event **4624 mit Logon Type 3** und `Account Name: ANONYMOUS LOGON` protokolliert die resultierende Impersonation. Der ETW-Provider `Microsoft-Windows-Security-Auditing` erfasst sie über die Subkategorie Account Logon / Logon Events. Da das SID wohlbekannt ist (S-1-5-7), liefern einfache SACL-Einträge auf sensiblen Objekten gegen ANONYMOUS LOGON hochpräzise Events. EDRs hooken typischerweise den ntdll-Thunk, doch nur wenige Engines behandeln diesen Aufruf standardmäßig als verdächtig — eine nützliche Custom-Detection.

Direkte Syscall-Beispiele

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

MITRE ATT&CK-Mappings

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