Use after free in Autofill in Google Chrome prior to 149

CVE-2026-11002 is a use-after-free in Chrome Autofill that can turn a *pre-existing renderer compromise* into a potential sandbox escape. The authoritative CVE text matters here: the attacker must already have compromised the renderer process, then use a crafted HTML page to drive the vulnerable Autofill path. NVD lists affected Chrome builds as versions before 149.0.7827.53; Google's early stable release notes show the fix shipping in 149.0.7827.53/.54 for desktop.

The 9.6/CRITICAL CVSS framing overstates operational risk for enterprise patch triage because it scores impact after the chain is complete, not the friction required to get there. Chromium's own severity label is *Medium*, and that directionally matches reality better: this is a valuable defense-in-depth break for exploit chains, but it is not a standalone web-to-host compromise and there is no current KEV listing, no public in-the-wild evidence, and an extremely low EPSS in the intel you supplied.

Why this verdict

• Second-stage only: the CVE text explicitly requires a *compromised renderer process*. That means the attacker position is not unauthenticated remote in one shot; it implies a prior exploit stage already succeeded, which is a major downward pressure from the 9.6 paper score.
• Reachable population is broad, but directly exploitable population is narrow: Chrome is everywhere, but only the subset on vulnerable builds *and* exposed to a separate working renderer exploit chain can be hit. That compounding prerequisite knocks this out of the true emergency bucket.
• Modern browser defenses are doing work here: Site Isolation, sandboxing, OS mitigations, and EDR don't make it harmless, but they do add real friction to reliable exploitation. This is exactly the class of bug where exploit developers care a lot more than commodity threat actors.
• No external urgency signal: no KEV, no public PoC, and the supplied EPSS is extremely low. When the ecosystem is quiet on a browser sandbox escape, defenders should resist treating the CVSS number as a fire alarm.
• Why it still lands above LOW: if you already lose the renderer, a sandbox escape in a massively deployed browser is still a meaningful privilege boundary break. On 10,000 endpoints, you patch this because exploit chains exist, not because this CVE alone is likely to burn you tomorrow.

Why not higher?

A higher rating would require an amplifier that is missing here: active exploitation, public weaponization, or a chain that does not require prior renderer compromise. None of those are present in the reviewed sources. The prerequisite of already owning the renderer is not a minor caveat; it is the central risk-reducing fact.

Why not lower?

A lower rating would ignore that this is still a sandbox escape in the most exposed client application most enterprises run. Attackers building high-end browser chains absolutely care about bugs like this because they turn a renderer foothold into real host impact. That keeps it out of backlog-hygiene territory.

1. Enforce browser auto-update compliance — Use Chrome enterprise policy and your endpoint management stack to verify that unmanaged or pinned builds are not stranded below 149.0.7827.53. For a MEDIUM noisgate verdict there is no mitigation SLA; apply this as normal hygiene while you drive remediation through standard browser maintenance.
2. Hunt for version laggards — Query EDR, asset inventory, or software metering for Chrome versions <149.0.7827.53 and focus on VDI pools, kiosk images, golden images, and machines with disabled auto-update. These are the places browser patch drift survives longest and quietly expands exploit-chain exposure.
3. Reduce unmanaged browsing paths — Block or flag non-corporate Chrome installs, portable browsers, and local admin exceptions that bypass your browser update channel. This matters because client-side browser exposure is primarily a *patch-lag* problem, not an open-port problem.
4. Keep exploit-chain controls healthy — Maintain Safe Browsing, web filtering, ad/malvertising controls, and EDR browser telemetry because they attack the *first-stage renderer compromise* this CVE depends on. They do not fix the bug, but they lower the odds that an attacker ever gets to use it.

Run this on the target endpoint or via your fleet management tool with standard user rights; admin is not required if Chrome is installed in normal locations. Save as check_cve_2026_11002.py and run python3 check_cve_2026_11002.py on macOS/Linux or py check_cve_2026_11002.py on Windows. It will auto-discover common Chrome install paths and print VULNERABLE, PATCHED, or UNKNOWN.

