Insufficient validation of untrusted input in Autofill in Google Chrome prior to 149

CVE-2026-11207 is an *insufficient input validation* bug in Chrome Autofill affecting Google Chrome versions before 149.0.7827.53 on desktop, with related Chrome 149 builds rolling out across channels at the end of May 2026. The published description says a remote attacker could *potentially* trigger a sandbox escape via malicious network traffic, which means the interesting outcome is not page-level abuse but breaking out of Chrome's containment boundary.

The 9.6/CRITICAL number is not how I would run this in an enterprise queue. NVD shows that score as CISA-ADP enrichment, while the Chrome-sourced description itself labels the bug's *Chromium security severity* as Medium; that tracks reality better because a sandbox escape is usually valuable only when paired with a separate renderer/code-execution primitive, and there is no public evidence here of in-the-wild use, KEV listing, or a public weaponized chain.

Why this verdict

• Requires a user-driven browser reachability path: this is UI:R, so the attacker does not get unauthenticated server-side reach into your fleet the way they would with an exposed appliance or daemon.
• Looks like a chain component, not clean initial access: a sandbox escape matters most after an attacker has already gained code execution or a strong primitive in the renderer/browser content path; that is major downward pressure on real-world severity.
• No exploitation heat: no KEV listing, no public campaign reporting, and a very low EPSS (0.0009) all argue against emergency treatment.
• Vendor context is calmer than the headline number: Chrome's own description tags the bug as *Chromium security severity: Medium*, while the 9.6 comes from CISA-ADP enrichment rather than Google's published severity language.
• Exposure is broad but not perimeter-broad: Chrome is everywhere, which keeps this from dropping to LOW, but it is still endpoint/browser exposure managed by update rings rather than internet-facing mass exploitation surface.

Why not higher?

I am not taking this to HIGH or CRITICAL because the public evidence does not show active exploitation, KEV status, a public weaponized PoC, or proof that this flaw alone routinely converts web content into host compromise. The chain likely narrows through user interaction and exploit-stage dependencies, which is exactly the kind of compounding friction that should drag a CVSS-first score down.

Why not lower?

I am not pushing this to LOW because a successful browser sandbox escape on an employee endpoint is still strategically valuable. Chrome is ubiquitous, users browse untrusted content all day, and if an attacker does have a compatible chain, the impact can jump from page context to endpoint compromise.

1. Enforce browser auto-update — Use Chrome enterprise policy or your endpoint management stack to force update cadence and prevent version pinning. For a MEDIUM verdict there is no mitigation SLA — go straight to the 365-day remediation window, but browsers are cheap to move, so this should ride your normal managed browser wave rather than linger.
2. Block unmanaged Chrome versions — Use device compliance or software inventory policy to flag and quarantine endpoints still running pre-149.0.7827.53 Chrome after your rollout. This helps especially with VDI gold images, kiosk builds, and long-lived laptops that miss silent updater events; again, for MEDIUM there is no mitigation SLA, so focus on finishing remediation inside the 365-day window.
3. Tighten web delivery controls — Keep Safe Browsing, DNS filtering, secure web gateway inspection, and ad/script control policies enabled because they reduce the chance users ever hit exploit delivery pages. These are worthwhile exposure reducers, but for this severity bucket they support normal remediation rather than an emergency compensating-control deadline.
4. Hunt browser-to-host breakouts — Create or tune detections for unusual Chrome child processes, browser-spawned shells, suspicious file writes from browser processes, and crash clusters around the disclosure window. This does not fix the bug, but it gives you the only meaningful chance to catch successful post-sandbox activity while remediation rolls through.

Run this on the target endpoint or through your EDR/remote execution platform. Invoke it with python3 check_chrome_cve_2026_11207.py on macOS/Linux or py check_chrome_cve_2026_11207.py on Windows; standard user rights are usually enough because it only reads version information from common install paths and the Windows registry.

#!/usr/bin/env python3
# Check Google Chrome version for CVE-2026-11207 exposure
# Outputs exactly one of: VULNERABLE / PATCHED / UNKNOWN
# Exit codes: 0=PATCHED, 1=VULNERABLE, 2=UNKNOWN

import os
import platform
import re
import subprocess
import sys

FIXED = (149, 0, 7827, 53)


def norm(v):
    parts = [int(x) for x in re.findall(r'\d+', v)]
    while len(parts) < 4:
        parts.append(0)
    return tuple(parts[:4])


def ge(a, b):
    return a >= b


def run_cmd(cmd):
    try:
        p = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=10)
        if p.returncode == 0:
            return (p.stdout or p.stderr).strip()
    except Exception:
        pass
    return None


def windows_version():
    # Try registry first
    reg_paths = [
        r'HKLM\SOFTWARE\Google\Chrome\BLBeacon',
        r'HKLM\SOFTWARE\WOW6432Node\Google\Chrome\BLBeacon',
        r'HKCU\Software\Google\Chrome\BLBeacon',
    ]
    for path in reg_paths:
        out = run_cmd(['reg', 'query', path, '/v', 'version'])
        if out:
            m = re.search(r'version\s+REG_\w+\s+([^\r\n]+)', out, re.IGNORECASE)
            if m:
                return m.group(1).strip()

    # Fallback to executable version
    candidates = [
        os.path.expandvars(r'%ProgramFiles%\Google\Chrome\Application\chrome.exe'),
        os.path.expandvars(r'%ProgramFiles(x86)%\Google\Chrome\Application\chrome.exe'),
        os.path.expandvars(r'%LocalAppData%\Google\Chrome\Application\chrome.exe'),
    ]
    for exe in candidates:
        if exe and os.path.exists(exe):
            out = run_cmd([exe, '--version'])
            if out:
                return out
    return None


def mac_version():
    app = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'
    if os.path.exists(app):
        out = run_cmd([app, '--version'])
        if out:
            return out
    plist = '/Applications/Google Chrome.app/Contents/Info.plist'
    if os.path.exists(plist):
        out = run_cmd(['/usr/bin/defaults', 'read', plist, 'CFBundleShortVersionString'])
        if out:
            return out
    return None


def linux_version():
    for cmd in (['google-chrome', '--version'], ['google-chrome-stable', '--version'], ['chrome', '--version']):
        out = run_cmd(cmd)
        if out:
            return out
    for path in ('/opt/google/chrome/chrome', '/usr/bin/google-chrome', '/usr/bin/google-chrome-stable'):
        if os.path.exists(path):
            out = run_cmd([path, '--version'])
            if out:
                return out
    return None


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

    if 'windows' in system:
        raw = windows_version()
    elif 'darwin' in system:
        raw = mac_version()
    elif 'linux' in system:
        raw = linux_version()

    if not raw:
        print('UNKNOWN')
        sys.exit(2)

    m = re.search(r'(\d+\.\d+\.\d+\.\d+)', raw)
    if not m:
        print('UNKNOWN')
        sys.exit(2)

    found = norm(m.group(1))

    if ge(found, FIXED):
        print('PATCHED')
        sys.exit(0)
    else:
        print('VULNERABLE')
        sys.exit(1)


if __name__ == '__main__':
    main()

Sources

1. NVD CVE-2026-11207
2. Chrome Releases - May 2026
3. Chromium issue reference 506127858
4. CISA Known Exploited Vulnerabilities Catalog
5. FIRST EPSS overview
6. FIRST EPSS API documentation
7. Chromium Security
8. Chromium Secure Architecture