Google’s disclosure around the stable release of Chrome 147 follows its usual rapid patching rhythm, but the nature and distribution of vulnerabilities in this release deserve more careful technical examination especially the two critical flaws identified within the WebML subsystem.

Critical WebML Vulnerabilities

Chrome 147 delivers patches for 60 vulnerabilities in total, two of which carry a critical classification: CVE-2026-5858 (heap buffer overflow) and CVE-2026-5859 (integer overflow), both residing in the WebML component. WebML forms part of Chrome’s growing client-side machine learning execution framework, supporting inference tasks, such as model evaluation and tensor operations, directly within the browser environment, frequently utilizing hardware acceleration (e.g., GPU via WebGPU or CPU vectorization paths). This architectural role makes memory safety issues in WebML especially consequential, as these operations process complex, attacker-influenced data structures (e.g., tensors, model graphs, serialized weights).

Heap Buffer Overflow: CVE-2026-5858

The heap buffer overflow (CVE-2026-5858) most likely originates from inadequate bounds validation during memory allocation or tensor manipulation. In real-world exploitation scenarios, this type of flaw can allow an attacker to overwrite neighboring heap memory regions, potentially corrupting object metadata or function pointers. Given Chrome’s multi-process architecture, exploitation would typically begin within the renderer process. However, when paired with additional primitives (e.g., type confusion or use-after-free), this could be escalated into arbitrary code execution inside the renderer sandbox.

Integer Overflow: CVE-2026-5859

The integer overflow (CVE-2026-5859) points to improper handling of arithmetic operations that are most likely involving size calculations for buffers or tensor dimensions. Integer overflows in these contexts frequently produce undersized memory allocations followed by out-of-bounds writes, effectively functioning as a precursor to heap corruption. When combined with controlled input (e.g., malicious ML model payloads delivered through web content), this can constitute a reliable exploitation path.

Bounty Valuations and Remote Code Execution Potential

The $43,000 bounty awarded for each of these vulnerabilities signals both high exploitability and significant potential impact. Within Chrome’s threat model, achieving reliable remote code execution (RCE) typically demands chaining multiple vulnerabilities together: an initial memory corruption flaw in the renderer (such as those described here), followed by a sandbox escape (e.g., via a kernel interface, GPU driver bug, or IPC flaw). While Google has not explicitly confirmed the existence of exploit chains, the critical severity rating strongly suggests these bugs could serve as viable entry points for such multi-stage attacks.

High-Severity Vulnerabilities Across Core Subsystems

Beyond WebML, 14 additional vulnerabilities were rated high severity, spanning core subsystems including WebRTC, V8, WebAudio, Media, ANGLE, Skia, and Blink. Each of these components represents a historically well-targeted attack surface:

  • V8 (JavaScript engine) vulnerabilities commonly involve type confusion, out-of-bounds access, or JIT miscompilation, enabling arbitrary read/write primitives.
  • WebRTC flaws can expose memory corruption vectors through malformed media streams or signaling data.
  • Skia (graphics engine) and ANGLE (OpenGL ES translation layer) are frequent targets for GPU-related exploitation, especially when combined with driver-level weaknesses.
  • Blink (rendering engine) bugs regularly involve DOM manipulation inconsistencies or layout engine memory safety issues.

The concentration of vulnerabilities across these subsystems raises the likelihood of exploit chain construction, where attackers piece together primitives from multiple layers (e.g., V8 → Blink → GPU → kernel).

Additional Vulnerabilities and Use-After-Free Risks

Notably, only two additional vulnerabilities (CVE-2026-5860 and CVE-2026-5861) received comparatively modest bounties of $11,000 and $3,000 respectively, suggesting either reduced exploit reliability or more limited impact. That said, CVE-2026-5874, a use-after-free in the PrivateAI component, earned $11,000, indicating meaningful security implications. Use-after-free conditions are especially hazardous in modern browsers, as they can be leveraged to achieve type confusion and ultimately arbitrary code execution when paired with heap grooming techniques.

The Patch Diffing Window

The absence of any reported in-the-wild exploitation is notable, but should not be read as an indicator of low risk. Historically, Chrome vulnerabilities, particularly those involving memory corruption, are rapidly reverse-engineered by threat actors following patch publication. The interval between patch release and widespread exploitation (the “patch diffing window”) remains a critical exposure period for any systems that have not yet applied the update.

A Broader Pattern of Targeted Complexity

A late-March update addressing 21 vulnerabilities, including an actively exploited zero-day, further underscores the sustained pressure on Chrome’s attack surface. It also reinforces an emerging pattern: attackers are increasingly focusing on complex, high-performance subsystems such as media processing, graphics pipelines, and now machine learning execution environments.

Session Cookie Hardening

Finally, Google’s rollout of enhanced session cookie protections represents a complementary hardening effort at the application security layer. These protections likely involve tighter binding of session cookies to device characteristics or transport-layer properties (e.g., TLS channel binding, SameSite enforcement, or token binding concepts). The goal is to reduce session hijacking exposure in scenarios where attackers exfiltrate authentication cookies (e.g., via infostealers or XSS) and replay them to impersonate legitimate users. Strengthening cookie integrity directly counters a common post-exploitation objective, complementing the browser‘s broader memory safety improvements.

Taken together, Chrome 147 reflects both the expanding functional scope of the modern browser that is introducing fresh attack surfaces like WebML, and the corresponding growth in security complexity. For defenders, swift patch deployment remains critical, especially given the high-value exploitation primitives exposed by these vulnerabilities and the realistic prospects for exploit chain development.