The original public exploit for CVE-2025-21333 spawns C:\Windows\System32\WindowsSandbox.exe, calls NtQueryInformationProcess on the child, reads its PEB through ReadProcessMemory, and string-parses a 16-byte GUID out of its command line. The new PoC, published this month, calls one method on a Microsoft COM class and gets the same GUID. The COM class is CLSID_IsolatedAppLauncher, the documented programmatic entry point to Microsoft Defender Application Guard. The kernel bug it satisfies is an integer-truncation overflow in vkrnlintvsp.sys whose only nontrivial precondition is the GUID.
CVE-2025-21333: The Defender Hands Out the VmId
vendor
pattern
cve
proof of concept
The kernel bug needs a VmId. That is the only nontrivial precondition.
CVE-2025-21333 is an integer-truncation heap overflow in vkrnlintvsp.sys, the Hyper-V Kernel Integration VSP driver Windows loads when Windows Sandbox, Microsoft Defender Application Guard, or related Hyper-V container features are enabled. The vulnerable syscall is NtCreateCrossVmEvent. The caller passes a SECURITY_DESCRIPTOR whose DACL contains an AclSize field of type WORD. The driver computes the marshalled-ACL allocation size through a path that truncates that 16-bit value, then copies bytes at the declared size into the resulting PagedPool chunk. The chunk is smaller than the copy. The bytes past the end land on whatever the PagedPool allocator placed next.
Both public PoCs use the same construction. Spray Windows Notification Facility state-data objects at 0x30 bytes each via NtCreateWnfStateName and NtUpdateWnfStateData. Punch holes by deleting every fiftieth state. Trigger the overflow with NtCreateCrossVmEvent and an ACL whose AceSize has been overwritten to 0xfff0 - sizeof(ACL):
PACL acl = (PACL)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 0x10000);
InitializeAcl(acl, 0xfff0, ACL_REVISION);
AddAccessAllowedAce(acl, ACL_REVISION, GENERIC_ALL, everyoneSID);
((ACCESS_ALLOWED_ACE*)((char*)acl + sizeof(ACL)))->Header.AceSize = 0xfff0 - sizeof(ACL);
// ... wrap in SECURITY_DESCRIPTOR, pass via OBJECT_ATTRIBUTES ...
NTSTATUS status = NtCreateCrossVmEvent(&CrossVmEvent, EVENT_ALL_ACCESS, &objattr, 0, &VmId, &VmId);The overflow writes forged pool headers and forged _WNF_STATE_DATA structures into the next several WNF objects, marking those slots with DataSize = 0xf0 and a recognizable sentinel. Read the corrupted slots back via NtQueryWnfStateData to identify them. Free one and immediately call NtFsControlFile to allocate a named-pipe attribute (NpAt pool tag) in the freed position. Free the next and call CreateIoRing plus BuildIoRingRegisterBuffers to allocate an IoRing register-buffer array (IrRB pool tag) in the position after that.
The attacker now controls one slot in an IoRing's registered-buffer array and reads the named pipe's Flink through the corrupted WNF state above it. From there the standard Yarden Shafir technique applies: forge an IOP_MC_BUFFER_ENTRY with Type = 0xc02, Size = 0x80, and an attacker-chosen Address, point the IoRing's buffer slot at it, and BuildIoRingReadFile / BuildIoRingWriteFile perform kernel reads and writes at that address. The exploit ends with KWrite over the current process token's Privileges.Present and Privileges.Enabled at offsets 0x40 and 0x48, both set to 0xffffffffffffffff, then system("cmd.exe"). The shell that opens is SYSTEM.
Every step in this chain is unprivileged from vkrnlintvsp.sys's perspective. The driver does not check whether the caller is an administrator. It checks whether the caller passes a valid VmId GUID. The two public PoCs share everything downstream of that check. They diverge entirely on how to obtain the GUID.
What MrAle98 had to do to get the VmId
The original public exploit, MrAle98/CVE-2025-21333-POC, was published on 2025-02-27. The Microsoft advisory for CVE-2025-21333 was published on 2025-01-14 and was marked "Exploitation Detected" by MSRC. MrAle98's PoC arrived six weeks after the patch.
The PoC spawns Windows Sandbox and reads the child process's memory:
if (!CreateProcessA("C:\\Windows\\System32\\WindowsSandbox.exe", NULL, NULL, NULL,
FALSE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi)) {
printf("[-] WindowsSandboxClient.exe process not found\n");
}
// NtQueryInformationProcess for ProcessBasicInformation
// ReadProcessMemory on PEB.ProcessParameters
// ReadProcessMemory on ProcessParameters.CommandLine
// strstr() for "<ContainerId>" and extract the 36-byte GUID literalThe console capture committed in the original repository shows what the command line of the spawned WindowsSandboxClient.exe contains:
[*] commandline = C:\Windows\system32\WindowsSandboxClient.exe
<ContainerId>19a1ef14-ee35-47d8-8bdb-cf4c86272272</ContainerId>
<AccountUser>WDAGUtilityAccount</AccountUser>
<AccountPassword>66387310-a27d-4a59-a688-3ab018388c9e</AccountPassword>
<AudioInputEnabled>true</AudioInputEnabled>
<ClipboardRedirectionEnabled>true</ClipboardRedirectionEnabled>
...The container GUID is the field the exploit needs. The fields next to it are the WDAGUtilityAccount username and a per-launch plaintext password, transmitted to the sandbox client as command-line XML. The exploit ignores them. They are still in the command line. ReadProcessMemory from an unprivileged sibling on the same session retrieves all of them. The Sandbox-host command line was designed under the assumption that command-line memory is local to a process; the assumption is false for callers on the same desktop.
The MrAle98 README states: "It is necessary to turn on the windows sandbox feature so that the vulnerable syscalls are handled by the vulnerable driver." Without Sandbox enabled, vkrnlintvsp.sys is not loaded and NtCreateCrossVmEvent is unreachable. The PoC depends on Sandbox being enabled and on WindowsSandbox.exe spawning successfully. Each spawn creates a process-tree event a defender can index against: an unsigned binary parents WindowsSandbox.exe, which parents WindowsSandboxClient.exe. A SOC writing detection rules on this CVE would target that parent-child relationship.
What nu1lptr0 had to do to get the VmId
The new PoC, nu1lptr0/CVE-2025-21333, was published on 2026-05-06. Fourteen months after MrAle98's. Its heap groom is more aggressive (the IoRing spray submits requests during creation rather than after). Its GUID acquisition is the substantive change. The relevant function in main.cpp:
GUID GetGuid()
{
GUID containerId;
HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
IIsolatedProcessLauncher* launcher = nullptr;
hr = CoCreateInstance(
CLSID_IsolatedAppLauncher,
nullptr,
CLSCTX_LOCAL_SERVER,
IID_IIsolatedProcessLauncher,
(void**)&launcher
);
if (SUCCEEDED(hr)) {
hr = launcher->GetContainerGuid(&containerId);
// [+] GUID acquired
}
CoUninitialize();
return containerId;
}No process is spawned. No window opens. No WindowsSandboxClient.exe parent-child relationship appears in the process tree. The COM server resolves CLSID_IsolatedAppLauncher to a signed Microsoft binary that runs out-of-process under svchost.exe. The unprivileged caller observes one CoCreateInstance succeed and one GetContainerGuid return a populated GUID. The exploit then proceeds with the same kernel chain MrAle98 documented.
The PoC's README explains the substitution as a stability improvement: "It is more stable and little sketchy as it doesn't open windows sandbox process for getting the GUID. I used Microsoft Defender Application Gaurd(MDAG) api for getting the guid of the sandbox process."
The label "sketchy" applies to spawning WindowsSandbox.exe and parsing its command line. The replacement is the documented programmatic entry point to a Microsoft security feature.
CLSID_IsolatedAppLauncher is the COM surface Microsoft ships to support its isolation features
The interface declaration lives in IsolatedAppLauncher.h, a header shipped in the Windows SDK and used by Microsoft Edge isolation, the Win32 App Isolation API, and the Microsoft Defender Application Guard runtime. The COM class is registered with the COM service infrastructure as a local-server activation. IIsolatedProcessLauncher::GetContainerGuid is documented as returning the container identifier for the isolated-application launcher. Its intended caller is the trusted shell or host that activated the launcher to start an isolated process.
The interface is not gated by privilege. Any user-mode process running in the same desktop session can CoCreateInstance the class and call GetContainerGuid. The returned value is a real container identifier the kernel will accept. Whether the caller had any legitimate reason to know the identifier is not part of the COM service's contract.
This is security-tool-as-primitive at the OS vendor's own implementation. The pattern names the case where a defensive tool's privileged, supported, signed action provides the attacker with a primitive the attacker would otherwise have to construct. The original PoC constructed the primitive by spawning a process and reading its memory. The new PoC asks Microsoft Defender Application Guard's COM API for the same value. The defender is the helper function.
The blast radius scales with deployment footprint. The IsolatedAppLauncher COM service is present on every Windows 11 endpoint where any of the supported isolation features is installed. Microsoft Defender Application Guard is configured by Group Policy in Microsoft Edge for Business deployments. The COM service answers GetContainerGuid whether or not the caller has any business in an isolated context. The kernel surface in vkrnlintvsp.sys is reachable whenever the Hyper-V container feature is enabled and that COM service is running.
The patch closes the syscall. It does not close the precondition surface.
Microsoft published CVE-2025-21333 on 2025-01-14 in the January 2025 cumulative update. The fix is in vkrnlintvsp.sys. The integer truncation in the ACL marshalling path was corrected, and NtCreateCrossVmEvent no longer underallocates relative to the declared ACL size. The advisory marks the bug as exploited in the wild prior to disclosure. The advisory names no in-wild GUID-acquisition path.
The kernel architecture is unchanged. vkrnlintvsp.sys is still loaded conditionally when a Hyper-V container feature is enabled. The cross-VM event syscall surface is still reachable from unprivileged user mode, gated by GUID possession. The set of public APIs that hand out VmIds has grown over the lifetime of the Windows isolation product family: Windows Sandbox, Microsoft Defender Application Guard, Windows Defender Application Guard for Edge, Win32 App Isolation. Each shipped its own way to provision and identify a container. The MrAle98 PoC used one. The nu1lptr0 PoC used another. The next variant of this bug class in this driver, or in vkrnlintvsp.sys's siblings, will use whichever path is least conspicuous at the time it drops.
The 2025-01-14 patch removes one syscall's overflow. The two public PoCs both target unpatched 23H2. Neither relies on anything novel for the GUID precondition. The original used a Microsoft binary it spawned. The new one uses a Microsoft COM service it called.
The defender that ships with Edge supplies the precondition for the exploit running outside any isolation
A SOC analyst investigating a Windows 11 endpoint where an unprivileged process appears to have acquired SYSTEM privileges has a process tree to read. The tree for the MrAle98 PoC shows WindowsSandbox.exe parented by the suspicious binary, with WindowsSandboxClient.exe parented in turn. The tree for the nu1lptr0 PoC shows the suspicious binary alone, with one transient COM activation in the audit log that did not spawn a child. The IsolatedAppLauncher COM activation is normal Windows behavior on any endpoint where Microsoft's isolation features are installed.
The next variant of CVE-2025-21333 in this driver, or in any sibling driver that gates its user-mode surface on possession of a Hyper-V container GUID, will not require Windows Sandbox to be visibly running. It will not require any process spawn. It will require a COM call to a Microsoft-signed service that exists to support a Microsoft security feature.
The patch closed one syscall. The COM service that provides its only nontrivial precondition is unchanged.