Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLure victim to crafted page
-
DeliveryExploit prior renderer RCE
-
ExploitTrigger UAF in Tracing IPC
-
ExecutionCorrupt browser-process memory
-
PersistEscape Chrome sandbox
-
ImpactExecute code as user
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory lifecycle management
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 that the attacker has already compromised the Chrome renderer process - this is explicitly stated in the CVE description and is the gating prerequisite, meaning the bug is a sandbox-escape primitive rather than a standalone remote vulnerability. The victim must additionally visit and interact with a crafted HTML page (UI:R), and the attack complexity is High (AC:H), indicating non-trivial timing, heap grooming, or state preconditions inside the Tracing component must be met. The affected target is any Chrome desktop install on a version below 149.0.7827.103; patched installs and Chromium downstreams that have rebased are not exploitable. No special non-default configuration is required on the victim side beyond running a vulnerable Chrome build. |
| Impact | Signals here are mixed and point to a serious-but-not-emergency issue. CVSS 8.3 reflects network attack vector, high impact, and a scope change (renderer to browser process), but attack complexity is High and user interaction is Required, both of which dampen real-world exploitability. SSVC confirms this: Exploitation is 'none', Automatable is 'no', and Technical Impact is 'total' - meaning if exploited the consequences are severe, but mass automated abuse is unlikely. Crucially, the CVSS PR:N rating is misleading on its own because the vulnerability description itself requires the attacker to have already compromised the renderer process, so this is realistically a second-stage bug used to chain a sandbox escape onto a prior RCE rather than a standalone remote-unauthenticated exploit. There is no CISA KEV listing, no public PoC reported, and EPSS data was not provided in the input. The bug is not actively exploited as far as available data shows, so this should be patched on Chrome's normal stable-channel cadence rather than treated as an out-of-band emergency, while acknowledging that Chromium sandbox escapes are routinely chained by exploit kits and commercial spyware vendors once public. |
| Exploit ScenarioDerived | A targeted user visits an attacker-controlled or compromised website and is induced to interact with it (the UI:R requirement), which first triggers a separate renderer-side RCE to gain code execution inside the sandboxed renderer. The attacker's renderer-side payload then sends crafted IPC messages to the browser process's Tracing component, triggering the use-after-free to corrupt memory and pivot execution into the browser process, escaping the sandbox and gaining the user's privileges on the host. No public exploit is identified at time of analysis, so realistic abuse currently sits with advanced actors capable of chaining their own renderer bug. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jun 09, 2026
Sandbox escape in Google Chrome prior to 149.0.7827.103 allows a remote attacker who has already compromised the renderer process to break out of the sandbox via a use-after-free flaw in the Tracing component, triggered through a crafted HTML page. No public exploit identified at time of analysis, and SSVC indicates exploitation status is 'none', but the technical impact is rated total because a successful escape grants code execution at browser-process privileges. Google has shipped a fix and rates the underlying Chromium severity as Medium, while the assigned CVSS is 8.3 due to scope change and high CIA impact.
RemediationAI
Update Google Chrome to version 149.0.7827.103 or later on Windows, macOS, and Linux via the stable-channel update described at https://chromereleases.googleblog.com/2026/06/stable-channel-update-for-desktop_0153744567.html - this is the vendor-released patch and the primary fix. Verify the running version via chrome://settings/help and restart the browser to apply the update; in managed environments push the update through Chrome Browser Cloud Management, Group Policy, or the platform package manager. Downstream Chromium-based browsers should be updated as soon as their vendors rebase onto patched Chromium, and embedded runtimes such as Electron and CEF should be upgraded to releases that pick up the fix. As a compensating control while patching, site isolation should be left at its default enabled state (it does not block this bug but constrains what a compromised renderer can reach), and high-risk users can be moved into restrictive profiles or browse with extensions like NoScript/uBlock Origin to reduce exposure to untrusted HTML - at the cost of breaking many sites. Disabling the Tracing subsystem is not a supported user-facing configuration and is not a viable workaround.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The flaw is a CWE-416 use-after-free in Chromium's Tracing subsystem, the instrumentation framework (TraceEvent/Perfetto-backed) used to record performance and diagnostic events across Chrome processes. Use-after-free conditions occur when a freed object's memory is reused while a dangling pointer still references it, which an attacker can groom to gain control of a function pointer or vtable. Because Tracing exposes IPC surface reachable from the renderer, an attacker who already has code execution in the renderer (typically via a prior renderer RCE such as a V8 bug) can drive the Tracing logic in the privileged browser process to free and reuse an object, escaping the renderer sandbox. The affected component is the Chromium browser engine, used by Chrome and many downstream Chromium-based browsers.
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
Sources disagree (Medium–Critical)AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:H/A:H
vuln.today treats the vendor’s rating as authoritative. A higher third-party CVSS (e.g. CISA-ADP) is shown for transparency but does not drive the headline severity.
CVSS VectorVendor: google
Lifecycle Timeline
3DescriptionCVE.org
Use after free in Tracing in Google Chrome prior to 149.0.7827.103 allowed a remote attacker who had compromised the renderer process to potentially perform a sandbox escape via a crafted HTML page. (Chromium security severity: Medium)
Executive ViewAI
Google Chrome versions prior to 149.0.7827.103 contain a sandbox escape vulnerability (CVE-2026-11700) that allows compromised renderer processes to achieve code execution at the browser level-a critical security boundary violation. While no current public exploits exist, the vulnerability poses significant organizational risk across all Chrome users and opens pathways for lateral movement and system-level compromise. Enterprises must prioritize deployment of patched versions to prevent this high-severity threat from becoming an active attack vector.
Vendor-released patch: Chrome 149.0.7827.103.
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
Use-after-free vulnerabilities occur when a program continues to access memory through a pointer after that memory has been deallocated.
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.
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Related Vulnerabilities in Google Chrome Use-After-Free and Memory Safety Flaws
View all 74Same weakness CWE-416 – Use After Free
View allSame technique Denial Of Service
View allVendor StatusVendor
SUSE
Severity: Critical| Product | Status |
|---|---|
| openSUSE Leap 16.0 | Fixed |
| openSUSE Tumbleweed | Fixed |
EUVD-2026-35226
GHSA-gpxh-m862-v6vq
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB