Blog / Threat Classification · R-ROLE · Correction

The Kernel as Client? Why CVE-2025-21333 Is #2 After All

Part 2 of the Kernel's Role series, corrected. This post was published as the kernel-as-client counter-example to Part 1. The mechanism does not support it: a system-call handler copies a caller-supplied DACL without checking its size. That is inbound request handling. Same structure as Calif. Same cluster.

BK
Bernhard Kreinz
• • Corrected • ~12 min read
Series · The Kernel's Role · Part 2 of 2
Part 1 · Calif M5 · Kernel as Server (#2 → #2) Part 2 · CVE-2025-21333 · Kernel as Server after all (#2, corrected)

Correction, 2026-09-07. The original version of this post classified CVE-2025-21333 as #3 Exploiting Client on the premise that the Hyper-V VSP submits requests to the NT kernel through an I/O ring and mishandles the returned entries. That premise is wrong. Public analyses of the patched driver and the public proof of concept place the overflow in VkiRootAdjustSecurityDescriptorForVmwp(), reached from the user-mode system call NtCreateCrossVmEvent(), where the driver copies a caller-controlled DACL with memmove(pool, Dacl, Dacl->AclSize) and never validates the size. I/O rings and WNF state data appear only afterwards, as heap-grooming and read/write primitives. The vulnerable code handles an inbound request from the attacker. Under R-ROLE that is server role: #2. The article below is rewritten around the actual mechanism; §4 keeps the original argument as the cautionary example it has become. The handbook case study (§13.5.7, Case Study 3) and the CVE/NVD enrichment post were corrected on the same date.

Part 1 of this series took the Calif M5 exploit and showed it cleanly as #2 → #2 — two server-side kernel exploits at a single trust boundary, ending in a root shell. The temptation after a piece like that is to generalise the wrong way: any attack ending in kernel-mode privilege must be #2. This post was written to break that habit, with CVE-2025-21333 — the January 2025 heap-based buffer overflow in the Windows Hyper-V NT Kernel Integration VSP — as the counter-example. It failed. The counter-example was built on a mechanism the CVE does not have, and the failure turns out to teach the role test better than the intended lesson would have.

The bug lives in vkrnlintvsp.sys, the driver behind the Hyper-V NT Kernel Integration VSP that Windows Sandbox and Microsoft Defender Application Guard rely on. It is not reached through a VMBus channel, and not through an I/O ring. It is reached through a system call. A user-mode process on the host calls NtCreateCrossVmEvent() with an OBJECT_ATTRIBUTES structure whose security descriptor carries a crafted DACL. The kernel routes the call to the driver's registered callback, VkiRootCalloutCreateEvent(), which reaches VkiRootAdjustSecurityDescriptorForVmwp(), which allocates a paged-pool buffer and copies Dacl->AclSize bytes into it without checking that size against the allocation. The component is in kernel mode, runs at SYSTEM, and in the interaction where the bug fires it is doing the most server-like thing a kernel does: handling a caller's request.

§ 1 · The chainThe chain, stripped to its structure

A low-privileged user on a Windows host with Windows Sandbox enabled holds the foothold. The attacker issues NtCreateCrossVmEvent() with a security descriptor whose DACL declares a size larger than the data the driver will allocate for it. The driver's callback copies the DACL into the pool buffer and overflows it. The public proof of concept then grooms the paged pool with WNF state data so that the overflow corrupts an adjacent I/O ring buffer-entry array, which yields arbitrary kernel read and write, and from there a SYSTEM token. Control passes to attacker-shaped state at SYSTEM on the host; the boundary from local user to SYSTEM is crossed.

Canonical TLCTC path
... → #2 |[privilege][@local_user→@SYSTEM]| + [DRE: C, I, A]

Antecedent steps establishing the local foothold are out of scope, denoted .... A single #2 step records the server-side overflow in the syscall handler. The intra-system annotation carries the privilege crossing without elevating it to a cluster (R-INTRA-7). Terminal DRE tags follow the System Risk Event on the host.

Note what is not in the path. No #3, despite the original version of this post. No #7 Malware, despite the SYSTEM-level outcome. No hypervisor boundary: this is a host-local elevation, not a guest-to-host escape. Windows Sandbox has to be enabled for the driver's callback to be registered, which makes the sandbox feature a precondition, not the attacker's vantage point. The discipline of the framework is in what it forbids, not just in what it asserts.

§ 2 · RoleThe kernel is a server here

Two facts about the VSP are easy to confuse. It runs at kernel privilege — an architectural fact about where its code executes. And in the specific interaction under analysis it accepts a system call from a less privileged caller and processes the caller's argument — a role fact, governed by direction. The role fact decides.

R-ROLE clarifies role by direction, not privilege. If the vulnerable component accepts and handles inbound requests or stimuli relative to the attacker, the step is #2 Exploiting Server. If it consumes external responses, content, or state relative to the attacker, the step is #3 Exploiting Client. The attacker sent the request. The driver handled it. Server role for the VSP. #2.

This is exactly the Calif structure from Part 1: an unprivileged caller, a system call, a kernel-side handler that trusts a length it was given. The name of the driver — "service provider" — pointed the original analysis toward VMBus and provider/consumer relationships that this bug never touches. The name of a component is not an input to R-ROLE. The failing operation is.

§ 3 · ComparisonSame outcome, same cause

The series was built for this comparison. Set the two paths next to each other.

Part 1 · Calif M5
... → #2 → #2 |[priv][@local_user→@root]|

User-mode caller invokes kernel via syscall. Kernel processes inbound stimulus. Two server-side kernel bugs chained. Outcome: root shell.

Part 2 · Hyper-V VSP
... → #2 |[priv][@local_user→@SYSTEM]|

User-mode caller invokes kernel via syscall. Driver callback copies caller-supplied DACL unchecked. One server-side kernel bug. Outcome: host SYSTEM.

Both end at the highest local privilege on their platform. Both cross the same kind of intra-system boundary. Both are server-side memory-safety failures in code that handles a system call. The series was designed to show two cases that share the consequence-side fingerprint and split on the cause side. What it actually shows is two cases that share both, and differ only in count: Calif needed two separately evidenced exploits (SG-6, Part 1 §3); the VSP case needs one.

That is a less dramatic result and a more useful one. The point of R-ROLE is not that kernels flip roles often. It is that the role has to be read off the failing operation, and the failing operation has to be established from the code path — not from the advisory's prose, and not from the component's name.

§ 4 · The retracted argumentWhy the original said #3, and what a real kernel-as-client case looks like

The original argument ran: the VSP submits operations into an I/O ring shared with the NT kernel; the kernel writes responses back; the overflow fires when the VSP processes the returned entries; therefore the VSP consumes responses, therefore client role, therefore #3. Every link after the first was valid reasoning. The first link was false. I/O rings do appear in this exploit — as the object whose buffer-entry array the public proof of concept overwrites to obtain arbitrary read and write. That is an exploitation primitive chosen by the exploit author, applied after the overflow. It is not the interface through which the vulnerable code is reached, and the driver is not consuming anything through it.

The error has a shape worth naming: the exploitation primitive was mistaken for the vulnerable interface. Advisories do not describe mechanisms. Proof-of-concept write-ups describe exploitation. Neither hands you the failing operation labelled as such. The role test needs the call path from attacker input to the faulty instruction, and that has to be read from the patch diff or the reverse-engineered driver.

The R-ROLE test for any code-imperfection bug. Establish the failing operation from the code first. Then ask which side of that operation the attacker controls relative to the vulnerable code. If the attacker sends and the target handles inbound — #2. If the target fetches and the attacker influences what is fetched — #3. Apply the test to the specific failing operation, not to the component's general purpose, and not to the primitives the exploit uses afterwards.

Reverse the direction and the classification reverses with it — that sentence from the original post remains true; it just needs a real example. A kernel acts as client when it initiates a request and mishandles what comes back: an in-kernel SMB or NFS client parsing a hostile server's response, a USB stack parsing descriptors it requested from a malicious device during enumeration, a driver consuming tables returned by firmware. Those steps are #3 regardless of ring level. Misconception 2 in the handbook — "the kernel is always the server" — stands on its own terms. CVE-2025-21333 is simply not its example.

§ 5 · Not #7Why this is not #7

The outcome includes execution at host SYSTEM privilege. Casual reporting will describe this as "code execution in the kernel." Under R-EXEC, the rule is the same here as it was in Part 1: #7 Malware is recorded if and only if foreign executable content is interpreted, loaded, or executed by the target.

The overflow corrupts existing in-kernel state. The instruction stream that subsequently runs is the host's own already-trusted code, redirected by attacker-shaped data. As with Calif, this is data-only in the structural sense — even if an operational exploit later pivots to shellcode injection or unsigned driver loading. Those would be follow-on steps recorded as their own clusters when they occur. The #2 step itself does not introduce foreign code; it deforms the data state the target's own code executes against. This part of the original post was right, and the CVE/NVD enrichment post — which had appended an unconditional #7 — was corrected to match.

§ 6 · SynthesisThe series synthesis, revised

Reading across the two cases with the verified mechanism in place:

Part 1 · Calif M5 Part 2 · Hyper-V VSP
Locus of vulnerable code XNU kernel, syscall handlers (Ring 0) vkrnlintvsp.sys, syscall callback VkiRootAdjustSecurityDescriptorForVmwp() (Ring 0)
Privilege level of vulnerable code Kernel-mode Kernel-mode
Attacker action Sends inbound syscall Sends inbound syscall (NtCreateCrossVmEvent, crafted DACL)
Vulnerable component's role Server (receives request) Server (receives request)
R-ROLE classification #2 Exploiting Server #2 Exploiting Server #3
Foreign executable content? No (data-only) No (data-only)
R-EXEC result #7 NOT recorded #7 NOT recorded
Boundary crossed local_user → root local_user → SYSTEM
Distinct exploits (SG-6) Two One
Defensive surface Kernel syscall hardening, MTE-class Bounds-check caller-supplied ACL sizes; January 2025 patch; Windows Sandbox / Application Guard off where unused

Nine of those rows now match. The one that differs is the exploit count, which is an SG-6 matter, not an R-ROLE matter. The comparison the series set out to make does not exist in this pair. What the pair does demonstrate is how a role flip gets manufactured: take a component name that sounds like a provider, add an exploitation primitive that sounds like a response channel, and the test produces the wrong answer while every rule is applied correctly. The rules were fine. The input was wrong.

§ 7 · DefenceDefensive consequence

Controls against #2 harden the receiving side: validate inbound arguments, bounds-check every size the caller supplies, restrict the syscall surface, apply memory-safety hardening to handlers. For this CVE that means the January 2025 patch and, on hosts that do not need them, leaving Windows Sandbox and Application Guard disabled so the vulnerable callback is never registered. CISA added the CVE to its Known Exploited Vulnerabilities catalogue on 14 January 2025; it was exploited in the wild before the fix shipped.

The original post recommended validating I/O ring responses and treating returned buffers as untrusted. Those are sound #3 controls. They would not have prevented this bug, because this bug is not on that code path. A defence programme that had followed the original classification would have hardened the wrong surface. That is the practical cost of a wrong cluster, and the reason the mechanism has to be verified before the cluster is assigned.◆

§ 8 · RecordWhat changed in this post

  • Cluster: #3 Exploiting Client → #2 Exploiting Server.
  • Mechanism: "VSP mishandles I/O ring responses from the NT kernel" → unvalidated Dacl->AclSize in a system-call callback; I/O ring and WNF are exploitation primitives.
  • Boundary: |[privilege][@guest_user→@host_SYSTEM]| → |[privilege][@local_user→@SYSTEM]|. Host-local elevation; no VM escape.
  • Weakness: CWE-122 (heap-based buffer overflow), as listed by NVD and CISA.
  • Unchanged: data-only, no #7 (R-EXEC); intra-system operator does not change the cluster (R-INTRA-7); Misconception 2 remains valid.
  • Also corrected on 2026-09-07: handbook §13.5.7 Case Study 3; the CVE/NVD enrichment post (which had appended an unconditional #7); the dual-layer notation post; the CVE extension proposal; cross-references in Part 1 and the Glossary Fix series.

Sources. Microsoft Security Response Center, CVE-2025-21333 (January 2025 Patch Tuesday). CISA Known Exploited Vulnerabilities catalogue, entry added 2025-01-14. Alessandro Iandoli, "CVE-2025-21333 Windows heap-based buffer overflow analysis" and the accompanying proof of concept. PwnFuzz Labs, CVE-2025-21333 breakdown.

Canonical path for this case

... → #2 |[privilege][@local_user→@SYSTEM]| + [DRE: C, I, A]

Series paths, side by side

Part 1: ... → #2 → #2 |[privilege][@local_user→@root]| + [DRE: C, I, A]
Part 2: ... → #2 |[privilege][@local_user→@SYSTEM]| + [DRE: C, I, A]
Part 2 as published 2026-05-15: ... → #3 |[privilege][@guest_user→@host_SYSTEM]| + [DRE: C, I, A]
#2 Exploiting Server CVE-2025-21333 R-ROLE R-EXEC SG-6 Misconception 2 Correction Series

References: TLCTC handbook §13.5.7 Case Study 3 (Hyper-V VSP, CVE-2025-21333 — corrected 2026-09-07 to #2; earlier editions described the VSP as mishandling a kernel response); §13.5.8 Common Misconceptions; v2.1 §4.2.5 R-* Rules and §4.2.4 Semantic Guardrails. Vendor advisory: Microsoft Security Response Center, CVE-2025-21333 (Hyper-V NT Kernel Integration VSP heap-based buffer overflow, January 2025 Patch Tuesday). Vulnerable driver: vkrnlintvsp.sys; vulnerable function: VkiRootAdjustSecurityDescriptorForVmwp(); entry point: NtCreateCrossVmEvent().

TLCTC Framework · v2.1 notation, verified against v2.5 rules · Published under CC BY 4.0