Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft malicious WPF pixel-shader bytecode
-
DeliveryDeliver via crafted app or document
-
ExploitDesync CPSTrans::Initialize parsing passes
-
ExecutionTrigger heap out-of-bounds write
-
ImpactExecute code in user context
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires the victim to open or execute crafted WPF content containing malicious pixel-shader bytecode that desynchronizes the two parsing passes in CPSTrans::Initialize (CVSS UI:R confirms required user interaction). The affected component is the WPF desktop runtime (Microsoft.WindowsDesktop.App.Runtime) on Windows, so only applications built on .NET/.NET Framework WPF are exposed - pure server-side or non-WPF .NET workloads are not in the vulnerable code path. Limiting factors: user interaction is mandatory (no drive-by/zero-click or automatable mass exploitation, confirmed by SSVC Automatable=no), code executes in the context of the user running the WPF application rather than at elevated privilege (S:U), and the target must be running an unpatched affected version (e.g., .NET 9.0.0-9.0.20, 10.0.0-10.0.12, or affected .NET Framework builds). |
| Impact | This is a genuine, high-priority vulnerability but not an emergency. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, 8.8 High) indicates a network-reachable, low-complexity, unauthenticated memory-corruption flaw with full confidentiality/integrity/availability impact, which aligns with the CWE-787 out-of-bounds write and the GHSA description of heap OOB writes in WPF's CPSTrans::Initialize pixel-shader parser. However, several signals temper the raw score: the vector requires user interaction (UI:R), so this is not a wormable, zero-click network exploit - it is content-driven RCE that needs a victim to open or run crafted WPF content. The SSVC framework corroborates lower urgency: Exploitation=none (no observed exploitation), Automatable=no (cannot be mass-automated, consistent with the UI:R requirement), though Technical Impact=total (matches the C:H/I:H/A:H). There is no CISA KEV listing and no POC/exploit-code indicator in the provided data, so exploitation status is 'no public exploit identified at time of analysis.' Net assessment: patch on a normal priority cadence - the total technical impact and ubiquity of .NET warrant timely remediation, but the user-interaction requirement and absence of any exploitation evidence mean this is not a drop-everything scenario like an automatable unauthenticated server RCE. |
| Exploit ScenarioDerived | An attacker crafts malicious WPF pixel-shader bytecode (e.g., embedded in a .NET desktop application, document, or downloadable content) designed to desynchronize the two parsing passes in CPSTrans::Initialize. The victim opens or runs the crafted WPF content, triggering a heap out-of-bounds write that corrupts memory and leads to arbitrary code execution in the context of the user running the application. No public exploit code is identified at time of analysis, and the low attack complexity (AC:L) suggests reliable exploitation is feasible once a working primitive is developed. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 14, 2026
Remote code execution in Microsoft's Windows Desktop (WPF) runtime lets an unauthenticated attacker execute arbitrary code in the context of a victim who opens crafted WPF content containing a malicious pixel-shader. The flaw is a heap out-of-bounds write (CWE-787) in the shader-processing routine CPSTrans::Initialize, triggered when crafted pixel-shader bytecode desynchronizes the component's two parsing passes; per the CVSS vector the attacker needs no credentials (PR:N) but the victim must interact with the malicious content (UI:R), and exploitation yields code execution at the user's privilege level rather than elevated (S:U), which is why the independent assessment rates this as high priority but not an emergency. Affected software spans .NET 8.0 (<8.0.32), 9.0 (<9.0.21), 10.0 (<10.0.13), 11.0 preview/RC builds before 11.0.0-rc.2, multiple .NET Framework 3.5/4.6.2-4.8.1 servicing branches on Windows, and Visual Studio 2022 17.14 (<17.14.42) and Visual Studio 2026 18.10 (<18.10.4). No public exploit code has been identified and there is no KEV listing at time of analysis, but vendor patches are available and should be applied promptly given the ease of triggering (AC:L) once a user opens the file.
RemediationAI
Vendor-released patches are available; the primary fix is to upgrade to the patched build for each affected branch - .NET 9.0.21 (from 9.0.0-9.0.20), .NET 10.0.13 (from 10.0.0-10.0.12), .NET 11.0.0-rc.2 (from 11.0.0-preview.1-11.0.0-rc.1), and .NET 8.0.32 or later for the 8.0 line - by updating the Microsoft.WindowsDesktop.App.Runtime NuGet packages (win-x64/win-x86/win-arm64) and any runtime bundling them, then redeploying self-contained or framework-dependent applications built against them. For .NET Framework installations, install the corresponding Windows servicing updates so that the reported builds reach 4.8.4811.0 (4.8), 4.8.9363.0 (4.8.1), 4.7.4150.0 (4.6.2/4.7/4.7.1/4.7.2), and 2.0.50727.9073 / 3.0.30729.9070 (or 2.0.50727.8987 / 3.0.30729.8982 for the 3.5 branch); note these updates require a restart and can be applied broadly through Windows Update or WSUS. Developer tooling should be updated to Visual Studio 2022 17.14.42 and Visual Studio 2026 18.10.4 respectively. Until patching completes, the most effective compensating control is to prevent untrusted pixel-shader bytecode from reaching the WPF effect pipeline: do not open, preview, or load WPF documents/packages/shader resources (.ps blobs, XAML/BAML applications, or Visual Studio projects containing them) from untrusted or externally sourced locations, and, where the application is under your control, validate, re-author, or rebuild shaders from trusted HLSL source rather than accepting precompiled bytecode from users - the trade-off is that legitimate custom shader content will be rejected or must be recompiled. Additionally, running WPF applications with least privilege (non-administrator) limits the impact of successful exploitation, since the flaw executes in the user's security context (S:U), and enabling attack-surface-reduction/Mark-of-the-Web controls that block execution of content downloaded from the internet provides defense in depth at the cost of some user friction. Full technical details and vendor guidance are at https://msrc.microsoft.com/update-guide/vulnerability/CVE-2026-70007 and https://github.com/dotnet/wpf/security/advisories/GHSA-pfwj-2f93-rf42.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 12 packages in nuget, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The vulnerable code lives in the WPF (Windows Presentation Foundation) desktop runtime shipped as Microsoft.WindowsDesktop.App.Runtime and, for older codebases, in .NET Framework's WPF assemblies on Windows. WPF's effects pipeline accepts pixel-shader bytecode - the compiled shader blob consumed by ShaderEffect/PixelShader and similar APIs - and CPSTrans::Initialize is the routine that translates/validates that bytecode. According to the upstream GitHub Security Advisory (GHSA-pfwj-2f93-rf42), a single crafted blob can desynchronize the two parsing passes inside CPSTrans::Initialize, so the second pass operates on state that no longer matches the first pass's assumptions; the result is a heap out-of-bounds write (and, per the same advisory, out-of-bounds read) with attacker-influenced offset/length. CWE-787 (Out-of-Bounds Write) is the root-cause class: missing or inconsistent bounds validation of attacker-controlled shader metadata rather than a logic error in a network protocol. Because the input is normally delivered as a file, package, or embedded resource that the target application loads, the CVSS vector is AV:N with UI:R - remote delivery, but with mandatory user interaction - and the outcome is full confidentiality, integrity, and availability impact within the victim user's security context (C:H/I:H/A:H, S:U). The CPE/version data shows the fix is branch-wide across the .NET runtime families (net8.0, net9.0, net10.0, net11.0-preview) and across the legacy .NET Framework 3.5/4.x servicing stacks, consistent with the same WPF shader-handling defect being backported to every supported Windows .NET Framework build. Only applications that actually host WPF and render shader effects are in the vulnerable code path; server-side or non-WPF .NET workloads that never touch this component are not exposed.
Know when the next one hits your stack
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
Network-delivered crafted content (AV:N) needs no privileges (PR:N) but requires the victim to open it (UI:R); reliable heap OOB write yields full in-process impact (C/I/A:H), scope unchanged as code runs as the user.
Primary rating from Vendor (microsoft).
CVSS VectorVendor: microsoft
Lifecycle Timeline
2DescriptionCVE.org
Out-of-bounds write in .NET Framework allows an unauthorized attacker to execute code over a network.
Technical POC Analysis
Evidence basis: advisory GHSA-pfwj-2f93-rf42 only.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A high-severity remote code execution vulnerability in Microsoft's Windows Desktop (WPF) runtime allows an attacker to run arbitrary code at the signed-in user's privilege level when that user opens crafted WPF content, such as a malicious document or application page. Because exploitation requires the victim to interact with the content and does not grant elevated rights, the practical exposure is concentrated in end-user workstations and developer machines rather than backend servers. Leadership should care because remediation touches several independent product lines - multiple .NET releases, .NET Framework servicing branches, and Visual Studio installations - so the main risk is incomplete patch coverage rather than a single missed update.
Apply vendor patch.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.
EUVD-2026-100196
GHSA-pfwj-2f93-rf42
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB