Use after free in MimeHandlerView in Google Chrome prior to 149

CVE-2026-10956 is a use-after-free in Chrome's MimeHandlerView, affecting Chrome desktop builds before 149.0.7827.53 on Linux and before 149.0.7827.53/.54 on Windows/macOS. In plain English: attacker-controlled web content can make Chrome touch memory after it has been freed, which can let the attacker run code inside the browser's sandboxed process after a user visits or renders crafted content. Based on Chrome's advisory wording and the component involved, this looks like a renderer/content-handling bug, not a direct OS-level takeover.

Google's HIGH 8.8 baseline is technically reasonable in a vacuum because the bug is remotely reachable and sits in a massively deployed client. In the real world, though, the biggest fact is the one defenders care about: the stated impact is code execution inside a sandbox, which means an attacker still needs a second primitive for a full workstation compromise. Add the lack of KEV, lack of public exploit evidence, and a very low EPSS (0.0008), and this lands lower on an enterprise patch queue than internet-facing edge flaws or sandbox-escape chains.

Why this verdict

• Start at 8.8, then cut for sandbox reality: vendor scoring assumes remote code execution is inherently urgent, but the public description says execution is inside a sandbox, which materially lowers standalone impact.
• UI:R is real friction: this requires the attacker to win a user-browsing event or content-render event. That implies phishing, malvertising, compromised sites, or another delivery channel rather than direct reachability.
• No exploitation signal: no KEV, no public Google statement of in-the-wild abuse, no obvious public PoC, and a very low EPSS 0.0008 all push this down the queue.
• Population is broad, but reachability is narrower: Chrome is everywhere, yet only vulnerable builds that actually hit the MimeHandlerView path are candidates. That is less deterministic than an externally exposed VPN or web appliance flaw.
• Modern controls help after first stage: EDR, browser isolation, Safe Browsing, and identity telemetry can still blunt follow-on actions even if renderer compromise occurs.

Why not higher?

This is not scored higher because the public impact stops at sandboxed browser code execution. There is no public second-stage sandbox escape, no KEV listing, and no exploitation evidence that would justify treating this like a full remote workstation takeover. For a 10,000-host patch queue, that matters.

Why not lower?

This is not LOW because it is still a remote memory-corruption bug in Chrome, a massively deployed client that routinely faces hostile content. If weaponized, it can still compromise the browser process, abuse sessions, and serve as stage one in a broader chain.

1. Enforce Chrome auto-update compliance — Make sure managed endpoints are actually receiving Chrome 149.0.7827.53/.54 or later and are not pinned on stale channels. Because this is a MEDIUM noisgate verdict, there is no mitigation SLA; do this as routine hygiene while driving patch closure within the 365-day remediation window.
2. Prioritize high-risk user groups for browser isolation — Apply or verify browser isolation for admins, finance, executives, and users who routinely open untrusted links or documents. Isolation matters here because the exploit's advertised impact is inside the browser sandbox, and isolation further shrinks useful attacker outcomes; with a MEDIUM verdict, there is no mitigation SLA, so align this to your standard hardening cycle.
3. Hunt for version laggards in unmanaged or exception fleets — Focus on VDI gold images, kiosks, lab systems, developer workstations with update deferrals, and offline laptops. These are the places where Chrome auto-update assumptions usually fail, and for a MEDIUM issue you should close those gaps as part of the remediation plan rather than invoking an emergency change.
4. Monitor browser crash and child-process anomalies — Use EDR and browser telemetry to look for repeated renderer crashes, unusual command lines, or suspicious browser-spawned processes around suspicious browsing events. This will not replace patching, but it improves your odds of catching exploit development or a chained attack while you work through normal remediation.

Run this on the target endpoint itself or via your software-distribution/remote-execution tooling. Invoke it as python3 check_chrome_cve_2026_10956.py on macOS/Linux or py check_chrome_cve_2026_10956.py on Windows; no admin rights are required, but the script needs permission to read Chrome executable metadata in standard install paths.

#!/usr/bin/env python3
# Check exposure to CVE-2026-10956 (Chrome MimeHandlerView UAF)
# Output: VULNERABLE / PATCHED / UNKNOWN
# Exit codes: 0=PATCHED, 1=VULNERABLE, 2=UNKNOWN

import os
import platform
import re
import subprocess
import sys
from typing import Optional, Tuple

WIN_SAFE = (149, 0, 7827, 54)   # treat .54 as patched for Win/macOS per vendor note
MAC_SAFE = (149, 0, 7827, 54)
LINUX_SAFE = (149, 0, 7827, 53)


def parse_version(text: str) -> Optional[Tuple[int, int, int, int]]:
    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_ver(a, b):
    return (a > b) - (a < b)


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


def windows_version() -> Optional[Tuple[int, int, int, int]]:
    candidates = [
        os.path.join(os.environ.get('ProgramFiles', r'C:\Program Files'), 'Google', 'Chrome', 'Application', 'chrome.exe'),
        os.path.join(os.environ.get('ProgramFiles(x86)', r'C:\Program Files (x86)'), 'Google', 'Chrome', 'Application', 'chrome.exe'),
        os.path.join(os.environ.get('LocalAppData', ''), 'Google', 'Chrome', 'Application', 'chrome.exe'),
    ]
    for path in candidates:
        if path and os.path.exists(path):
            try:
                cmd = [
                    'powershell', '-NoProfile', '-Command',
                    f"(Get-Item '{path}').VersionInfo.ProductVersion"
                ]
                v = get_version_from_command(cmd)
                if v:
                    return v
            except Exception:
                pass
    return None


def mac_version() -> Optional[Tuple[int, int, int, int]]:
    app = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'
    if os.path.exists(app):
        return get_version_from_command([app, '--version'])
    return None


def linux_version() -> Optional[Tuple[int, int, int, int]]:
    commands = [
        ['google-chrome', '--version'],
        ['google-chrome-stable', '--version'],
        ['chromium-browser', '--version'],
        ['chromium', '--version'],
    ]
    for cmd in commands:
        v = get_version_from_command(cmd)
        if v:
            return v
    return None


def main():
    system = platform.system().lower()
    version = None
    safe = None
    product = 'Google Chrome/Chromium-like browser'

    if 'windows' in system:
        version = windows_version()
        safe = WIN_SAFE
        product = 'Google Chrome on Windows'
    elif 'darwin' in system:
        version = mac_version()
        safe = MAC_SAFE
        product = 'Google Chrome on macOS'
    elif 'linux' in system:
        version = linux_version()
        safe = LINUX_SAFE
        product = 'Google Chrome/Chromium on Linux'
    else:
        print(f'UNKNOWN: unsupported OS {platform.system()}')
        sys.exit(2)

    if not version:
        print(f'UNKNOWN: could not determine installed version for {product}')
        sys.exit(2)

    print(f'Detected version: {".".join(map(str, version))} ({product})')

    if cmp_ver(version, safe) < 0:
        print(f'VULNERABLE: version is older than fixed baseline {".".join(map(str, safe))}')
        sys.exit(1)
    else:
        print(f'PATCHED: version meets or exceeds fixed baseline {".".join(map(str, safe))}')
        sys.exit(0)


if __name__ == '__main__':
    main()

Sources

1. Chrome Releases: Stable Channel Update for Desktop (2026-06-02)
2. Chromium issue 506375731
3. Chrome Security Page
4. CISA Known Exploited Vulnerabilities Catalog
5. FIRST EPSS API documentation
6. FIRST EPSS model overview
7. Canadian Centre for Cyber Security advisory AV26-544
8. Chrome Releases: Early Stable Update for Desktop (149.0.7827.53/.54)