Type confusion in V8 in Google Chrome prior to 152.0.7977.82 allowed a remote attacker to execute arbitrary…

CVE-2026-85046 is a type confusion flaw in Chrome's V8 JavaScript engine affecting all versions prior to 152.0.7977.82 (stable channel update September 3, 2026). A remote attacker can craft a malicious HTML page that tricks V8's JIT compiler into misinterpreting an object's type, corrupting heap metadata and achieving arbitrary read/write primitives — ultimately yielding code execution inside the renderer sandbox. The attack requires no authentication; the victim only needs to navigate to or be redirected to a hostile page. Every Chrome, Chromium, and Edge (Chromium-based) installation below the patched version is in scope — that is billions of browser instances globally.

Google rates this HIGH at CVSS 8.8, and for once the vendor label is accurate. The key nuance is the phrase *"inside the sandbox."* V8 type confusions are potent — they routinely appear in exploit chains used by commercial spyware vendors (NSO, Intellexa lineage) and state-sponsored actors — but on their own they grant code execution only within Chrome's heavily restricted renderer process. A full host compromise requires chaining this with a separate sandbox escape (e.g., a Mojo IPC bug or kernel vulnerability). Google's advisory confirms active exploitation in the wild as of disclosure, though CISA has not yet added it to the KEV catalog. The combination of confirmed wild exploitation and the inherent sandbox ceiling makes HIGH the right call — not CRITICAL, not MEDIUM.

Why this verdict

• Active wild exploitation: Google confirms exploitation at disclosure. This is not theoretical — someone is weaponizing this today, which anchors the severity at HIGH minimum regardless of friction analysis.
• Sandbox containment caps blast radius: The advisory explicitly states code execution *inside the sandbox*. Without a chained sandbox escape, the attacker gains access only to renderer-process data (current-tab DOM, session cookies, form data). They cannot touch the filesystem, install persistence, or pivot laterally. This is the primary reason the verdict does not reach CRITICAL.
• User interaction required but trivially achievable: The CVSS UI:R component (victim must visit a page) is real friction in theory, but in practice phishing click rates in enterprise remain 5–15% per campaign, and malvertising/watering-hole delivery bypasses the click requirement entirely.
• Role multiplier: Chrome is a universal endpoint application. In the *low-value role* (general browsing workstation), sandboxed RCE yields limited data theft. In the *high-value role* (admin workstation used to access IdP consoles, cloud management planes, PAM vaults via browser), renderer compromise can steal active session tokens for Okta, Azure AD, AWS Console, or CyberArk — enabling identity-tier pivot *without* sandbox escape. However, this session-theft outcome requires the admin to be actively authenticated in the same browser profile, narrowing the realistic window. The blast radius is session-scale, not fleet-scale, which keeps the verdict at HIGH rather than CRITICAL.
• Chromium monoculture amplifies population: Chrome holds ~65% desktop browser share. Edge, Brave, Opera, and Vivaldi share the same V8 engine. The affected population is enormous — virtually every managed endpoint runs a vulnerable version until patched.

Why not higher?

CRITICAL would require either a confirmed sandbox escape chain (making this a full host-compromise zero-day) or the affected component being a canonical high-value-role product (hypervisor, DC, IdP). Chrome is an endpoint application whose sandbox explicitly limits the blast radius to renderer-process data. While session-token theft from an admin browser is serious, it is session-scoped and requires the admin to be actively logged in — it does not inherently yield domain takeover or fleet compromise. No public evidence of a paired sandbox escape exists.

Why not lower?

Active exploitation in the wild is confirmed by Google at disclosure. Downgrading below HIGH with confirmed exploitation would be negligent. The attack is network-delivered, requires zero authentication, and targets the single most widely deployed application on enterprise endpoints. Even sandboxed, the renderer has access to authentication cookies and session tokens that can enable significant lateral movement in the hands of a sophisticated attacker.

