NtOpenProcessToken

Prototype

NTSTATUS NtOpenProcessToken(
  HANDLE       ProcessHandle,
  ACCESS_MASK  DesiredAccess,
  PHANDLE      TokenHandle
);

Arguments

IDs de syscalls par version de Windows

Stub du syscall

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

NtOpenProcessToken est la forme historique de la primitive d'ouverture de jeton, conservée pour la compatibilité source avec l'API NT originale. Les chemins modernes dans `kernel32!OpenProcessToken` appellent en réalité `NtOpenProcessTokenEx` avec `HandleAttributes = 0`. Le SSN dérive énormément selon les builds — de `0x114` sur Windows 10 1507 à `0x133` sur Windows 11 24H2 — ce qui en fait un mauvais candidat pour des SSN codés en dur et un cas d'école pour la résolution dynamique via Hell's Gate / Halo's Gate. En interne, l'appel passe par `SeQueryAuthenticationIdToken` puis `ObOpenObjectByPointer` sur le pointeur EPROCESS->Token.

Usage courant par les malwares

Toujours la première étape d'une chaîne de vol de jeton : ouvrir un processus à haute intégrité (winlogon, services.exe, lsass.exe) avec `TOKEN_DUPLICATE | TOKEN_QUERY`, puis appeler NtDuplicateToken pour forger un jeton d'impersonation SecurityImpersonation, et enfin NtSetInformationThread (ThreadImpersonationToken) ou CreateProcessWithTokenW pour spawner sous l'identité volée. C'est le motif Incognito / Mimikatz `token::elevate` classique, fondement de la plupart des mouvements latéraux post-exploitation observés chez Conti, BlackCat et APT29.

Opportunités de détection

Ouvrir le jeton d'un processus dont vous n'êtes pas propriétaire requiert dans la plupart des cas SeDebugPrivilege — l'événement Windows Security 4672 (Special Privileges Assigned) sur la session de logon appelante est un précurseur solide. L'événement 4663 (object access) avec type d'objet `Token` et 4673 (Sensitive Privilege Use) se déclenchent lorsque l'opération réussit sur un processus privilégié. Le provider ETW `Microsoft-Windows-Kernel-Audit-API-Calls` émet des événements `PsOpenProcessToken`. Les EDR hookent `ntdll!NtOpenProcessToken` ; les syscalls directs contournent les hooks user-mode mais le noyau continue à émettre de l'audit SE_TOKEN_USER côté object-manager sur les processus protégés.

Exemples de syscalls directs

; Direct syscall stub for NtOpenProcessToken — SSN 0x133 on Win11 24H2
; NOTE: SSN varies across builds; resolve dynamically in production.
NtOpenProcessToken PROC
    mov  r10, rcx          ; ProcessHandle
    mov  eax, 133h         ; SSN (Win11 24H2)
    syscall
    ret
NtOpenProcessToken ENDP

// Step 1 of an impersonation chain: open a privileged process token.
// Requires SeDebugPrivilege on the calling thread.
HANDLE hLsass = NULL, hToken = NULL;
OBJECT_ATTRIBUTES oa = { sizeof(oa) };
CLIENT_ID cid = { (HANDLE)(ULONG_PTR)lsassPid, NULL };

NTSTATUS s = NtOpenProcess(&hLsass,
                           PROCESS_QUERY_LIMITED_INFORMATION,
                           &oa, &cid);
if (NT_SUCCESS(s)) {
    // TOKEN_DUPLICATE so we can later forge an impersonation token.
    s = NtOpenProcessToken(hLsass,
                           TOKEN_DUPLICATE | TOKEN_QUERY,
                           &hToken);
    // -> feed hToken into NtDuplicateToken -> NtSetInformationThread
}

// Resolve NtOpenProcessToken SSN at runtime — SSN moves every Windows build.
use std::arch::asm;
use std::ffi::CString;
use windows_sys::Win32::Foundation::HANDLE;
use windows_sys::Win32::System::LibraryLoader::{GetModuleHandleA, GetProcAddress};

unsafe fn ssn_from_export(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;
    // Pattern: 4C 8B D1 B8 ?? ?? 00 00
    assert_eq!(*p.add(0), 0x4C);
    assert_eq!(*p.add(3), 0xB8);
    (*p.add(4) as u32) | ((*p.add(5) as u32) << 8)
}

#[unsafe(naked)]
unsafe extern "system" fn syscall_thunk(
    _process: HANDLE,
    _desired: u32,
    _token_out: *mut HANDLE,
    _ssn: u32,
) -> i32 {
    asm!(
        "mov r10, rcx",
        "mov eax, r9d",   // SSN supplied as 4th arg
        "syscall",
        "ret",
        options(noreturn),
    );
}

Mappings MITRE ATT&CK

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