← Back to Feed CACHED · 2026-09-30 01:49:31 · CACHE_KEY CVE-2026-11101
CVE-2026-11101 · CWE-457 · Disclosed 2026-06-04

Uninitialized Use in Dawn WebGPU Engine in Chrome on Windows Leaks Cross-Origin Data

ASSESSED — NOISGATE
Vendor
—
—
—
Reassessed
—
—
—
Verdict: —
Do you agree?
01 · The Real Story

A drafty window in the GPU hallway lets someone in the next room peek at your papers

CVE-2026-11101 is an uninitialized-use flaw in Dawn, Google Chrome's open-source implementation of the WebGPU standard, affecting Chrome on Windows prior to version 149.0.7827.53 (stable channel update June 4, 2026). When Chrome allocates GPU memory for WebGPU shader operations, certain buffers are not zeroed before reuse. A remote attacker who convinces a victim to visit a crafted HTML page can issue timed WebGPU calls that read stale GPU memory belonging to a different origin, leaking cross-origin data such as rendered page content, partial DOM state, or cached texture data. The impact is confidentiality-only — there is no integrity or availability impact, and no path to code execution from this bug alone.

Google rates this Medium (6.5) via Chromium's own severity guidelines, and that label is directionally correct. The CVSS vector assigns C:H (high confidentiality impact) because cross-origin data can include session tokens or rendered banking pages, but I:N/A:N keeps the ceiling low. In practice, Chrome's aggressive auto-update pipeline means the vulnerable population shrinks rapidly after disclosure. The 6.5 base score slightly overstates the real-world risk for managed enterprise fleets where Chrome is centrally updated, but it is reasonable for unmanaged consumer endpoints. noisgate adjusts downward to 5.5 based on the absence of exploitation, no public PoC, and the auto-update factor.

"Browser-only cross-origin data leak in Dawn/WebGPU with no PoC and aggressive auto-update coverage"
02 · The Attack Path

3 steps from start to impact.

STEP 01

Victim visits attacker-controlled page

The attacker must lure a Chrome-on-Windows user to a page they control (or inject script into a page via XSS/ad injection). This is the sole entry point — the vulnerability is entirely client-side and requires active user interaction. The page must load WebGPU content, which means the victim's GPU and driver must support the WebGPU feature flag (enabled by default since Chrome 113).
Conditions required:
  • Victim is running Chrome on Windows < 149.0.7827.53
  • Victim visits attacker-controlled or attacker-injected page
  • WebGPU is enabled (default since Chrome 113)
  • GPU hardware and driver support WebGPU
Where this breaks in practice:
  • Chrome auto-updates on most managed endpoints within 24-72 hours of release
  • Enterprise Chrome policies (CBCM) can force updates and block outdated versions
  • Content Security Policy headers on legitimate sites limit script injection vectors
STEP 02

WebGPU shader triggers uninitialized memory read

The crafted page issues a sequence of WebGPU API calls that allocate and release GPU buffers in a pattern that leaves stale data from a previous origin's rendering in an uninitialized buffer. The attacker's shader then reads this buffer before Chrome's Dawn layer zeroes it. This is a race-condition-like pattern in GPU memory management — not a traditional memory corruption.
Conditions required:
  • Attacker has JavaScript execution in the victim's browser
  • Dawn allocates a GPU buffer previously used by a different origin without clearing it
Where this breaks in practice:
  • Chrome's site isolation (one renderer per origin) limits which origins share GPU process memory
  • The attacker cannot control *which* origin's data leaks — it is whatever was previously in that GPU memory region
  • Data returned is raw GPU texture/buffer fragments, not structured DOM or cookie data
STEP 03

Cross-origin data exfiltrated

The attacker's JavaScript reads the leaked GPU buffer contents via a WebGPU readback and sends them to an attacker-controlled server. The data is GPU-rendered pixel data or partial shader output from a different origin — potentially including rendered text from a banking page, email content, or other visually sensitive information. The attacker must reconstruct useful information from raw pixel/buffer dumps.
Conditions required:
  • Attacker can read back the GPU buffer to JavaScript
  • Network egress is available from the victim's browser
Where this breaks in practice:
  • Leaked data is raw pixels/buffer fragments, not structured data — requires post-processing
  • No guarantee that sensitive data was in the GPU buffer at the right time
  • Network monitoring or DLP may flag large data exfiltration from browser contexts
Detection/coverage: No scanner or EDR specifically detects this attack pattern. Browser-level telemetry (Chrome Enterprise reporting) can confirm version compliance.
03 · Compensating Control

