Chrome's Eighth Zero-Day of 2026: CVE-2026-125350, a Use-After-Free in XML

A single malicious web page can corrupt memory in Chrome's XML engine and run code inside the sandbox, and Google says it's already being exploited. It's the eighth Chrome zero-day of the year. Here's the bug, the fix, why an un-relaunched browser stays vulnerable, and how to roll it out across a fleet.

3 min readIntermediate

Executive summary. CVE-2026-125350 is an actively exploited use-after-free in Google Chrome's XML handling (the Chromium patch points at libxslt's pattern-matching cache). A crafted web page can free a cached object while an earlier operation still holds its old address, corrupting memory and allowing arbitrary code execution inside the browser sandbox; chained with a sandbox escape it becomes full RCE on the device. Google rates it high (CVSS 8.8) and confirms in-the-wild exploitation without publishing details. The fix is Chrome 157.0.8103.51 (Windows/macOS; .50 on some channels). CISA added it to KEV with a 24 November deadline. It is the eighth exploited Chrome zero-day of 2026. The operational catch: Chrome updates in the background but only applies the fix after a relaunch, so "updated" browsers can still be vulnerable until users restart.

Chrome CVE-2026-125350 XML use-after-free exploitation flow

What it is

Field Detail
CVE CVE-2026-125350
Product Google Chrome / Chromium (XML/XSLT, libxslt)
Type Use-after-free → code execution in the renderer sandbox
Severity High (CVSS 8.8)
Status Exploited in the wild; CISA KEV, deadline 24 Nov 2026
Fixed 157.0.8103.51 (Win/macOS); relaunch required
Milestone 8th exploited Chrome zero-day of 2026

How a web page becomes code execution

Use-after-free is one of the most exploited browser bug classes. In this case:

  1. The victim loads a malicious page containing crafted XML/XSLT.
  2. A nested evaluation frees a cached object in libxslt's pattern-matching cache.
  3. An earlier operation still holds the freed pointer and reuses it, the use-after-free.
  4. The attacker shapes memory so that reuse lets them run code in the renderer sandbox; a second bug (a sandbox escape) turns that into code execution on the host.

Browser zero-days are prized because the delivery is trivial, just get the target to open a link or load a malicious ad, with no further interaction.

Why "relaunch" is the whole game

Chrome's silent updater downloads the fix in the background, but the running browser keeps executing the old code until it's relaunched. On fleets, this is where patch programmes quietly fail: the dashboard says "updated", yet long-lived browser sessions (common on always-on workstations) stay exploitable for days. Force a relaunch, don't just push the update.

Remediation

Now

  1. Update Chrome to 157.0.8103.51 (or later) on Windows and macOS; update Chromium-based browsers (Edge, Brave, etc.) to the build that carries the fix.
  2. Force a relaunch. Use your management tooling (Chrome Browser Cloud Management / policy / MDM) to require a restart, or communicate it clearly; the fix is inert until the browser restarts.
  3. Meet the 24 November KEV deadline for managed estates.

Reduce browser attack surface

  1. Keep auto-updates on and monitor Chrome version compliance (and actual relaunch, not just download).
  2. Consider site isolation and policies that limit risky content; ensure the OS and Chrome sandbox are intact.

Detection and hunting

In-the-wild details aren't public, so focus on version hygiene and post-exploitation:

Signal Why
Chrome processes below the fixed build still running Un-relaunched, still vulnerable
Chrome/renderer crashes on specific pages UAF exploitation often crashes before it succeeds
Chrome spawning unexpected child processes (shells, scripts) Sandbox escape / post-exploitation
New outbound connections or persistence created by a browser session Follow-on activity

The pattern: browsers are the softest edge

Eight exploited Chrome zero-days in a year is a reminder that the browser is an internet-facing application on every endpoint, parsing hostile content all day. The defensive posture isn't exotic: patch fast, relaunch to apply, keep the sandbox healthy, and verify version compliance rather than trusting the updater.

Conclusion

CVE-2026-125350 is an exploited, high-severity browser bug with a simple delivery path. Updating is necessary but not sufficient, the fix only counts after a relaunch, so make "restart Chrome" the explicit, enforced step.

Do this now: push Chrome 157.0.8103.51+, force a relaunch across the fleet, and verify version compliance rather than trusting the background updater.

Related: The Collapsing Patch Window on exploitation speed.

Sources: The Hacker News, CyberInsider, SOCRadar, Deepwatch, Qualys. Fixed-build numbers vary slightly by channel; confirm against Google's Chrome release notes and the CISA KEV entry.

HackersRoot Research · Research team

The HackersRoot research team investigates attack techniques across AI systems, cloud and identity, and enterprise networks, then publishes the detections and hardening guidance that stop them.

More from HackersRoot →

Related research