Use after free in Glic in Google Chrome prior to 149

CVE-2026-10990 is a use-after-free in Chrome's Glic component — the Gemini-in-Chrome side panel / agent surface — affecting Chrome versions before 149.0.7827.53 on Linux and before 149.0.7827.53/54 on Windows and macOS. The public description says exploitation requires a remote attacker who has already compromised the renderer process, which makes this a post-renderer-compromise escape or privilege-expansion primitive, not a one-bug drive-by full compromise.

The supplied 9.6/CRITICAL framing overshoots reality for enterprise scheduling. Google itself classed this bug as Medium in the June 2, 2026 Chrome stable advisory, and the real-world friction is the whole story: the attacker must first land renderer code execution, then reach a Glic/Gemini-in-Chrome path that is still being gradually rolled out, requires sign-in, supported region/language, and may be disabled by enterprise policy. That keeps this important, but not emergency-critical on its own.

Why this verdict

• Baseline down: Google's own release notes classify CVE-2026-10990 as Medium, not Critical, which is a strong signal the vendor sees meaningful exploitation friction.
• Major friction — post-initial-access inside the browser: the description says the attacker must have already compromised the renderer process. That implies this is not the first bug in the chain.
• Reachable population narrows again: the target also needs Glic/Gemini in Chrome available, which Google says is gradually rolled out, requires sign-in, supported region/language, and can be disabled by enterprise policy.
• No live-fire signals: no KEV listing, no public exploitation evidence found, no public PoC found, and supplied EPSS 0.00035 is minimal.
• Still not low: Chrome is ubiquitous, the bug sits in a privileged browser-adjacent feature, and a sandbox-escape style primitive remains highly valuable to real exploit developers when paired with another browser bug.

Why not higher?

A higher rating would require either stand-alone exploitation, broadly reachable attack surface, or active exploitation evidence. We have none of those here: the attacker needs renderer compromise first, and the Glic feature itself is not universally reachable across managed fleets.

Why not lower?

This is still memory corruption in a widely deployed browser, not a cosmetic policy bypass. If an attacker already has renderer execution, bugs in privileged Chrome surfaces like Glic can be the difference between a dead-end sandbox and a meaningful endpoint compromise.

1. Patch Chrome through the normal browser ring — Move endpoints to 149.0.7827.53+ (or 149.0.7827.54 where that's the Windows/macOS build) as part of your standard browser update motion. Because the reassessed verdict is MEDIUM, there is no mitigation SLA — go straight to the 365-day remediation window, but in practice browsers should ride your routine fast ring rather than backlog purgatory.
2. Disable Gemini in Chrome where business use is low — If your fleet does not need Gemini in Chrome, use Chrome Enterprise GeminiSettings / Gemini app controls to turn the feature off and shrink the reachable attack surface. For a MEDIUM verdict there is no mitigation SLA, so treat this as an exposure-reduction option during normal policy maintenance rather than an emergency block.
3. Prioritize patching on high-risk browsing tiers — Patch admin workstations, researchers, finance, executives, and users who regularly open untrusted web content first. The bug is only valuable after renderer compromise, so the best return comes from systems with the highest probability of seeing hostile content.
4. Harden extension and browser policy hygiene — Keep Chrome signed-in policy, extension allowlisting, and browser management intact so Glic/Gemini rollout state remains visible and controllable. This does not fix CVE-2026-10990, but it reduces adjacent browser-chain options and improves scoping.

Run this on the target endpoint or via your EDR/live-response tool. Invoke it with python3 check_chrome_cve_2026_10990.py; it needs only standard user rights and reports VULNERABLE, PATCHED, or UNKNOWN based on the locally installed Google Chrome version.

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

import os
import platform
import re
import shutil
import subprocess
import sys

THRESHOLD = (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 run_cmd(cmd):
    try:
        p = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
        out = (p.stdout or '') + '\n' + (p.stderr or '')
        return out.strip()
    except Exception:
        return ''


def get_windows_version():
    cmds = [
        ['reg', 'query', r'HKLM\Software\Google\Chrome\BLBeacon', '/v', 'version'],
        ['reg', 'query', r'HKCU\Software\Google\Chrome\BLBeacon', '/v', 'version'],
        ['powershell', '-NoProfile', '-Command', "(Get-Item 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe').VersionInfo.ProductVersion"],
        ['powershell', '-NoProfile', '-Command', "(Get-Item 'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe').VersionInfo.ProductVersion"]
    ]
    for cmd in cmds:
        out = run_cmd(cmd)
        ver = parse_version(out)
        if ver:
            return ver
    return None


def get_macos_version():
    chrome_bin = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'
    if os.path.exists(chrome_bin):
        out = run_cmd([chrome_bin, '--version'])
        ver = parse_version(out)
        if ver:
            return ver
    return None


def get_linux_version():
    candidates = ['google-chrome', 'google-chrome-stable', 'chromium', 'chromium-browser']
    for name in candidates:
        path = shutil.which(name)
        if path:
            out = run_cmd([path, '--version'])
            ver = parse_version(out)
            if ver:
                return ver
    return None


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

    if 'windows' in system:
        version = get_windows_version()
    elif 'darwin' in system:
        version = get_macos_version()
    elif 'linux' in system:
        version = get_linux_version()

    if not version:
        print('UNKNOWN: Could not determine installed Google Chrome version')
        sys.exit(2)

    version_str = '.'.join(str(x) for x in version)
    threshold_str = '.'.join(str(x) for x in THRESHOLD)

    if version < THRESHOLD:
        print(f'VULNERABLE: Installed Chrome version {version_str} is older than {threshold_str}')
        sys.exit(1)
    else:
        print(f'PATCHED: Installed Chrome version {version_str} is at or above {threshold_str}')
        sys.exit(0)


if __name__ == '__main__':
    main()

Sources

1. Google Chrome Releases - Stable Channel Update for Desktop (June 2, 2026)
2. Google Chrome Help - Use Gemini in Chrome
3. Chrome Enterprise and Education Help - Gemini in Chrome
4. Unit 42 - Vulnerability in Chrome Allowed Extensions to Hijack New Gemini Panel
5. Canadian Centre for Cyber Security - Google Chrome security advisory (AV26-544)
6. GovCERT.HK - Multiple Vulnerabilities in Google Chrome
7. CISA Known Exploited Vulnerabilities Catalog
8. FIRST EPSS API documentation