1. Force Chrome auto-update and verify version ≥ 152.0.7977.82 — Chrome's built-in updater is the primary remediation. Use Chrome Enterprise policy TargetVersionPrefix or ChromeManagementEnabled with your MDM (Intune, SCCM, Workspace) to force updates. Given the noisgate mitigation SLA of ≤ 30 days for HIGH, confirm fleet-wide update within that window — but given active exploitation, push for 72 hours.
2. Disable JIT compilation via Chrome enterprise policy — Set --js-flags=--jit-less or use the enterprise policy DefaultJavaScriptJitSetting = 2 to disable TurboFan/Maglev JIT. This eliminates the JIT type confusion attack surface entirely. Performance impact is 10–30% on JavaScript-heavy pages. Deploy within the noisgate mitigation SLA (≤ 30 days) if patching is delayed, but preferably within days given active exploitation.
3. Enable site isolation and strict site engagement policies — Ensure SitePerProcess is enabled (default since Chrome 67) and consider IsolateOrigins for high-value internal apps. This limits what a compromised renderer can access across origins.
4. Deploy browser-level URL filtering at the proxy/SASE layer — Block uncategorized and newly registered domains at the network edge (Zscaler, Netskope, Palo Prisma). This reduces the likelihood of users reaching attacker-controlled pages delivering the exploit.
5. Monitor for anomalous renderer behavior via EDR — Tune EDR policies to alert on Chrome renderer processes spawning unexpected child processes, making outbound connections to unusual destinations, or accessing sensitive file paths. CrowdStrike, SentinelOne, and Defender for Endpoint all support renderer anomaly detection.

Run on any host where you want to check the installed Chrome version. Execute with python3 check_cve_2026_85046.py — no special privileges required. Works on Windows, macOS, and Linux.

#!/usr/bin/env python3
"""Check if installed Chrome/Chromium is vulnerable to CVE-2026-85046.
Type confusion in V8 — fixed in 152.0.7977.82.
Exit codes: 0 = PATCHED, 1 = VULNERABLE, 2 = UNKNOWN
"""
import subprocess
import sys
import platform
import os
import re

FIXED_VERSION = (152, 0, 7977, 82)

def parse_version(version_str):
    parts = re.findall(r'(\d+)', version_str)
    if len(parts) >= 4:
        return tuple(int(p) for p in parts[:4])
    return None

def get_chrome_version():
    system = platform.system()
    candidates = []
    if system == 'Windows':
        candidates = [
            [r'C:\Program Files\Google\Chrome\Application\chrome.exe', '--version'],
            [r'C:\Program Files (x86)\Google\Chrome\Application\chrome.exe', '--version'],
            ['reg', 'query', r'HKLM\SOFTWARE\Google\Chrome\BLBeacon', '/v', 'version'],
        ]
    elif system == 'Darwin':
        candidates = [
            ['/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', '--version'],
        ]
    else:
        candidates = [
            ['google-chrome', '--version'],
            ['google-chrome-stable', '--version'],
            ['chromium-browser', '--version'],
            ['chromium', '--version'],
        ]
    for cmd in candidates:
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
            output = result.stdout.strip() + result.stderr.strip()
            ver = parse_version(output)
            if ver:
                return ver, output
        except (FileNotFoundError, subprocess.TimeoutExpired, OSError):
            continue
    return None, None

def main():
    ver, raw = get_chrome_version()
    if ver is None:
        print('UNKNOWN — Could not detect Chrome/Chromium installation.')
        sys.exit(2)
    print(f'Detected version: {".".join(str(v) for v in ver)} (raw: {raw})')
    if ver >= FIXED_VERSION:
        print(f'PATCHED — version {".".join(str(v) for v in ver)} >= {".".join(str(v) for v in FIXED_VERSION)}')
        sys.exit(0)
    else:
        print(f'VULNERABLE — version {".".join(str(v) for v in ver)} < {".".join(str(v) for v in FIXED_VERSION)}')
        print('CVE-2026-85046: Type confusion in V8. Update Chrome immediately.')
        sys.exit(1)

if __name__ == '__main__':
    main()

Sources

1. Chrome Releases Blog — Stable Channel Update Sept 3, 2026
2. deskmodder.de — Chrome 152.0.7977.82 fixes 12 vulnerabilities, one exploited in the wild
3. offseq Radar — CVE-2026-85046 Live Threat Intelligence
4. Malwarebytes — Two critical Chrome flaws (Sept 2026)
5. Zeropath — Chrome V8 type confusion analysis (CVE-2026-6363 analog)
6. CyberSecurityNews — Chrome 152 security fixes overview
7. Sentrium — V8 type confusion zero-day vulnerability analysis