Insufficient validation of untrusted input in Reading Mode in Google Chrome prior to 149

CVE-2026-11213 is an *insufficient validation of untrusted input* flaw in Chrome Reading Mode affecting versions before 149.0.7827.53. Per the CVE record, the attacker must already have *compromised the renderer process* and then use a crafted HTML page to try to turn that foothold into a *sandbox escape*. In practice, this means the bug matters on desktop Chrome fleets, but only as part of a multi-bug browser exploit chain rather than as a clean one-shot compromise.

The vendor's 9.6 CRITICAL label overstates enterprise patch urgency when judged on real-world attack path friction. The decisive downshift is the prerequisite: *renderer compromise first*. That implies the attacker already landed a separate renderer RCE or memory-corruption primitive, so this CVE is not initial access. It is still meaningful because Chrome sandbox escapes are high-value chain components on a ubiquitous client platform, but with no KEV listing, no verified public PoC, and a very low reported EPSS, this lands as *MEDIUM* for fleet prioritization.

Why this verdict

• Baseline downshift: vendor 9.6 assumes full chain impact, but the CVE text itself says the attacker must have *already compromised the renderer process*.
• Attacker position matters: this is not unauthenticated remote initial access; it implies a prior exploit stage inside Chrome, which is strong downward pressure on severity.
• Reachable population is narrower than Chrome's install base: all desktop Chrome users may be *installed*, but only targets where an attacker can first land a renderer bug and then drive Reading Mode are meaningfully exposed.
• Modern controls still have multiple chances to break the chain: browser exploit mitigations, crash telemetry, EDR, and application control can stop either the precondition or post-escape phase.
• No current exploitation amplifier: no KEV listing, no verified public PoC, and a very low reported EPSS argue against treating this like an emergency fleet event.

Why not higher?

A higher rating would require either active exploitation, a public and reliable exploit chain, or a direct unauthenticated path from web content to system compromise. We do not have that here. The need for *prior renderer compromise* is not minor friction; it is the whole reason this is not a standalone CRITICAL from an enterprise patching perspective.

Why not lower?

This is still a browser sandbox escape in Chrome, and Chrome is one of the highest-value client attack surfaces in a large enterprise. If paired with a renderer bug, the blast radius on a single endpoint can become severe quickly. That keeps it above LOW/IGNORE even without exploitation evidence.

1. Enforce rapid Chrome auto-update compliance — Use enterprise browser management to keep desktop Chrome on supported stable builds and detect update failures. For a *MEDIUM* noisgate verdict there is no mitigation SLA — go straight to the 365-day remediation window, but browsers should still be kept near-current because chain bugs age badly.
2. Harden browser execution on high-risk user tiers — Apply stronger controls to admins, developers, executives, and users with sensitive data access: least privilege, browser isolation where available, and tighter application control. This reduces the value of a successful sandbox escape while you work through normal remediation.
3. Monitor browser-to-OS breakout behavior — Tune EDR detections for suspicious Chrome child processes, unusual broker interactions, token access, and sudden browser crash clusters. There is no MEDIUM mitigation SLA, but this detection work is worthwhile fleet hygiene because it catches exploit chains, not just this CVE.
4. Limit risky browsing on privileged endpoints — Keep privileged admin workstations and crown-jewel operator systems off general web browsing where possible. This does not patch the bug, but it lowers the business impact if a browser chain lands on a sensitive host.

Run this on the target endpoint or through your EDR/remote execution tool. Invoke it with python3 chrome_cve_2026_11213_check.py on macOS/Linux or py chrome_cve_2026_11213_check.py on Windows; no admin rights are required for basic version detection, though some locked-down endpoints may need elevated access to read install locations.

#!/usr/bin/env python3
# CVE-2026-11213 Chrome version checker
# Output: VULNERABLE / PATCHED / UNKNOWN
# Exit codes: 0=PATCHED, 1=VULNERABLE, 2=UNKNOWN

import os
import platform
import re
import subprocess
import sys
from shutil import which

FIXED = (149, 0, 7827, 53)


def parse_version(text):
    m = re.search(r'(\d+)\.(\d+)\.(\d+)\.(\d+)', text or '')
    if not m:
        return None
    return tuple(int(x) for x in m.groups())


def version_to_str(v):
    return '.'.join(str(x) for x in v)


def run_cmd(cmd):
    try:
        p = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=10)
        out = (p.stdout or '') + ' ' + (p.stderr or '')
        return out.strip()
    except Exception:
        return ''


def find_linux_version():
    candidates = [
        'google-chrome', 'google-chrome-stable', 'chromium', 'chromium-browser'
    ]
    for c in candidates:
        path = which(c)
        if path:
            out = run_cmd([path, '--version'])
            v = parse_version(out)
            if v:
                return ('linux', path, v)
    return None


def find_macos_version():
    candidates = [
        '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
        os.path.expanduser('~/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'),
        '/Applications/Chromium.app/Contents/MacOS/Chromium'
    ]
    for path in candidates:
        if os.path.exists(path):
            out = run_cmd([path, '--version'])
            v = parse_version(out)
            if v:
                return ('macos', path, v)
    return None


def find_windows_version():
    powershell = which('powershell') or which('pwsh')
    if not powershell:
        return None

    ps_script = r"""
$paths = @(
  "$Env:ProgramFiles\Google\Chrome\Application\chrome.exe",
  "$Env:ProgramFiles(x86)\Google\Chrome\Application\chrome.exe",
  "$Env:LocalAppData\Google\Chrome\Application\chrome.exe",
  "$Env:ProgramFiles\Chromium\Application\chrome.exe",
  "$Env:ProgramFiles(x86)\Chromium\Application\chrome.exe"
)
foreach ($p in $paths) {
  if (Test-Path $p) {
    try {
      $v = (Get-Item $p).VersionInfo.ProductVersion
      Write-Output "$p|$v"
      exit 0
    } catch {}
  }
}
exit 1
"""
    out = run_cmd([powershell, '-NoProfile', '-Command', ps_script])
    if '|' in out:
        path, ver = out.split('|', 1)
        v = parse_version(ver)
        if v:
            return ('windows', path.strip(), v)
    return None


def main():
    system = platform.system().lower()
    result = None

    if 'windows' in system:
        result = find_windows_version()
    elif 'darwin' in system:
        result = find_macos_version()
    else:
        result = find_linux_version()

    if not result:
        print('UNKNOWN - Chrome/Chromium not found or version unreadable')
        sys.exit(2)

    os_name, path, version = result

    # This check is version-based only; it does not validate whether Reading Mode is enabled/reachable.
    if version < FIXED:
        print(f'VULNERABLE - {os_name} {path} version {version_to_str(version)} is older than fixed {version_to_str(FIXED)}')
        sys.exit(1)
    else:
        print(f'PATCHED - {os_name} {path} version {version_to_str(version)} is at or above fixed {version_to_str(FIXED)}')
        sys.exit(0)


if __name__ == '__main__':
    main()

Sources

1. CVE record mirror with CNA details and references
2. Google Chrome early stable desktop update to 149.0.7827.53/.54
3. Google Chrome Releases index
4. Chromium issue reference 507382702
5. CISA Known Exploited Vulnerabilities Catalog
6. FIRST EPSS overview
7. FIRST EPSS API documentation
8. Censys scanning FAQ