NtCallEnclave

Prototyp

NTSTATUS NtCallEnclave(
  PVOID    Routine,
  PVOID    Parameter,
  BOOLEAN  WaitForThread,
  PVOID   *ReturnValue
);

Argumente

Syscall-IDs pro Windows-Version

Syscall-Stub

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

`NtCallEnclave` ist der **World-Switch**-Call. Intern führt er ein `EENTER` auf SGX bzw. einen `VMCALL` in den Secure Kernel für VBS aus — beides überträgt schließlich die logische CPU des Host-Threads in VTL1 mit gespeichertem Stack-/Register-Kontext. Die Enklaven-Routine läuft mit einem *frischen* Stack innerhalb des reservierten Enklaven-Bereichs; sie kann den VTL0-Host-Speicher niemals direkt anfassen. Datenaustausch: die Enklave liest `Parameter` (eine VTL0-Adresse, die der Secure Kernel beim Eintritt marshallt) und liefert einen Wert per `*ReturnValue`. Wiedereintritt ist durch `ThreadCount` aus `NtInitializeEnclave` begrenzt. Der User-Mode-Wrapper `CallEnclave` ist ein dünner Shim um diesen Syscall — er holt `Routine` aus der Export-Tabelle der Enklave.

Häufige Malware-Nutzung

Dies ist der Call, der **Angreifer-Code in VTL1 ausführt**, aber erst nachdem die Create/Load/Initialize-Kette die Signaturprüfungen bestanden hat. Realistische Missbrauchswege: (1) eine *Microsoft-signierte* Enklave mit präparierten Parametern aufrufen, die eine bekannte Schwachstelle triggern — die Enklave führt dann Angreifer-Logik mit VTL0-EDR-Blindheit aus; (2) eine *Research-Loader*-Enklave (z. B. der Yuste / Soriano-Salvador-Stub) aufrufen, die in `Parameter` absichtlich einen beliebigen Shellcode-Pointer akzeptiert und in VTL1 dorthin springt. Einmal drin, kann die Enklave `NtCallEnclave` mit `Routine = Adresse außerhalb der Enklave` nutzen, um zurück in den Host zu rufen (der `CallEnclave`-Mechanismus ist bidirektional); diesen Weg nutzt Recon-Class-Research, um normale Syscalls (z. B. `NtAllocateVirtualMemory`) aus der Enklave abzusetzen. EDR sieht den Host-Syscall, kann ihn aber nicht dem Enklaven-Thread zuordnen.

Erkennungs­möglichkeiten

Direkte Telemetrie aus dem Enklaven-Inneren ist von VTL0 aus unmöglich — by design. Stattdessen pivotieren auf (a) die *Frequenz* von `NtCallEnclave` pro Prozess (legitime Trustlets rufen es in stabiler Kadenz; ein Angreifer-Tool zeigt oft einen Burst zum Angriffszeitpunkt), (b) das *Callout*-Muster: eine Enklave, die sofort zurück in VTL0 ruft, um `NtAllocateVirtualMemory`/`NtWriteVirtualMemory` aufzurufen, ist verdächtig. Der ETW-Provider `Microsoft-Windows-Kernel-Memory` (Event 5) traced Enklaven-Entries/Exits, ist aber nicht standardmäßig aktiv — auf wertvollen Endpoints aktivieren. Aus einem Kernel-Driver heraus existiert `KeRegisterEnclaveCallback` *nicht*; den Enklaven-Call können Sie aus einem normalen Driver nicht abfangen. Das Signal muss aus der Host-Syscall-Sequenz kommen.

Direkte Syscall-Beispiele

// Final step of a minimal enclave session: invoke a named export inside the enclave.
// 'enclaveBase' came from CreateEnclave; 'EnclaveEntry' is exported by the signed enclave DLL.
#include <windows.h>

typedef int (*PENCLAVE_ENTRY)(void *param);

int InvokeEnclave(PVOID enclaveBase, PVOID hostRequest) {
    PENCLAVE_ENTRY entry = (PENCLAVE_ENTRY)GetProcAddressForCaller(
        enclaveBase, "EnclaveEntry");
    PVOID retVal = NULL;
    if (!CallEnclave(entry, hostRequest, TRUE /*WaitForThread*/, &retVal)) {
        return -1;
    }
    return (int)(INT_PTR)retVal;
}

; Direct syscall stub for NtCallEnclave (SSN 0x93 on Win11 24H2 / Server 2025)
; SSN was 0x91 from Win10 2004 through Win11 23H2 — stable for ~5 years.
NtCallEnclave PROC
    mov  r10, rcx          ; Routine
    mov  eax, 93h          ; SSN
    syscall
    ret
NtCallEnclave ENDP

// Cargo: windows-sys = { version = "0.59", features = ["Win32_System_Threading"] }
use std::ptr::null_mut;
use windows_sys::core::BOOL;

extern "system" {
    fn CallEnclave(
        routine: *const core::ffi::c_void,
        param: *mut core::ffi::c_void,
        wait_for_thread: BOOL,
        ret: *mut *mut core::ffi::c_void,
    ) -> BOOL;
}

pub unsafe fn call_enclave_entry(
    routine: *const core::ffi::c_void,
    request: *mut core::ffi::c_void,
) -> Option<*mut core::ffi::c_void> {
    let mut ret: *mut core::ffi::c_void = null_mut();
    if CallEnclave(routine, request, 1 /*TRUE*/, &mut ret) == 0 {
        return None;
    }
    Some(ret)
}

MITRE ATT&CK-Mappings

• T1620Reflective Code Loadingmitre ↗
• T1574Hijack Execution Flowmitre ↗
• T1106Native APImitre ↗