1
MEDIUM 5.5→IGNORE 0.0
SEVERITY REDUCED
Enforce Chrome version compliance via CBCM or MDM — Use Chrome Browser Cloud Management, Intune, or SCCM to enforce minimum version 149.0.7827.53. Block browser launch or flag non-compliant devices. This eliminates the vulnerability entirely on managed endpoints. Deploy within the noisgate remediation SLA of 365 days for MEDIUM — though most fleets should already be past this version given auto-update.
2
MEDIUM 5.5→IGNORE 0.0
SEVERITY REDUCED
Disable WebGPU via Chrome enterprise policy — Set the Chrome policy WebGPUAllowed to false via Group Policy or CBCM. This disables the Dawn/WebGPU pipeline entirely, removing the attack surface. Use this as a temporary mitigation for endpoints that cannot be updated. Note: this breaks WebGPU-dependent web applications (3D visualization, ML inference in browser). No mitigation SLA applies for MEDIUM — go straight to the 365-day remediation window.
3
MEDIUM 5.5→MEDIUM 4.5
Deploy Content Security Policy headers on internal web applications — Ensure internal applications set strict Content-Security-Policy headers to prevent injection of attacker-controlled scripts that could trigger the WebGPU leak. This does not protect against navigation to attacker-controlled sites but hardens internal apps against being used as a pivot. This is defense-in-depth, not a complete mitigation.
4
MEDIUM 5.5→MEDIUM 5.5
Enable Chrome Enterprise reporting for version telemetry — Configure Chrome Enterprise Connectors or CBCM reporting to track browser versions fleet-wide. Identify endpoints still running pre-149 Chrome and prioritize their update. This is a visibility control, not a direct mitigation, but it lets you measure your exposure window.
What doesn't work
  • Network-level blocking (WAF/proxy) — The exploit is delivered via standard HTTPS to any page the user visits. There is no network signature to block unless you block all WebGPU traffic, which is not feasible at the proxy layer.
  • EDR/endpoint detection — No EDR vendor has signatures for WebGPU-based cross-origin memory reads. The exploit runs entirely within the browser's GPU process using legitimate WebGPU API calls. No anomalous process behavior or file drops occur.
  • Site isolation alone — Chrome's site isolation helps but does not fully prevent this bug. The GPU process is shared across origins, and Dawn's buffer management is where the flaw lives — site isolation operates at the renderer process level, not the GPU process level.
04 · Intelligence Metadata

The supporting signals.

In-the-Wild ExploitationNone observed. Not listed in CISA KEV. No reports from Google TAG, Mandiant, or threat intel feeds indicate active exploitation. No GreyNoise or Shodan signatures — this is a client-side browser bug, not a network-scannable service.
Proof-of-Concept AvailabilityNo public PoC found. Checked pocindex.io, GitHub (CVE-2026-11101), ExploitDB, and nuclei templates — no repositories or exploits published as of 2026-09-30. The Chromium bug tracker entry (issues.chromium.org/issues/500443031) is access-restricted.
EPSS Score0.0025 (0.25%) — 16th percentile. Indicates very low predicted exploitation probability within 30 days. Consistent with a medium-severity info-disclosure bug with no public exploit.
CISA KEV StatusNot listed. No known exploitation mandating emergency federal patching.
CVSS Vector InterpretationCVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:N/A:N — Remote, low complexity, no privileges, but requires user interaction (visiting a page). High confidentiality impact only. No integrity or availability impact. Scope unchanged (stays within browser sandbox).
Affected VersionsGoogle Chrome on Windows prior to 149.0.7827.53. Chromium-based browsers (Edge, Brave, Opera) using the same Dawn engine version are likely affected but must be verified per vendor advisory.
Fixed VersionChrome 149.0.7827.53 (stable, released June 4, 2026). Edge and other Chromium derivatives typically follow within days.
Disclosure TimelineDisclosed 2026-06-04 via Chrome stable channel update. Last modified 2026-07-23. Chromium bug ID: 500443031.
Reporting ResearcherReported by an anonymous researcher through the Chrome Vulnerability Rewards Program. No named individual or team credited in the advisory.
Related Dawn CVEsPart of a pattern of Dawn/WebGPU memory safety issues in Chrome 149: CVE-2026-10927 (OOB read, sandbox escape), CVE-2026-11077 (sandboxed code exec), CVE-2026-7983 (cross-origin leak), CVE-2026-5281 (zero-day UAF). This specific CVE is the least severe of the cluster.