#!/usr/bin/env python3
# check_cve_2026_11002.py
# Detects whether local Google Chrome is below 149.0.7827.53
# Exit codes:
#   0 = PATCHED
#   1 = VULNERABLE
#   2 = UNKNOWN

import os
import platform
import re
import shutil
import subprocess
import sys
from pathlib import Path

FIXED = (149, 0, 7827, 53)


def parse_version(text):
    m = re.search(r'(\d+)\.(\d+)\.(\d+)\.(\d+)', text)
    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 compare_versions(a, b):
    return (a > b) - (a < b)


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


def candidate_paths():
    system = platform.system().lower()
    paths = []

    if system == 'windows':
        envs = [
            os.environ.get('ProgramFiles'),
            os.environ.get('ProgramFiles(x86)'),
            os.environ.get('LocalAppData'),
        ]
        suffixes = [
            r'Google\Chrome\Application\chrome.exe',
            r'Chromium\Application\chrome.exe',
        ]
        for base in envs:
            if not base:
                continue
            for suf in suffixes:
                paths.append(str(Path(base) / Path(suf)))
        which = shutil.which('chrome') or shutil.which('chrome.exe') or shutil.which('google-chrome')
        if which:
            paths.append(which)

    elif system == 'darwin':
        paths.extend([
            '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
            str(Path.home() / 'Applications/Google Chrome.app/Contents/MacOS/Google Chrome'),
            '/Applications/Chromium.app/Contents/MacOS/Chromium',
        ])
        which = shutil.which('google-chrome') or shutil.which('chrome') or shutil.which('chromium')
        if which:
            paths.append(which)

    else:
        paths.extend([
            '/usr/bin/google-chrome',
            '/usr/bin/google-chrome-stable',
            '/opt/google/chrome/chrome',
            '/snap/bin/chromium',
            '/usr/bin/chromium',
            '/usr/bin/chromium-browser',
        ])
        for name in ['google-chrome', 'google-chrome-stable', 'chromium', 'chromium-browser', 'chrome']:
            which = shutil.which(name)
            if which:
                paths.append(which)

    # de-duplicate while preserving order
    seen = set()
    ordered = []
    for p in paths:
        if p and p not in seen:
            seen.add(p)
            ordered.append(p)
    return ordered


def get_version_from_binary(path):
    rc, out = run_cmd([path, '--version'])
    if rc is None:
        return None
    return parse_version(out)


def main():
    found = []
    for path in candidate_paths():
        if Path(path).exists() or shutil.which(path):
            v = get_version_from_binary(path)
            if v:
                found.append((path, v))

    if not found:
        print('UNKNOWN: Google Chrome/Chromium binary not found in common locations')
        sys.exit(2)

    # Prefer Google Chrome if present; otherwise use first discovered browser binary
    chosen = None
    for path, v in found:
        low = path.lower()
        if 'google' in low and 'chrome' in low:
            chosen = (path, v)
            break
    if not chosen:
        chosen = found[0]

    path, version = chosen
    if compare_versions(version, FIXED) < 0:
        print(f'VULNERABLE: {path} version {version_to_str(version)} is below fixed version {version_to_str(FIXED)}')
        sys.exit(1)
    else:
        print(f'PATCHED: {path} version {version_to_str(version)} is at or above fixed version {version_to_str(FIXED)}')
        sys.exit(0)


if __name__ == '__main__':
    main()

Sources

1. NVD CVE-2026-11002
2. Chrome Releases - Early Stable Update for Desktop (149.0.7827.53/.54)
3. Chromium severity guidelines
4. Chromium Site Isolation overview
5. Chrome sandbox diagnostics for Windows
6. CISA Known Exploited Vulnerabilities Catalog
7. FIRST EPSS data and statistics
8. Chromium issue 494740162