Skip to main content

Google Chrome CVE-2026-113013

| EUVDEUVD-2026-105767 HIGH
Buffer Overflow (CWE-119)
2026-10-20 chrome-cve-admin@google.com GHSA-95x4-8vfv-v89f
8.8
CVSS 3.1 · Vendor: google
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Lure victim to crafted HTML page
  2. Exploit
    Trigger DevTools memory corruption
  3. Execution
    Corrupt memory via buffer overflow
  4. Impact
    Execute 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.4% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

Chrome 156.0.8078.47 <156.0.8078.47

Affected Packages

euvd chrome fix: 156.0.8078.47

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

Vendor (google) PRIMARY 8.8 HIGH
AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
vuln.today AI 8.8 HIGH

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.

3.1 AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (google).

CVSS VectorVendor: google

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
Required
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

3
CVSS changed
Oct 20, 2026 - 23:23 NVD
8.8 (HIGH)
Patch available
Oct 20, 2026 - 23:20 EUVD
CVE Published
Oct 20, 2026 - 22:18 cve.org
HIGH 8.8

DescriptionCVE.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

Why It Matters

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.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.4%
Top 68% exploitable
Prevalence
Ubiquitous
Google Chrome is among the most widely deployed browsers worldwide
Data Quality
4 sources
Confidence: Medium

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact
Medium

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy