← cd ../blog

CVE-2026-125350: Chrome XML use-after-free zero-day, exploited in the wild

Google's eighth exploited Chrome zero-day of 2026 is a use-after-free in the XML component (CVSS 8.8, on CISA KEV). Fixed builds for Chrome and Edge, fleet checks, hunting and policy.

Another Chrome zero-day, and another one where the public technical detail amounts to a single line. Google shipped the fix on 9 November with the familiar note that it “is aware that an exploit for CVE-2026-125350 exists in the wild”, and CISA added it to KEV the next day. This post is mostly about fleet work: knowing which browsers you have, making sure they actually restarted onto the fixed build, and covering the other Chromium-based browsers. I won’t speculate on the exploit chain, because nothing reliable about it has been published.

Scope and ethics. This post covers what’s publicly known, version inventory, detection and remediation for endpoints you manage. There’s no PoC, no crafted page and no speculation about exploit internals. Lab validation means checking version reporting and update policy on test machines, not loading malicious content.

At a glance

   
CVE CVE-2026-125350, “Use after free in XML”
Severity CVSS 3.1 8.8 High, AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H (CISA-ADP, via NVD). Chromium severity: High
CWE CWE-416 Use After Free
Fixed in Chrome desktop 157.0.8103.50/.51 (Windows, Mac) and 157.0.8103.50 (Linux), 9 Nov 2026. Extended Stable 156.0.8078.96 (Windows, Mac)
Edge Stable 157.0.4341.46 (9 Nov), Extended Stable 156.0.4314.80 (10 Nov), Android 157.0.4341.53 (11 Nov), per Microsoft
Exploited? Yes. Google confirms an in-the-wild exploit. CISA KEV, added 10 Nov 2026 (federal due date 24 Nov)
Auth / interaction None / the victim has to load attacker-controlled content

Description: what’s actually known

Chrome is Google’s browser, built on the open-source Chromium project, which also underpins Microsoft Edge, Opera, Brave, Vivaldi and many embedded browsers. CISA’s KEV entry explicitly notes that the flaw “could affect multiple web browsers that utilize Chromium”.

The public description, from NVD and Google’s release post, is:

Use after free in XML in Google Chrome prior to 157.0.8103.50 allowed a remote attacker to execute arbitrary code inside the sandbox via a crafted HTML page.

What that tells us:

  • Bug class: use-after-free. Code keeps a pointer to an object after the memory has been freed. If an attacker can get new, controlled data allocated into that slot, the stale pointer then operates on the attacker’s data. In a browser this is a well-worn path from memory corruption to code execution.
  • Component: Google labels it “XML”, meaning the code that handles XML content in the rendering pipeline. Google hasn’t said which code path, and I’m not going to guess.
  • Where code runs: “inside the sandbox”, i.e. in a sandboxed renderer process. On its own, that gives an attacker code execution in a heavily restricted process. Full device compromise normally needs a second, separate bug to escape the sandbox. Google hasn’t said whether this exploit was paired with one.
  • Trigger: a crafted HTML page. Visiting a malicious or compromised site, or rendering attacker content in a malicious ad or embedded frame, is enough. No other interaction needed.

What isn’t public: the vulnerable code path, the exploit, the attacker, the targets and any IOCs. The Chromium bug entries are restricted. Google’s standard note says bug details may stay restricted “until a majority of users are updated with a fix”, and also while a bug in a third-party library that other projects depend on remains unfixed. That second sentence is boilerplate in every Chrome release post, so don’t read it as confirmation that a third-party library is involved. The release post credits Arni Hardarson (Neonix Security), who reported on 12 October, and an anonymous reporter on 6 November.

This is the eighth exploited Chrome zero-day Google has patched in 2026, according to BleepingComputer’s count.

Impact

  • Arbitrary code execution in the renderer sandbox from simply loading a page.
  • Used in real attacks before the patch was available.
  • Highest risk: users who browse untrusted content on privileged machines (admins, developers, finance), and any service that renders untrusted HTML with headless Chromium, such as PDF generators, link preview or scraping workers, and test harnesses. Those often run older bundled builds with weaker sandboxing.

Which browsers are exposed

Browser / channel Fixed build Source
Chrome Stable, Windows / Mac 157.0.8103.50 / .51 or later Chrome Releases, 9 Nov
Chrome Stable, Linux 157.0.8103.50 or later Chrome Releases, 9 Nov
Chrome Extended Stable, Windows / Mac 156.0.8078.96 or later Chrome Releases, 9 Nov
ChromeOS Stable 16836.33.0 (browser 156.0.8078.102) lists the fix Chrome Releases, 13 Nov
Edge Stable 157.0.4341.46 or later Microsoft Edge security release notes
Edge Extended Stable 156.0.4314.80 or later Microsoft Edge security release notes
Edge for Android 157.0.4341.53 or later Microsoft Edge security release notes
Chrome for Android / iOS, Opera, Brave, Vivaldi, Electron/CEF apps, distro chromium packages Not confirmed here. Check each vendor —

