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.
3 steps from start to impact.
Victim visits attacker-controlled page
- 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
- 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
WebGPU shader triggers uninitialized memory read
- Attacker has JavaScript execution in the victim's browser
- Dawn allocates a GPU buffer previously used by a different origin without clearing it
- 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
Cross-origin data exfiltrated
- Attacker can read back the GPU buffer to JavaScript
- Network egress is available from the victim's browser
- 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
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.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.- 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.
The supporting signals.
| In-the-Wild Exploitation | None 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 Availability | No 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 Score | 0.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 Status | Not listed. No known exploitation mandating emergency federal patching. |
| CVSS Vector Interpretation | CVSS: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 Versions | Google 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 Version | Chrome 149.0.7827.53 (stable, released June 4, 2026). Edge and other Chromium derivatives typically follow within days. |
| Disclosure Timeline | Disclosed 2026-06-04 via Chrome stable channel update. Last modified 2026-07-23. Chromium bug ID: 500443031. |
| Reporting Researcher | Reported by an anonymous researcher through the Chrome Vulnerability Rewards Program. No named individual or team credited in the advisory. |
| Related Dawn CVEs | Part 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.
- CVE-2026-11101 — CyberStrike Detail
- CVE-2026-11101 — OpenCVE
- Chrome 149 Patches 429 Vulnerabilities — SecurityWeek
- Chrome 149 Security Update — Cyber Security News
- CVE-2026-11101 — CVE.org Official Record
- Chromium Bug Tracker — Issue 500443031
- CVE-2026-7983 Dawn Cross-Origin Leak Analysis — Windows News
- Chrome 149 Update Resolves 18 Severe Vulnerabilities — SecurityWeek
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.
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
# 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
}