NtAdjustPrivilegesToken

Prototyp

NTSTATUS NtAdjustPrivilegesToken(
  HANDLE            TokenHandle,
  BOOLEAN           DisableAllPrivileges,
  PTOKEN_PRIVILEGES NewState,
  ULONG             BufferLength,
  PTOKEN_PRIVILEGES PreviousState,
  PULONG            ReturnLength
);

Argumente

Syscall-IDs pro Windows-Version

Syscall-Stub

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

NtAdjustPrivilegesToken ist die Funktion, die `advapi32!AdjustTokenPrivileges` umhüllt. Subtile, aber kritische Eigenheit: Die Funktion liefert `STATUS_SUCCESS` (`0`) zurück, selbst wenn ein oder mehrere angeforderte Privilegien *nicht* gehalten wurden — Aufrufer müssen `GetLastError() == ERROR_NOT_ALL_ASSIGNED` (oder `STATUS_NOT_ALL_ASSIGNED` auf NTSTATUS-Seite) prüfen. Wer das vergisst, produziert stille Eskalations-Bugs in defensiver Tooling. Der SSN ist von Windows 10 1507 bis Windows 11 24H2 **stabil bei `0x41`**, was ihn zum beliebten Eintrag für hartkodierte SSN-Tabellen macht.

Häufige Malware-Nutzung

Pflichtschritt vor jeder Cross-Process-Token-Manipulation: SeDebugPrivilege aktivieren, damit der Implant `NtOpenProcess` auf LSASS oder andere geschützte Dienste anwenden kann. Weitere von Malware häufig aktivierte Privilegien: SeImpersonatePrivilege (für die Potato-Familie zur Impersonation), SeAssignPrimaryTokenPrivilege (für `CreateProcessWithTokenW`), SeTcbPrivilege (LSASS-Stufe), SeBackupPrivilege / SeRestorePrivilege (Registry-Hive-Diebstahl für SAM/SYSTEM-Dumps via `reg save HKLM\SAM`). Mimikatz' `privilege::debug` ist buchstäblich ein Wrapper um diesen Syscall.

Erkennungs­möglichkeiten

Windows-Security-Event **4703** (Token Right Adjusted) protokolliert jede erfolgreiche Privilegien-Anpassung samt aktivierter Privilegien und Aufrufer-Prozess. Event 4672 (Special Privileges Assigned) feuert beim Logon und erneut, wenn sensible Privilegien (SeDebug, SeTcb, SeImpersonate, SeAssignPrimaryToken, SeLoadDriver, SeBackup, SeRestore, SeTakeOwnership, SeCreateToken) in einem neuen Prozess aktiviert werden. Die Korrelation 4703 + nachfolgende 4663/4673 auf LSASS ist ein hochpräzises Muster zur Erkennung von Credential-Dumping. Der ETW-Provider `Microsoft-Windows-Kernel-Audit-API-Calls` erfasst den Aufruf ebenfalls.

Direkte Syscall-Beispiele

NtAdjustPrivilegesToken PROC
    mov  r10, rcx
    mov  eax, 41h          ; SSN stable across all builds
    syscall
    ret
NtAdjustPrivilegesToken ENDP

// Enable SeDebugPrivilege via direct Nt* calls — required before opening LSASS.
HANDLE hToken;
LUID luid;
TOKEN_PRIVILEGES tp = { 0 };

NtOpenProcessTokenEx(NtCurrentProcess(),
                    TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
                    0, &hToken);

LookupPrivilegeValueW(NULL, L"SeDebugPrivilege", &luid);
tp.PrivilegeCount = 1;
tp.Privileges[0].Luid = luid;
tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

NTSTATUS s = NtAdjustPrivilegesToken(hToken,
                                     FALSE,
                                     &tp,
                                     0, NULL, NULL);
// IMPORTANT: also test STATUS_NOT_ALL_ASSIGNED (0x06000000+) — success isn't enough.
if (s == 0x00000106 /* STATUS_NOT_ALL_ASSIGNED */) {
    // Privilege wasn't held — abort the elevation chain.
}

// Tiny helper used right after NtOpenProcessTokenEx, before NtDuplicateToken.
use windows_sys::Win32::Foundation::{HANDLE, LUID};
use windows_sys::Win32::Security::{LookupPrivilegeValueW, TOKEN_PRIVILEGES, SE_PRIVILEGE_ENABLED};

pub unsafe fn enable_privilege(token: HANDLE, name: &str) -> bool {
    let wide: Vec<u16> = name.encode_utf16().chain(std::iter::once(0)).collect();
    let mut luid: LUID = std::mem::zeroed();
    if LookupPrivilegeValueW(std::ptr::null(), wide.as_ptr(), &mut luid) == 0 {
        return false;
    }
    let mut tp = TOKEN_PRIVILEGES {
        PrivilegeCount: 1,
        Privileges: [windows_sys::Win32::Security::LUID_AND_ATTRIBUTES {
            Luid: luid,
            Attributes: SE_PRIVILEGE_ENABLED,
        }],
    };
    // Direct syscall stub elsewhere; signature matches NtAdjustPrivilegesToken.
    extern "system" { fn NtAdjustPrivilegesToken(
        h: HANDLE, disable_all: u8,
        new_state: *mut TOKEN_PRIVILEGES, len: u32,
        prev: *mut TOKEN_PRIVILEGES, ret_len: *mut u32) -> i32; }
    let s = NtAdjustPrivilegesToken(token, 0, &mut tp, 0, std::ptr::null_mut(), std::ptr::null_mut());
    // STATUS_NOT_ALL_ASSIGNED == 0x00000106 — treat as failure for elevation.
    s == 0
}

MITRE ATT&CK-Mappings

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