NtAlpcOpenSenderProcess

Prototype

NTSTATUS NtAlpcOpenSenderProcess(
  PHANDLE             ProcessHandle,
  HANDLE              PortHandle,
  PPORT_MESSAGE       PortMessage,
  ULONG               Flags,
  ACCESS_MASK         DesiredAccess,
  POBJECT_ATTRIBUTES  ObjectAttributes
);

Arguments

IDs de syscalls par version de Windows

Stub du syscall

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

`NtAlpcOpenSenderProcess` est le **hook d'identité client autoritatif** du serveur. Après que `NtAlpcSendWaitReceivePort` retourne un `PORT_MESSAGE`, le serveur ne tient que l'en-tête de message — entièrement contrôlé par l'attaquant dans tous les champs *sauf* `ClientId`, que le noyau estampille depuis l'EPROCESS de l'expéditeur à l'envoi. Ce syscall prend ce `ClientId.UniqueProcess` et retourne un vrai `HANDLE` vers l'objet EPROCESS, ouvert avec l'accès demandé. Sert à : (a) vérifier le chemin d'image (`QueryFullProcessImageName`), (b) vérifier le token (`NtOpenProcessToken`), (c) vérifier le niveau de protection (PsProtectedSignerSystem, etc., via `NtQueryInformationProcess(ProcessProtectionInformation)`). L'implémentation noyau `AlpcpOpenSender` valide que le message est bien arrivé sur le port fourni et que l'expéditeur existe encore — les pids ne sont pas réutilisés tant que le message en détient une référence, donc les courses de PID-recycle ne sont pas possibles *via cette primitive*.

Usage courant par les malwares

La primitive en elle-même est bénigne ; les **bugs chez ses appelants** ne le sont pas. Trois classes notoires : 1. **Vérification d'identité oubliée** — un serveur ALPC privilégié (TaskHost, Spooler, DiagTrack) fait confiance à `PORT_MESSAGE.ClientId` pour une décision privilégiée *sans* appeler `NtAlpcOpenSenderProcess` pour canonicaliser. Un attaquant spoofe `ClientId` dans un message forgé et déclenche une action privilégiée. **CVE-2018-8440** (LPE ALPC de SandboxEscaper, Task Scheduler) et plusieurs bugs proches de PrintNightmare étaient des variantes. 2. **Mauvais DesiredAccess** — le serveur ouvre avec `PROCESS_DUP_HANDLE` 'au cas où' puis fuite le handle au client ; le client l'utilise pour injecter dans le serveur. Bug réel dans le service WinHTTP, vers 2020. 3. **TOCTOU d'identité de l'expéditeur** — le serveur ouvre l'expéditeur, lit son chemin d'image puis agit ; entretemps l'expéditeur exec un binaire privilégié via `NtCreateUserProcess` en réutilisant le même pid (rare ; nécessite PROCESS_CREATE_PROCESS). Outillage offensif : la lignée **rpcview** / **alpc-fuzzing** (Clément Rouault, James Forshaw) exerce exactement ce chemin pour cartographier les frontières de confiance côté serveur.

Opportunités de détection

En dehors de `lsass`, `services.exe`, `spoolsv.exe`, du Task Scheduler et d'une poignée de serveurs RPC bien connus, les appels à `NtAlpcOpenSenderProcess` sont rares. Le provider ETW `Microsoft-Windows-Threat-Intelligence` (Defender uniquement) trace les ouvertures de handle avec origine ; `Microsoft-Windows-RPC` montre l'appel RPC correspondant si le serveur utilise LRPC. Chasser les **serveurs privilégiés inattendus** qui ouvrent leurs expéditeurs — un implant user-context prétendant être un serveur RPC émettra ce syscall sur les connexions entrantes d'autres implants. Coupler avec `NtOpenProcessToken` sur le même handle pour attraper le pattern complet de vérification d'identité, puis l'impersonation token aval (`NtAlpcImpersonateClientOfPort` ou `ImpersonateLoggedOnUser`) — ce triplet est la frontière de confiance ALPC classique, et tout appelant hors allowlist Microsoft mérite triage.

Exemples de syscalls directs

// Canonical server-side trust gate: never trust PORT_MESSAGE.ClientId for an
// authorisation decision — always re-derive the sender via NtAlpcOpenSenderProcess.
#include <windows.h>
#include <winternl.h>

NTSTATUS NTAPI NtAlpcOpenSenderProcess(
    PHANDLE, HANDLE, PPORT_MESSAGE, ULONG, ACCESS_MASK, POBJECT_ATTRIBUTES);

BOOL CallerIsSystem(HANDLE serverPort, PPORT_MESSAGE msg) {
    HANDLE hSender = NULL;
    if (NtAlpcOpenSenderProcess(
            &hSender, serverPort, msg,
            0,
            PROCESS_QUERY_LIMITED_INFORMATION,
            NULL) < 0) {
        return FALSE;
    }

    HANDLE hTok = NULL;
    BOOL ok = OpenProcessToken(hSender, TOKEN_QUERY, &hTok);
    if (hSender) CloseHandle(hSender);
    if (!ok) return FALSE;

    BYTE buf[512]; DWORD ret = 0;
    BOOL isSystem = FALSE;
    if (GetTokenInformation(hTok, TokenUser, buf, sizeof(buf), &ret)) {
        PTOKEN_USER tu = (PTOKEN_USER)buf;
        // Compare tu->User.Sid against S-1-5-18 (LocalSystem)
        SID localSystem = {SID_REVISION, 1, {0,0,0,0,0,5}, {18}};
        isSystem = EqualSid(tu->User.Sid, &localSystem);
    }
    CloseHandle(hTok);
    return isSystem;
}

; Direct syscall stub for NtAlpcOpenSenderProcess (SSN 0x89 on Win11 24H2 / Server 2025)
NtAlpcOpenSenderProcess PROC
    mov  r10, rcx          ; ProcessHandle
    mov  eax, 89h          ; SSN
    syscall
    ret
NtAlpcOpenSenderProcess ENDP

// Cargo: ntapi = "0.4", windows-sys = "0.59"
use std::ptr::null_mut;
use windows_sys::Win32::Foundation::HANDLE;

type FnOpenSender = unsafe extern "system" fn(
    *mut HANDLE, HANDLE, *const u8, u32, u32, *const u8,
) -> i32;

pub unsafe fn open_sender_process(
    server_port: HANDLE, msg: *const u8, desired: u32,
) -> Option<HANDLE> {
    let ntdll = libloading::Library::new("ntdll.dll").ok()?;
    let f: libloading::Symbol<FnOpenSender> =
        ntdll.get(b"NtAlpcOpenSenderProcess\0").ok()?;
    let mut h: HANDLE = 0;
    let st = f(&mut h, server_port, msg, 0, desired, std::ptr::null());
    if st < 0 { None } else { Some(h) }
}

Mappings MITRE ATT&CK

• T1068Exploitation for Privilege Escalationmitre ↗
• T1134Access Token Manipulationmitre ↗
• T1559Inter-Process Communicationmitre ↗
• T1106Native APImitre ↗