Sources.

  1. CVE-2026-11101 — CyberStrike Detail
  2. CVE-2026-11101 — OpenCVE
  3. Chrome 149 Patches 429 Vulnerabilities — SecurityWeek
  4. Chrome 149 Security Update — Cyber Security News
  5. CVE-2026-11101 — CVE.org Official Record
  6. Chromium Bug Tracker — Issue 500443031
  7. CVE-2026-7983 Dawn Cross-Origin Leak Analysis — Windows News
  8. Chrome 149 Update Resolves 18 Severe Vulnerabilities — SecurityWeek
05 · The Call

Final Verdict
= UNCHANGED to MEDIUM (5.5/10)

Why this verdict

  • No exploitation evidence or PoC reduces urgency. EPSS is 0.25% (16th percentile), not in KEV, no public exploit code, no threat intel reports of use. The attack remains theoretical.
  • Chrome auto-update compresses the vulnerability window. In managed enterprise environments using CBCM or Intune, Chrome updates deploy within 24-72 hours. The vulnerable population at any given time is small and shrinking. By September 2026, nearly four months post-patch, residual exposure is negligible on managed fleets.
  • Confidentiality-only impact with no escalation path. The bug leaks GPU buffer fragments — raw pixels and shader data — not structured credentials or tokens. There is no code execution, no sandbox escape, no persistence. The attacker gets noisy, partial visual data from whatever happened to be in GPU memory.
  • User interaction required limits scalable exploitation. Each victim must be individually lured to a malicious page. This is not wormable, not drive-by (still needs a click/navigation), and not chainable to RCE without a separate sandbox escape.
  • Role multiplier: Chrome is an endpoint application, not a high-value infrastructure component. It does not run on domain controllers, hypervisors, CI/CD systems, or network edge appliances in a server role. Even on an admin's workstation, this vulnerability leaks browser-rendered pixel data — it does not provide OS-level access, credential theft beyond what is visually rendered, or lateral movement capability. The blast radius is single-user, single-session, browser-only. No high-value-role floor applies.

Why not higher?

This vulnerability cannot reach HIGH because there is no code execution, no sandbox escape, no integrity or availability impact, and no path to system compromise. The leaked data is raw GPU buffer content — not structured credentials, not file system access, not memory from other processes. Chrome's site isolation further limits cross-origin GPU memory sharing. The absence of any exploitation evidence or PoC after nearly four months confirms this is a low-priority information disclosure.

Why not lower?

Despite the mitigating factors, the CVSS vector's C:H rating is defensible — cross-origin GPU data *can* contain visually rendered sensitive content (banking pages, email bodies, authentication forms). The attack requires no authentication and low complexity from the attacker's perspective once the victim visits the page. Unmanaged devices (BYOD, contractor laptops) may not have auto-update enforced, leaving a tail of vulnerable endpoints. A LOW rating would understate the confidentiality risk on those endpoints.

06 · Verification

Crowdsourced verification payload.

Run this script on each Windows target host where Chrome is installed. No elevated privileges required — it reads the Chrome executable version from the file system. Example invocation: powershell -ExecutionPolicy Bypass -File .\Check-CVE-2026-11101.ps1

noisgate-verify.ps1
POWERSHELLREAD-ONLYSAFE
# Check-CVE-2026-11101.ps1
# Checks if Google Chrome on Windows is vulnerable to CVE-2026-11101
# (Uninitialized Use in Dawn, cross-origin data leak)
# Exit codes: 1 = VULNERABLE, 0 = PATCHED, 2 = UNKNOWN

$fixedVersion = [version]"149.0.7827.53"
$chromePaths = @(
    "$env:ProgramFiles\Google\Chrome\Application\chrome.exe",
    "${env:ProgramFiles(x86)}\Google\Chrome\Application\chrome.exe",
    "$env:LocalAppData\Google\Chrome\Application\chrome.exe"
)

$found = $false
foreach ($path in $chromePaths) {
    if (Test-Path $path) {
        $found = $true
        try {
            $fileVersion = (Get-Item $path).VersionInfo.ProductVersion
            $currentVersion = [version]$fileVersion
            Write-Host "Chrome found at: $path"
            Write-Host "Installed version: $fileVersion"
            Write-Host "Fixed version: $fixedVersion"
            if ($currentVersion -lt $fixedVersion) {
                Write-Host "VULNERABLE - Chrome $fileVersion is below fixed version $fixedVersion" -ForegroundColor Red
                exit 1
            } else {
                Write-Host "PATCHED - Chrome $fileVersion is at or above fixed version $fixedVersion" -ForegroundColor Green
                exit 0
            }
        } catch {
            Write-Host "UNKNOWN - Could not parse version from $path : $_" -ForegroundColor Yellow
            exit 2
        }
    }
}

if (-not $found) {
    Write-Host "UNKNOWN - Google Chrome not found in standard installation paths" -ForegroundColor Yellow
    exit 2
}