Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLure victim to crafted HTML page
-
ExploitTrigger DevTools memory corruption
-
ExecutionCorrupt memory via buffer overflow
-
ImpactExecute arbitrary code within renderer sandbox
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, buffer size validation
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 load attacker-controlled HTML that exercises the Chrome DevTools code path, so DevTools functionality must be engaged for the crafted page to trigger the memory corruption. No authentication is needed (PR:N confirmed by CVSS), but user interaction is required (UI:R) - the victim must be induced to open the malicious page. The most important limiting factor is that successful exploitation yields code execution only INSIDE the Chromium sandbox (S:U, vendor-confirmed), not on the host; absent a separate sandbox-escape the attacker cannot reach the operating system, which is why Chromium rates the issue Low. Affected builds are Chrome versions prior to 156.0.8078.47, so patched installations are not exploitable. |
| Impact | Signals conflict sharply here and that tension is the core of the assessment. The NVD CVSS 3.1 base score is 8.8 (High) with vector AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, which on its face suggests a remotely triggerable, low-complexity, no-privilege arbitrary-code-execution bug. However, Google/Chromium explicitly rates this a LOW severity issue, and the description is the reason: the memory corruption in DevTools allows code execution 'inside the sandbox' via a crafted HTML page. This is a sandboxed renderer-level compromise, NOT a sandbox escape - the scope is Unchanged (S:U), consistent with the attacker remaining confined to the Chromium sandbox and NOT gaining host-level code execution. That gap between an 8.8 numeric score and a vendor 'Low' rating should be treated as a real divergence, not a scoring error: by itself this flaw does not breach the security boundary that protects the operating system, so in practice it would need to be chained with a separate sandbox-escape vulnerability to achieve meaningful host impact. On exploitation maturity, there is no public exploit identified at time of analysis - the CVE is not listed in CISA KEV, no POC is referenced, and no EPSS value is supplied in the input, so exploitation probability cannot be quantified from the data given. Authentication requirements are confirmed from the CVSS vector (PR:N = unauthenticated), but exploitation requires user interaction (UI:R) - the victim must open or be lured to a crafted page. SSVC-style framing is not provided in the input and cannot be reconstructed reliably. Net judgment: despite the High CVSS number, this is a lower-priority issue in isolation because it yields only sandboxed execution; it becomes a genuine priority only as one link in an exploit chain, and no active-exploitation or POC signal elevates it today. |
| Exploit ScenarioDerived | A remote, unauthenticated attacker lures a victim who has Chrome DevTools in use into visiting a crafted HTML page, which triggers the DevTools memory-corruption bug and executes attacker-controlled code within the renderer sandbox. No public exploit is identified at time of analysis, and because execution is confined to the sandbox, a realistic attack would pair this with a separate sandbox-escape to reach the host. Low complexity (AC:L) but requires user interaction (UI:R) to deliver the malicious page. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 21, 2026
Memory corruption in the DevTools component of Google Chrome builds prior to 156.0.8078.47 lets remote attackers execute arbitrary code inside the browser sandbox when a victim opens a crafted HTML page that exercises the DevTools code path. Exploitation is unauthenticated (PR:N per the CVSS vector) but requires user interaction (UI:R), and the vendor-confirmed scope is unchanged (S:U), meaning code execution is confined to the Chromium sandbox rather than the host operating system - which is why Chromium assigns this a Low security severity despite the 8.8 CVSS base score. No public exploit identified at time of analysis, and a vendor patch is available in Chrome 156.0.8078.47; the sharp gap between the NVD-style 8.8 score and the vendor's Low rating is the central judgement call in this case.
RemediationAI
Vendor-released patch: upgrade Google Chrome to 156.0.8078.47 or later, distributed through the normal Stable Channel update (verify via chrome://version and force an update check where auto-update is throttled), per the advisory at https://chromereleases.googleblog.com/2026/10/stable-channel-update-for-desktop_02018666648.html. Because exploitation requires the DevTools code path to be engaged, organizations that do not need developer tooling on managed endpoints can reduce exposure before patching by setting the DeveloperToolsAvailability enterprise policy to 2 (Disable DevTools) - the trade-off is that this breaks legitimate debugging, extension development, and any internal tooling that drives the DevTools Protocol, so scope it to non-developer populations. Setting the policy to 1 (disable DevTools for force-installed extensions only) is a lighter-touch alternative but leaves the surface partially reachable. Do not disable the Chromium sandbox as a performance measure, since the sandbox is the sole control limiting this bug's impact to in-sandbox code execution; keeping site isolation and the renderer sandbox enabled preserves that containment even on unpatched builds. Patch status is confirmed available from the vendor, so no long-term compensating control is required beyond the update.
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-119 improper restriction of operations within the bounds of a memory buffer, occurring in Chrome's DevTools code - the developer tooling subsystem that exposes the Chrome DevTools Protocol (JSON-RPC over a local WebSocket/Debugger endpoint) and renders the DevTools front-end inside the browser. Because the corruption is reachable through a crafted HTML page only when DevTools functionality is engaged, the practical attack surface is narrower than a typical renderer bug: the victim must both load attacker-controlled content and have the relevant DevTools path active. Chromium's multi-process design then constrains the outcome - the CVSS scope is unchanged (S:U), so a successful trigger yields arbitrary code execution within the renderer/browser sandbox, and reaching the operating system would require a separate, independent sandbox escape that is not part of this CVE. Affected builds are all Chrome versions prior to 156.0.8078.47 according to EUVD; no CPE strings were included in the supplied intelligence, so product identification relies on the vendor advisory and the EUVD version range rather than formal CPE matching.
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 page with no auth (AV:N/PR:N) but requires victim interaction (UI:R); high renderer-context impact yet scope Unchanged (S:U) since execution stays within the sandbox.
Primary rating from Vendor (google).
CVSS VectorVendor: google
Lifecycle Timeline
3DescriptionCVE.org
Memory corruption in DevTools in Google Chrome prior to 156.0.8078.47 allowed a remote attacker to execute arbitrary code inside the sandbox via a crafted HTML page. (Chromium security severity: Low)
Executive ViewAI
Google Chrome builds before 156.0.8078.47 contain a DevTools memory-corruption flaw that could let a crafted web page execute code inside the browser sandbox when a user opens it. The issue affects any employee using an unpatched Chrome build, though sandbox confinement and the absence of identified public exploit code reduce the likelihood of full host compromise. Leadership should prioritize rapid browser patching because Chrome is broadly deployed and the vendor fix is already available.
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.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
EUVD-2026-105767
GHSA-95x4-8vfv-v89f
NVD
CVE.org
EPSS
Exploit-DB