返回资讯中心
外部精选
软件工程
#开发者实时流

Playing It Sfape: Code Execution in Isolated User Mode

This is precisely the kind of workload enclaves were designed for. Even if the VTL0 world is compromised, hashed credentials should remain private, and the code deciding whether two values match should retain its integr…

Hacker News 最新santiago-pl2026/10/20 · 27 天前30 分钟阅读

以下正文同步自 Hacker News 最新,版权归原站所有,已转换为易读排版。

This is precisely the kind of workload enclaves were designed for. Even if the VTL0 world is compromised, hashed credentials should remain private, and the code deciding whether two values match should retain its integrity.

Note that SFAPE.dll is not loaded by a regular Defender process. Its VTL0 host component is SFAPM.dll, an LSA package that exports SpLsaModeInitialize and is loaded by lsass.exe. Running as NT AUTHORITY\SYSTEM, LSASS creates the enclave, loads SFAPE.dll as its primary VTL1 image, and communicates with it through CallEnclave:

On current Windows 11 systems, LSA protection is generally enabled by default (still, some policies, compatibility issues, and installation history can affect the state). LSA protection prevents ordinary processes, including ones running as SYSTEM, from reading or injecting code into LSASS unless they have the required protection level. To sum up, it shouldn’t be possible to sniff communication between LSA and an enclave (contrary to the interesting TotalRecall Reloaded issue affecting Windows Recall).

The builds used throughout this research were:

SFAPE.dll 10.0.26100.8875 84,192 bytes SHA-256 AEFEDEB6A7F84679C192D3C19F6C08C3E508222574AE5C9E3D0E10FD2DECE4AF

vertdll.dll 10.0.26100.8972 216,408 bytes SHA-256 1B5B909DCB4D9DC73A036DDFB9B97A80DA54925DBA72F2C0CCE36C58EDF5D33A

host OS Windows 11 25H2, build 26200.8973

SFAPE exports ten functions: CharactersInput, ClearCc, ClipboardInput, CloseCcHandle, GetCcAttributes, Initialize, MeasurePerformance, SealUnsealCredentials, SetCcTimeStamps, and UserCredentials.

The root bug is in the exported Initialize function. A simplified version of the relevant decompilation looks like this:

... status = (uint32_t *)((uint8_t *)request + 0x30);

configuration = request->configuration; callout = request->callout; context = request->calloutContext; table = request->callbackTable;

if (g_initialized) { *status = STATUS_ALREADY_INITIALIZED; // 0xC0000510 return status; }

EnclaveGetEnclaveInformation(..., &g_enclaveInfo);

if (IsInsideEnclave(request, 0x38)) return STATUS_CONFLICTING_ADDRESSES; ...

On the first call, the function performs extensive validation of the request and many nested callback pointers. On a repeated call, g_initialized is already set, so SFAPE writes the error status through request + 0x30 and returns. Notably, this time there is no address verification - the address can belong to either VTL0 or VTL1. The calling host process controls the request parameter. Therefore, after legitimate initialization, the function gives us the following primitive:

write32(request + 0x30, 0xC0000510)

So… does it really have any impact? Calling this an arbitrary write would be a huge overstatement. The destination is under our control, but the value is fixed, the address must tolerate the surrounding request shape, and only four bytes are written. At first glance, it is not obvious what else can be achieved here.

Before rejecting it as a useless DoS primitive, let’s look at how SFAPE distinguishes host pointers from enclave pointers.

The range validator is used to protect other exports. Before operating on host-supplied pointers, SFAPE.dll uses a common classifier to determine whether an address range overlaps private enclave memory:

bool IsInsideEnclave(uint64_t address, uint32_t size) { uint64_t end = address + size;

if (end < g_enclaveBase || g_enclaveBase + g_enclaveSize < address) return false;

return true; }

The exact decompiler output was less pretty, but that is the relevant logic. A pointer is accepted only when the calculated range lies outside the enclave memory.

In our build, g_enclaveBase is stored at image RVA 0xE868, followed by g_enclaveSize at RVA 0xE870.

This gives our write32 primitive a useful target. Remember that g_enclaveBase is a 64-bit value, so its high DWORD is located at RVA 0xE86C. By placing the repeated-initialization request at RVA 0xE83C, its status field at +0x30 lands exactly on that high DWORD. We can therefore deterministically overwrite the high DWORD with 0xC0000510 and corrupt the entire pointer. After that, ordinary VTL1 pointers compare as if they were outside the cached enclave range. We successfully broke the logic used by SFAPE’s IsInsideEnclave guard function.

By doing this, did we unlock anything useful?

Defeating the range validator made another bug reachable. ClipboardInput accepts a pointer to a host-controlled UNICODE_STRING. Its wrapper validates the descriptor and checks Buffer for MaximumLength bytes. The worker, however, uses Length and later rereads both Buffer and Length before zeroing the plaintext:

// Wrapper ValidateHostRange(text, sizeof(*text)); ValidateHostRange(text->Buffer, text->MaximumLength);

// Worker HashClipboardText(text->Buffer, text->Length); InvokeTelemetryCallout(...); // telemetry callback sync point SecureZeroMemory(text->Buffer, text->Length);

The descriptor remains in writable VTL0 memory throughout the call. The telemetry callback provides a deterministic synchronization point after hashing but before the final SecureZeroMemory. While the enclave thread is blocked in that callback, the host replaces Buffer and Length, then allows the worker to continue. The final primitive becomes:

memset(ptr, 0, length)

Another discovery we made is that SFAPE maintains credential-context objects in a global red-black-tree-like map. The pointer to that map is stored at RVA 0xE060 (therefore its high DWORD is at RVA 0xE064). We can use the above primitive to clear those four bytes. This works as intended only if the original map pointer had a nonzero high DWORD. Otherwise, clearing it would leave the pointer unchanged and we wouldn’t be able to pivot into another memory region.

original map pointer: 0xHHHHHHHHLLLLLLLL after memset(..., 0, 4): 0x00000000LLLLLLLL

The low 32 bits remain unchanged, producing a different address in the low 4 GB range. For the pivot to work, our host process reserves a VTL0 buffer that mirrors the enclave allocation and fills it with pointers to a small synthetic tree node. Spraying every aligned qword means that we do not need to know the original heap pointer’s low 32 bits.

Several exported SFAPE functions accept a 32-bit credential-context handle, resolve it through this red-black-tree-like map, and then trust the object pointer present in the resulting node. The node contains a real handle previously returned by UserCredentials, but its object field resides in VTL0 and remains under our control. We are therefore redirecting the resolution of a legitimate handle rather than inventing one.

This opens up another route. GetCcAttributes eventually performs two reads, and its wrapper copies the results into the VTL0 response:

request->attribute2A8 = *(uint64_t *)(object + 0x2A8); request->attribute2B0 = *(uint64_t *)(object + 0x2B0);

If we pick the right address, such as:

object = source - 0x2A8

we can turn it into a selected 16-byte VTL1 read primitive.

Similarly, SetCcTimeStamps provides the inverse operation, resulting in a controlled 64-bit VTL1 write.

*(uint64_t *)(object + 0x2B0) = request->controlledQword;

Both primitives are constrained. The object helpers access lock bookkeeping before reaching the useful fields. For the write target ptr, the PoC uses:

object = ptr - 0x2B0 write32(ptr - 0x29C, 0xC0000510) // object+0x14: nonzero lock owner SetCcTimeStamps(real_handle, controlled_qword)

The additional write32 invocation makes the helper skip exclusive-lock acquisition, and the new write primitive works as intended. In summary, these are not clean, universal memcpy replacements, but they can be used successfully assuming we pick suitable memory locations or pre-shape their contents.

To recap, at this stage, the chain looks like this:

repeated Initialize | v fixed write32(0xC0000510) | v cached enclave-base corruption | v corrupted IsInsideEnclave | v ClipboardInput TOCTOU -> memset(address, 0, length) | v CC-map pivot -> synthetic object | +-------------------+ | | v v read16 write64

The Valid-Target Table

With controlled read and write primitives on board, the next obvious step is gaining code execution.

Knowing a useful VTL1 function address is not enough. When VTL1 code is requested, CallEnclave enters vertdll, and LdrpIssueEnclaveCall checks the requested address against an inverted list of approved targets known as VertValidTargetTable (VTT). A pointer not present in the table is simply rejected. This is somewhat similar to the standard Control Flow Guard bitmap, but this time the metadata is writable.

For the pinned vertdll build, the relevant writable globals are:

vertdll + 0x2CCB0 uint32 target count vertdll + 0x2CCB8 uint64 target-table pointer

By replacing the table, we can authorize any existing functions and call them. The VTT check itself does not require an entry to be an exported function start, so ROP gadgets can be used as well.

Instead of overwriting the original VTT, our PoC creates a replacement in a verified writable area at the end of SFAPE’s .data section. The host process cannot directly write that private memory, so each qword is written through the write64 primitive. The table pointer and count are then redirected to this new block. The original pointer and count are preserved so that we can restore them later for a clean state.

At that point we could call existing functions from the primary SFAPE image and its approved secondary images, including vertdll. There was still one awkward restriction: an enclave export has the void *function(void *context) format, so CallEnclave directly gives us control over one argument. Enclave exports know how to extract more data from supplied objects, but most other functions simply require more parameters.

Using NtContinue removes that limitation. The technique was originally described in Outflank’s article.

NtContinue restores the registers described by a Windows CONTEXT structure. Controlling CPU registers such as RIP, RSP, RCX, RDX, R8, and R9 lets us call an existing VTL1 routine using the normal x64 calling convention. The first four arguments are supplied in registers, and additional arguments are passed on the stack.

An arbitrary fake stack may be enough for a one-shot gadget sequence, but after the target returns the enclave dispatcher still expects its genuine frame. Guessing or rebuilding that would be rather hard. The cleaner solution is to just capture it.

The PoC first adds RtlCaptureContext to the new VTT and calls it in the active VTL1 thread. The captured state contains a real private stack pointer and the normal return site inside LdrpIssueEnclaveCall. A private copy of the first 0x2A0 bytes of the x64 CONTEXT is then constructed in SFAPE’s writable VTL1 padding.

For a simple call, the important rule is:

controlled RSP = captured RSP - 8

Once our arbitrary function is executed, it sees a valid return address and returns into the untouched live dispatcher path. Control safely returns to VTL0 (whose context was not modified), and we can keep invoking other exports. While this is not a ROP chain, it can be converted into one. At the same time, our current interface is actually more elegant and easier to maintain. The internal helper supports between zero and sixteen arguments.

To confirm proper control, we ran several vertdll tests. We called functions such as GetCurrentThreadId, GetEnabledXStateFeatures, and RtlCompareMemoryUlong, and verified real argument control together with the expected output.

The original read16 and write64 were enough to build the VTT and continuation chain, but they had some constraints. Once the NtContinue calling mechanism was working, vertdll itself provided a much cleaner interface.

Two wrappers at RVAs 0x4090 and 0x40B0 enter a non-exported syscall stub:

mov r10, rcx mov eax, 08000019h syscall ret

The wrappers correspond to:

EnclaveCopyIntoEnclave(vtl1Destination, vtl0Source, length); EnclaveCopyOutOfEnclave(vtl0De

正文由 探How 从来源站点 RSS 同步,内容未经改写;遇到排版缺失或需要图片、视频时请以原文为准。

打开原文
去社区讨论 →