Inappropriate implementation in V8 in Google Chrome prior to 148

#!/usr/bin/env python3
# check_cve_2026_7999.py
# Detect vulnerable Chrome / Edge versions for CVE-2026-7999.
# Outputs one of: VULNERABLE / PATCHED / UNKNOWN
# Exit codes: 0=PATCHED, 1=VULNERABLE, 2=UNKNOWN

import argparse
import os
import platform
import re
import shutil
import subprocess
import sys
from typing import Optional, Tuple, List

TARGETS = {
    'chrome': {
        'linux': '148.0.7778.96',
        'darwin': '148.0.7778.97',
        'windows': '148.0.7778.97',
    },
    'edge': {
        'linux': '148.0.3967.54',
        'darwin': '148.0.3967.54',
        'windows': '148.0.3967.54',
    }
}

def norm_os() -> str:
    s = platform.system().lower()
    if 'windows' in s:
        return 'windows'
    if 'darwin' in s or 'mac' in s:
        return 'darwin'
    return 'linux'

def parse_ver(v: str) -> Tuple[int, ...]:
    nums = re.findall(r'\d+', v)
    return tuple(int(x) for x in nums)

def cmp_ver(a: str, b: str) -> int:
    av = list(parse_ver(a))
    bv = list(parse_ver(b))
    n = max(len(av), len(bv))
    av += [0] * (n - len(av))
    bv += [0] * (n - len(bv))
    if av < bv:
        return -1
    if av > bv:
        return 1
    return 0

def run_version(cmd: List[str]) -> Optional[str]:
    try:
        p = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
        out = (p.stdout or '') + ' ' + (p.stderr or '')
        m = re.search(r'(\d+\.\d+\.\d+\.\d+)', out)
        return m.group(1) if m else None
    except Exception:
        return None

def candidates(product: str, osname: str) -> List[List[str]]:
    cmds = []
    if osname == 'linux':
        if product == 'chrome':
            for exe in ['google-chrome', 'google-chrome-stable', 'chromium', 'chromium-browser']:
                path = shutil.which(exe)
                if path:
                    cmds.append([path, '--version'])
        elif product == 'edge':
            for exe in ['microsoft-edge', 'microsoft-edge-stable']:
                path = shutil.which(exe)
                if path:
                    cmds.append([path, '--version'])
    elif osname == 'darwin':
        if product == 'chrome':
            paths = [
                '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
                os.path.expanduser('~/Applications/Google Chrome.app/Contents/MacOS/Google Chrome')
            ]
        else:
            paths = [
                '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
                os.path.expanduser('~/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge')
            ]
        for p in paths:
            if os.path.exists(p):
                cmds.append([p, '--version'])
    elif osname == 'windows':
        base = []
        for env in ['ProgramFiles', 'ProgramFiles(x86)', 'LocalAppData']:
            val = os.environ.get(env)
            if val:
                base.append(val)
        if product == 'chrome':
            rels = [
                ['Google', 'Chrome', 'Application', 'chrome.exe'],
            ]
        else:
            rels = [
                ['Microsoft', 'Edge', 'Application', 'msedge.exe'],
            ]
        for b in base:
            for rel in rels:
                p = os.path.join(b, *rel)
                if os.path.exists(p):
                    cmds.append([p, '--version'])
    return cmds

def detect_one(product: str) -> Tuple[str, Optional[str], Optional[str]]:
    osname = norm_os()
    fixed = TARGETS[product][osname]
    for cmd in candidates(product, osname):
        ver = run_version(cmd)
        if ver:
            if cmp_ver(ver, fixed) < 0:
                return ('VULNERABLE', ver, fixed)
            return ('PATCHED', ver, fixed)
    return ('UNKNOWN', None, fixed)

def main() -> int:
    ap = argparse.ArgumentParser(description='Check Chrome / Edge version exposure for CVE-2026-7999')
    ap.add_argument('--product', choices=['chrome', 'edge', 'both'], default='both', help='Product to check')
    args = ap.parse_args()

    products = ['chrome', 'edge'] if args.product == 'both' else [args.product]
    results = []
    for prod in products:
        status, ver, fixed = detect_one(prod)
        results.append((prod, status, ver, fixed))

    for prod, status, ver, fixed in results:
        found = ver if ver else 'not found'
        print(f'{prod.upper()}: {status} (found={found}, fixed>={fixed})')

    # Decision logic:
    # - If any installed checked product is vulnerable => VULNERABLE
    # - Else if at least one checked product is patched and none vulnerable => PATCHED
    # - Else => UNKNOWN
    if any(r[1] == 'VULNERABLE' for r in results):
        print('VULNERABLE')
        return 1
    if any(r[1] == 'PATCHED' for r in results) and not any(r[1] == 'VULNERABLE' for r in results):
        print('PATCHED')
        return 0
    print('UNKNOWN')
    return 2

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