Chrome 158 has since been promoted to Stable (17 Nov), so the practical target is “current Stable”, and anything at or above those numbers in the same branch is fine. The Chrome for Android 157.0.8103.50 release post on 9 November only mentions “stability and performance improvements”, so I couldn’t confirm the Android fixed build from Google’s posts.

Identifying affected systems

The number that matters is the version running in the browser process. Chrome downloads updates in the background, but they only take effect after a relaunch, so many “updated” machines are still running the old code.

# Linux
google-chrome --version; chromium --version 2>/dev/null
dpkg -l google-chrome-stable 2>/dev/null | tail -n1 || rpm -q google-chrome-stable
# was the browser restarted after the update? compare start time with package install time
ps -eo pid,lstart,cmd | grep -E '[c]hrome' | grep -v -- '--type=' | head -n3

# macOS
defaults read "/Applications/Google Chrome.app/Contents/Info.plist" CFBundleShortVersionString
defaults read "/Applications/Microsoft Edge.app/Contents/Info.plist" CFBundleShortVersionString
# Windows
(Get-Item "$env:ProgramFiles\Google\Chrome\Application\chrome.exe").VersionInfo.ProductVersion
(Get-Item "${env:ProgramFiles(x86)}\Microsoft\Edge\Application\msedge.exe").VersionInfo.ProductVersion
# per-user installs live under %LOCALAPPDATA%\Google\Chrome\Application

For a fleet, use what you already have:

  • Chrome Enterprise Core (Browser Cloud Management) and the Edge management service both report browser versions per device. Filter for anything below the fixed build.
  • EDR, MDM or software inventory (Intune, Jamf, SCCM, osquery). In osquery, the programs (Windows) and apps (macOS) tables carry installed versions.
  • Headless and embedded Chromium: search build manifests and images for puppeteer, playwright, chromium, electron and cef, and check what Chromium version each ships.
  • Users can confirm at chrome://version / edge://version.

Safe validation in an isolated lab

Nothing here needs a malicious page:

  1. On a test VM, install a pre-fix build (156.x Stable or 157 before .50) and the current build side by side, or on two VMs.
  2. Confirm your inventory or scanner flags only the old one, and that it reads the running version, not just the file on disk. Update the old one without relaunching and see what each tool reports.
  3. Apply your relaunch policy (below) to the test OU and confirm the browser actually restarts within the deadline.
  4. If you have headless Chromium in CI or services, run the version check inside those containers and confirm they’re part of your patch pipeline.

Detection and threat hunting

No IOCs, payload hashes or attacker infrastructure have been published for this CVE, so hunting is generic:

  • Renderer crashes. Clusters of Chrome or Edge renderer crashes on the same domain across several users, especially before the patch landed. Check crash reporting or chrome://crashes on suspected machines.
  • Unexpected child processes of the browser. chrome.exe / msedge.exe / chrome spawning cmd.exe, powershell.exe, rundll32.exe, mshta.exe, sh, bash, curl or osascript is abnormal and would suggest a successful sandbox escape on top of the renderer bug. Most EDRs have a built-in rule for this; make sure it’s enabled and alerting.
  • Proxy and DNS logs. Look for newly registered or rare domains visited just before any such alert, and for unusual frames or ad-delivery chains.
  • Unpatched-window exposure. Prioritize investigating high-value users whose browsers stayed below the fixed build after 9 November.

Remediation

  1. Update and relaunch. Chrome to 157.0.8103.50/.51 or later (now 158 Stable), Extended Stable to 156.0.8078.96 or later, Edge to the builds above. The relaunch is the step people forget.
  2. Enforce relaunch with policy. Chrome’s RelaunchNotification (set to required) and RelaunchNotificationPeriod, or Edge’s equivalent policies, put a deadline on it.
  3. Check for update blockers. Remove or raise any TargetVersionPrefix pin, and make sure no GPO has disabled Google Update / Edge Update.
  4. Other Chromium browsers. Check Opera, Brave, Vivaldi and distro chromium packages against their vendors’ notes.
  5. Embedded Chromium. Rebuild services and CI images that bundle Chromium (Puppeteer, Playwright, Electron, CEF) once their upstream ships the fix, and don’t render untrusted HTML in them in the meantime unless the process is isolated.

Interim measures

There’s no configuration workaround from Google. Until devices relaunch, reduce exposure where you can: block uncategorized and newly registered domains at the proxy, keep ad blocking enabled in managed browser policy if that fits your environment, and don’t let admins browse the web from privileged workstations.

References

Verify every version against the vendor advisory before acting. Published 11 Nov 2026.