NtOpenProcessToken

Prototipo

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

Argumentos

IDs de syscalls por versión de Windows

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

Notas no documentadas

NtOpenProcessToken es la forma heredada de la primitiva de apertura de token, conservada por compatibilidad con la API NT original. Las rutas modernas en `kernel32!OpenProcessToken` realmente invocan `NtOpenProcessTokenEx` con `HandleAttributes = 0`. El SSN deriva considerablemente entre builds — de `0x114` en Windows 10 1507 a `0x133` en Windows 11 24H2 — lo que lo convierte en mal candidato para SSN codificados y un caso de manual para resolución dinámica vía Hell's Gate / Halo's Gate. Internamente, despacha a través de `SeQueryAuthenticationIdToken` y `ObOpenObjectByPointer` contra el puntero EPROCESS->Token.

Uso común por malware

Siempre el primer paso de una cadena de robo de token: abrir un proceso de alta integridad (winlogon, services.exe, lsass.exe) con `TOKEN_DUPLICATE | TOKEN_QUERY`, luego llamar a NtDuplicateToken para forjar un token de impersonación SecurityImpersonation, y por último NtSetInformationThread (ThreadImpersonationToken) o CreateProcessWithTokenW para arrancar bajo la identidad robada. Es el patrón clásico Incognito / Mimikatz `token::elevate` y la base de la mayor parte del movimiento lateral post-explotación observado en Conti, BlackCat y APT29.

Oportunidades de detección

Abrir un token sobre un proceso que no es tuyo requiere normalmente SeDebugPrivilege — el evento Windows Security 4672 (Special Privileges Assigned) sobre la sesión de logon llamante es un precursor sólido. El evento 4663 (object access) con tipo de objeto `Token` y 4673 (Sensitive Privilege Use) se disparan cuando la operación tiene éxito sobre un proceso privilegiado. El provider ETW `Microsoft-Windows-Kernel-Audit-API-Calls` emite eventos `PsOpenProcessToken`. Los EDR hookean `ntdll!NtOpenProcessToken`; los syscalls directos evaden los hooks de user-mode pero el kernel sigue emitiendo auditoría SE_TOKEN_USER del object-manager en procesos protegidos.

Ejemplos de syscalls directos

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

Mapeos MITRE ATT&CK

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