Type Confusion in V8 in Google Chrome prior to 149

#!/usr/bin/env python3
# check_chrome_cve_2026_10910.py
# Detects whether locally installed Google Chrome/Chromium builds are below the fix floor for CVE-2026-10910.
# 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
from typing import List, Optional, Tuple

FIXED = (149, 0, 7827, 53)
VERSION_RE = re.compile(r'(\d+)\.(\d+)\.(\d+)\.(\d+)')


def parse_version(text: str) -> Optional[Tuple[int, int, int, int]]:
    if not text:
        return None
    m = VERSION_RE.search(text)
    if not m:
        return None
    return tuple(int(x) for x in m.groups())


def cmp_version(a: Tuple[int, int, int, int], b: Tuple[int, int, int, int]) -> int:
    return (a > b) - (a < b)


def run_cmd(cmd: List[str]) -> Optional[str]:
    try:
        p = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=10)
        out = (p.stdout or "") + "\n" + (p.stderr or "")
        return out.strip()
    except Exception:
        return None


def windows_versions() -> List[Tuple[str, Tuple[int, int, int, int]]]:
    found = []
    # Registry query via reg.exe to avoid winreg edge cases in restricted contexts
    reg_paths = [
        r'HKLM\SOFTWARE\Google\Chrome\BLBeacon',
        r'HKLM\SOFTWARE\WOW6432Node\Google\Chrome\BLBeacon',
        r'HKCU\SOFTWARE\Google\Chrome\BLBeacon',
        r'HKLM\SOFTWARE\Chromium\BLBeacon',
        r'HKCU\SOFTWARE\Chromium\BLBeacon',
    ]
    for path in reg_paths:
        out = run_cmd(['reg', 'query', path, '/v', 'version'])
        if out:
            v = parse_version(out)
            if v:
                found.append((path, v))

    exe_paths = [
        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'),
        os.path.join(os.environ.get('ProgramFiles', r'C:\Program Files'), 'Chromium', 'Application', 'chrome.exe'),
    ]
    for exe in exe_paths:
        if exe and os.path.exists(exe):
            out = run_cmd([exe, '--version'])
            v = parse_version(out or '')
            if v:
                found.append((exe, v))
    return dedupe(found)


def mac_versions() -> List[Tuple[str, Tuple[int, int, int, int]]]:
    found = []
    paths = [
        '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
        os.path.expanduser('~/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'),
        '/Applications/Chromium.app/Contents/MacOS/Chromium',
        os.path.expanduser('~/Applications/Chromium.app/Contents/MacOS/Chromium'),
    ]
    for p in paths:
        if os.path.exists(p):
            out = run_cmd([p, '--version'])
            v = parse_version(out or '')
            if v:
                found.append((p, v))
    return dedupe(found)


def linux_versions() -> List[Tuple[str, Tuple[int, int, int, int]]]:
    found = []
    cmds = [
        ['google-chrome', '--version'],
        ['google-chrome-stable', '--version'],
        ['chromium', '--version'],
        ['chromium-browser', '--version'],
    ]
    for cmd in cmds:
        out = run_cmd(cmd)
        v = parse_version(out or '')
        if v:
            found.append((' '.join(cmd), v))
    return dedupe(found)


def dedupe(items: List[Tuple[str, Tuple[int, int, int, int]]]) -> List[Tuple[str, Tuple[int, int, int, int]]]:
    seen = set()
    result = []
    for src, ver in items:
        key = (src, ver)
        if key not in seen:
            seen.add(key)
            result.append((src, ver))
    return result


def main() -> int:
    system = platform.system().lower()
    versions: List[Tuple[str, Tuple[int, int, int, int]]] = []

    if 'windows' in system:
        versions = windows_versions()
    elif 'darwin' in system:
        versions = mac_versions()
    elif 'linux' in system:
        versions = linux_versions()
    else:
        print('UNKNOWN')
        return 2

    if not versions:
        print('UNKNOWN')
        return 2

    vulnerable = []
    patched = []
    for src, ver in versions:
        if cmp_version(ver, FIXED) < 0:
            vulnerable.append((src, ver))
        else:
            patched.append((src, ver))

    if vulnerable:
        print('VULNERABLE')
        return 1

    if patched:
        print('PATCHED')
        return 0

    print('UNKNOWN')
    return 2


if __name__ == '__main__':
    sys.exit(main())