Inappropriate implementation in GPU in Google Chrome prior to 149

CVE-2026-10897 is a GPU-side Chrome flaw that can let hostile web content *potentially* break out of the browser sandbox. Per the supplied record, it affects Google Chrome versions prior to 149.0.7827.53; public release notices around this train show desktop fixes landing as 149.0.7827.53 for Linux and 149.0.7827.53/.54 for Windows and macOS. In plain terms: a user lands on attacker-controlled content, that content exercises a vulnerable GPU code path, and the payoff is a sandbox escape rather than a simple tab crash.

There is no vendor CVSS baseline here, so this is a first-principles assessment. Reality says HIGH, not CRITICAL: Chrome is everywhere and sandbox escapes matter, but this is still a client-side, user-driven browser exploit with no confirmed KEV listing, no public in-the-wild reporting, and no public weaponized PoC located from authoritative sources at the time of review. That combination keeps it urgent for endpoint hygiene, but not an all-hands emergency patch-over-weekend event.

Why this verdict

• No vendor baseline exists so this is assessed from scratch using attacker path and fleet reality rather than inherited CVSS.
• Wide exposure but not wide reachability: Chrome is everywhere, yet the bug is delivered through hostile content and user browsing, not a directly exposed enterprise service.
• Sandbox escape is a real impact amplifier: if the bug works, it crosses the browser’s core isolation boundary and can hand the attacker endpoint-level leverage beyond a single tab.
• Multiple friction points push down from CRITICAL: user interaction, GPU-path specificity, exploit reliability against modern sandboxing, and likely platform/driver sensitivity all narrow real-world success.
• No live-fire indicators today: no KEV listing, no authoritative exploitation reporting, and no public PoC found during review.

Why not higher?

This is not a wormable server-side flaw and not a known-zero-day under active attack. The chain still depends on victim browsing, a functioning exploit for a restricted-detail GPU bug, and successful bypass of a hardened browser sandbox, all of which materially reduce real-world exploit throughput.

Why not lower?

A browser sandbox escape in Chrome is never routine backlog noise because the installed base is enormous and the boundary being crossed is security-critical. Even without active exploitation, this bug sits on a path attackers actively value for drive-by compromise and post-phishing follow-on access.

1. Force browser auto-update and relaunch compliance — Make Chrome update enforcement measurable across the fleet and force relaunch completion so patched binaries actually load. For a HIGH verdict, deploy this compensating control within 30 days if you cannot prove prompt patch uptake through your browser management plane.
2. Disable hardware acceleration on high-risk tiers — Temporarily turn off Chrome hardware acceleration for privileged admin workstations, jump hosts, SOC endpoints, and kiosk pools where browser compatibility allows it. This does not eliminate all graphics risk, but it reduces exposure to GPU-driven exploit paths; for a HIGH verdict, apply within 30 days to the small subset you cannot patch quickly.
3. Restrict unmanaged browsing paths — Push risky user populations through enterprise browser management, remote browser isolation, or stricter web filtering for ad-heavy and newly registered domains. This lowers exploit delivery opportunities while the patch rolls out; for a HIGH verdict, put this in place within 30 days where existing controls are weak.
4. Hunt for browser-to-child-process anomalies — Tune EDR detections for chrome spawning interpreters, LOLBins, or unexpected helper processes, plus suspicious writes from browser ancestry. This will not prevent the bug, but it raises the chance of catching successful post-escape activity; enable or tune within 30 days.

Run this on the target endpoint or through your software inventory/remote execution platform with standard user rights; admin is not required. Invoke with python3 check_chrome_149_gpu_cve.py on macOS/Linux or py check_chrome_149_gpu_cve.py on Windows. It locates Chrome, reads the installed version, and prints VULNERABLE, PATCHED, or UNKNOWN.

#!/usr/bin/env python3
# check_chrome_149_gpu_cve.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

FIXED_VERSION = (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 cmp_version(a, b):
    return (a > b) - (a < b)


def run_version(cmd):
    try:
        p = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
        out = (p.stdout or '') + ' ' + (p.stderr or '')
        ver = parse_version(out)
        if ver:
            return ver, ' '.join(cmd)
    except Exception:
        pass
    return None, None


def windows_candidates():
    paths = []
    for base in [os.environ.get('ProgramFiles'), os.environ.get('ProgramFiles(x86)'), os.environ.get('LocalAppData')]:
        if base:
            paths.append(os.path.join(base, 'Google', 'Chrome', 'Application', 'chrome.exe'))
    return [p for p in paths if p and os.path.exists(p)]


def mac_candidates():
    return ['/Applications/Google Chrome.app/Contents/MacOS/Google Chrome']


def linux_candidates():
    cmds = []
    for name in ['google-chrome', 'google-chrome-stable', 'chrome', 'chromium', 'chromium-browser']:
        path = shutil.which(name)
        if path:
            cmds.append(path)
    return cmds


def detect_version():
    system = platform.system().lower()

    if 'windows' in system:
        for exe in windows_candidates():
            ver, src = run_version([exe, '--version'])
            if ver:
                return ver, src
        try:
            import winreg  # noqa: F401
            reg_paths = [
                r'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\chrome.exe',
                r'SOFTWARE\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\App Paths\\chrome.exe',
            ]
            for hive in []:
                pass
        except Exception:
            pass
        return None, None

    if 'darwin' in system:
        for exe in mac_candidates():
            if os.path.exists(exe):
                ver, src = run_version([exe, '--version'])
                if ver:
                    return ver, src
        return None, None

    # Linux / other Unix-like
    for exe in linux_candidates():
        ver, src = run_version([exe, '--version'])
        if ver:
            return ver, src
    return None, None


def main():
    ver, src = detect_version()
    if not ver:
        print('UNKNOWN - Google Chrome version not detected on this host')
        sys.exit(2)

    ver_str = '.'.join(str(x) for x in ver)
    fixed_str = '.'.join(str(x) for x in FIXED_VERSION)

    # Windows/macOS may report 149.0.7827.54 on the same fixed release train;
    # any version >= 149.0.7827.53 is treated as patched.
    if cmp_version(ver, FIXED_VERSION) >= 0:
        print(f'PATCHED - detected version {ver_str} via {src}; fixed threshold is {fixed_str}+')
        sys.exit(0)
    else:
        print(f'VULNERABLE - detected version {ver_str} via {src}; below fixed threshold {fixed_str}')
        sys.exit(1)


if __name__ == '__main__':
    main()

Sources

1. Chrome Releases - Early Stable Update for Desktop (149.0.7827.53/.54)
2. Chrome Releases archive for 2026
3. Canadian Centre for Cyber Security advisory AV26-544
4. CISA Known Exploited Vulnerabilities Catalog
5. FIRST EPSS
6. Chrome Releases - Stable Channel Update for Desktop (Chrome 148 precedent and restricted bug handling language)
7. Chrome Releases - Stable Channel Update for Desktop (Chrome 147 precedent)