Google has pushed Chrome 152.0.7977.82/.83 to the Stable channel for Windows and Mac, and 152.0.7977.82 for Linux, resolving 12 security vulnerabilities. Two are called out in the advisory: CVE-2026-85046, a High-severity type confusion in the V8 JavaScript engine, and CVE-2026-85052, a High-severity out-of-bounds read in Chrome's CrashReporting component.
Type confusion in V8 is not a theoretical class of bug. It is the single most exploited vulnerability category in Chrome's history and the backbone of virtually every in-the-wild Chrome renderer exploit chain we've responded to over the past several years. A successful type confusion gives an attacker primitive read/write inside the renderer process — the first domino in a chain that ends with sandbox escape and host code execution, typically delivered through nothing more exotic than a malicious web page or a compromised ad network.
Google is withholding bug details until the majority of users have updated — standard practice, and a strong signal that the flaw is exploitable enough that publishing technical detail now would hand a working exploit recipe to threat actors before the patch propagates. Treat this as a patch-this-week event, not a patch-this-cycle event.
Technical Analysis
Affected Products and Versions
| Platform | Fixed Version |
|---|---|
| Windows | 152.0.7977.82 / 152.0.7977.83 |
| macOS | 152.0.7977.82 / 152.0.7977.83 |
| Linux | 152.0.7977.82 |
Any Chrome build prior to 152.0.7977.82 on these platforms is vulnerable. Chromium-derived browsers (Edge, Brave, Opera, Vivaldi) inherit V8 fixes on their own release cadence — verify your enterprise browser estate, not just Chrome.
CVE-2026-85046 — Type Confusion in V8 (High)
Reported by external researcher Salvatore Gulizia (Serotav) on 2026-08-04 with a $1,000 bounty. Type confusion occurs when the JIT compiler (TurboFan/Maglev) makes incorrect assumptions about an object's type during optimization, allowing JavaScript to read or write memory outside the object's actual bounds. From a defender's perspective, the attack chain looks like this:
- Delivery: Victim visits attacker-controlled or compromised page (watering hole, malvertising, phishing link).
- Renderer compromise: Malicious JavaScript triggers the type confusion, yielding arbitrary read/write within the renderer process.
- Sandbox escape: A second bug (or a sandbox weakness) is chained to break out of the renderer.
- Host execution: Attacker code runs as the logged-on user — typically observed as
chrome.exespawning anomalous child processes.
Exploitation requires no user interaction beyond page load. No authentication, no file download consent, no warning dialogs.
CVE-2026-85052 — Out-of-Bounds Read in CrashReporting (High)
An out-of-bounds read in Chrome's crash reporting component. OOB reads in ancillary components are frequently leveraged as information-disclosure primitives to defeat ASLR — in other words, they make the other bug in this release more reliably exploitable. Don't deprioritize it because it reads less scary than type confusion.
Exploitation Status
At time of publication, Google has not flagged either CVE as exploited in the wild, and neither appears in CISA's Known Exploited Vulnerabilities catalog. However, the 10 additional fixes are undisclosed, V8 type confusion bugs are historically weaponized within days of disclosure, and exploit brokers actively reverse Chrome patches. The gap between "not yet exploited" and "exploited" for this bug class is routinely measured in days, not months.
Detection & Response
You cannot detect the type confusion itself from the endpoint — it executes inside the renderer as legitimate-looking JavaScript. What you can detect is the post-exploitation behavior that follows a successful renderer compromise, and you can inventory unpatched browsers at scale.
SIGMA Rules
The single highest-fidelity signal of a Chrome exploit chain succeeding is the browser process tree doing something browsers never legitimately do: spawning shells, script interpreters, or LOLBins. These rules are battle-tested in our SOC and fire near-zero false positives outside of developer workstations.
---
title: Chrome Renderer Spawning Shell or Script Interpreter
id: 8f2c4b91-6e3d-4a17-b952-0d7e5f1a3c48
status: experimental
description: Detects chrome.exe spawning cmd.exe, powershell, wscript, cscript, mshta, rundll32, or regsvr32 — a hallmark of successful browser exploit chains and sandbox escapes such as those targeting V8 type confusion vulnerabilities like CVE-2026-85046.
references:
- http://chromereleases.googleblog.com/2026/09/stable-channel-update-for-desktop_01882797386.html
- https://attack.mitre.org/techniques/T1203/
author: Security Arsenal
date: 2026/09/18
tags:
- attack.initial_access
- attack.t1203
- attack.execution
logsource:
category: process_creation
product: windows
detection:
selection_parent:
ParentImage|endswith: '\chrome.exe'
selection_child:
Image|endswith:
- '\cmd.exe'
- '\powershell.exe'
- '\pwsh.exe'
- '\wscript.exe'
- '\cscript.exe'
- '\mshta.exe'
- '\rundll32.exe'
- '\regsvr32.exe'
- '\msiexec.exe'
- '\certutil.exe'
- '\bitsadmin.exe'
condition: selection_parent and selection_child
falsepositives:
- Rare — enterprise browser extensions with native messaging hosts; validate and whitelist by full path
level: high
---
title: Chrome CrashReporting Process Anomalous Child Execution
id: 3b9d7e26-1f48-4c5a-9d63-7e2a8b0f5d19
status: experimental
description: Detects crashpad_handler.exe (Chrome CrashReporting component, affected by CVE-2026-85052) spawning unexpected child processes. Crashpad should never launch command interpreters or system utilities.
references:
- http://chromereleases.googleblog.com/2026/09/stable-channel-update-for-desktop_01882797386.html
- https://attack.mitre.org/techniques/T1203/
author: Security Arsenal
date: 2026/09/18
tags:
- attack.initial_access
- attack.t1203
logsource:
category: process_creation
product: windows
detection:
selection_parent:
ParentImage|endswith: '\crashpad_handler.exe'
selection_child:
Image|endswith:
- '\cmd.exe'
- '\powershell.exe'
- '\pwsh.exe'
- '\wscript.exe'
- '\cscript.exe'
- '\mshta.exe'
- '\rundll32.exe'
- '\whoami.exe'
- '\net.exe'
- '\nltest.exe'
condition: selection_parent and selection_child
falsepositives:
- Extremely rare — investigate all hits
level: critical
---
title: Chrome Writing Executable Content to User-Writable Directories
id: 5e1a8c43-2d96-4b78-a3f1-9c6d2e7b4a05
status: experimental
description: Detects chrome.exe writing PE executables or scripts to Temp, AppData, or Downloads followed by execution patterns consistent with post-exploitation payload staging after a renderer compromise.
references:
- https://attack.mitre.org/techniques/T1204.002/
author: Security Arsenal
date: 2026/09/18
tags:
- attack.execution
- attack.t1204.002
logsource:
category: file_event
product: windows
detection:
selection_image:
Image|endswith: '\chrome.exe'
selection_path:
TargetFilename|contains:
- '\AppData\Local\Temp\'
- '\AppData\Roaming\'
- '\Downloads\'
selection_ext:
TargetFilename|endswith:
- '.exe'
- '.dll'
- '.ps1'
- '.bat'
- '.js'
- '.hta'
condition: selection_image and selection_path and selection_ext
falsepositives:
- Chrome software updater writes to AppData — filter known updater paths (GoogleUpdate) and known installer hashes
level: medium
KQL — Microsoft Sentinel / Defender
This query hunts Chrome child-process anomalies across the estate and simultaneously flags devices still running vulnerable builds via process version telemetry. Run it over a 7-day lookback; any hit on the child-process logic is a ticket, not a trend.
// Hunt 1: Chrome spawning suspicious child processes (post-exploitation indicator)
DeviceProcessEvents
| where TimeGenerated > ago(7d)
| where InitiatingProcessFileName =~ "chrome.exe" or InitiatingProcessFileName =~ "crashpad_handler.exe"
| where FileName in~ ("cmd.exe","powershell.exe","pwsh.exe","wscript.exe","cscript.exe","mshta.exe","rundll32.exe","regsvr32.exe","certutil.exe","bitsadmin.exe","msiexec.exe","whoami.exe","net.exe")
| project TimeGenerated, DeviceName, AccountName, InitiatingProcessFileName, FileName, ProcessCommandLine, InitiatingProcessCommandLine, SHA256, ReportId
| order by TimeGenerated desc;
// Hunt 2: Inventory devices running Chrome builds older than 152.0.7977.82
DeviceProcessEvents
| where TimeGenerated > ago(1d)
| where FileName =~ "chrome.exe"
| extend ChromeVersion = tostring(ProcessVersionInfoProductVersion)
| where ChromeVersion startswith "152." or ChromeVersion startswith "151." or ChromeVersion startswith "150."
| extend VersionParts = split(ChromeVersion, ".")
| extend Build = toint(VersionParts[2]), Rev = toint(VersionParts[3])
| where Build < 7977 or (Build == 7977 and Rev < 82)
| summarize LastSeen = max(TimeGenerated), Versions = make_set(ChromeVersion) by DeviceName
| order by LastSeen desc;
Velociraptor VQL
Use this artifact for rapid fleet-wide scoping during an IR retainer or threat hunt — it enumerates Chrome processes, their versions, and any suspicious children in one pass.
-- Chrome exploitation hunt: enumerate chrome processes, versions, and suspicious children
SELECT Pid, Ppid, Name, Exe, CommandLine, Username, CreateTime,
parse_file(path=Exe).Version AS ChromeVersion,
if(condition=CommandLine =~ '(cmd|powershell|pwsh|wscript|cscript|mshta|rundll32|regsvr32|certutil)',
then='SUSPICIOUS_CHILD', else='') AS Verdict
FROM pslist()
WHERE Name =~ 'chrome|crashpad'
OR Exe =~ '\\chrome\.exe$'
For a targeted sweep of vulnerable builds:
-- Identify endpoints with unpatched Chrome installations
SELECT FullPath, Size, Mtime,
parse_pe_file(file=FullPath).FileVersion AS InstalledVersion
FROM glob(globs=['C:/Program Files/Google/Chrome/Application/chrome.exe',
'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe'])
WHERE InstalledVersion < '152.0.7977.82'
Remediation / Verification Script
Deploy via Intune, SCCM, GPO startup script, or your RMM. It checks installed Chrome version, forces an update check, and reports non-compliant endpoints.
# Chrome 152.0.7977.82 compliance check and remediation trigger
# Security Arsenal — CVE-2026-85046 / CVE-2026-85052 response
$MinVersion = [version]"152.0.7977.82"
$ChromePaths = @(
"$env:ProgramFiles\Google\Chrome\Application\chrome.exe",
"${env:ProgramFiles(x86)}\Google\Chrome\Application\chrome.exe"
)
$Installed = $null
foreach ($p in $ChromePaths) {
if (Test-Path $p) {
$Installed = (Get-Item $p).VersionInfo.ProductVersion
break
}
}
if (-not $Installed) {
Write-Output "NOT_INSTALLED"
exit 0
}
if ([version]$Installed -ge $MinVersion) {
Write-Output "COMPLIANT: Chrome $Installed"
exit 0
}
Write-Output "NON_COMPLIANT: Chrome $Installed < $MinVersion — triggering update"
# Trigger Google Update silently
$UpdateExe = "$env:ProgramFiles(x86)\Google\Update\GoogleUpdate.exe"
if (Test-Path $UpdateExe) {
Start-Process $UpdateExe -ArgumentList "/ua /installsource scheduler" -Wait
}
# Re-check after update attempt
Start-Sleep -Seconds 30
foreach ($p in $ChromePaths) {
if (Test-Path $p) {
$NewVersion = [version](Get-Item $p).VersionInfo.ProductVersion
if ($NewVersion -ge $MinVersion) {
Write-Output "REMEDIATED: Chrome now $NewVersion (browser restart required)"
exit 0
}
}
}
Write-Output "FAILED: Chrome still vulnerable — escalate for manual remediation"
exit 1
For Linux fleets:
#!/bin/bash
# Chrome version compliance check — CVE-2026-85046 / CVE-2026-85052
MIN_VERSION="152.0.7977.82"
CURRENT=$(google-chrome --version 2>/dev/null | awk '{print $3}')
if [ -z "$CURRENT" ]; then
echo "NOT_INSTALLED"
exit 0
fi
if [ "$(printf '%s\n' "$MIN_VERSION" "$CURRENT" | sort -V | head -n1)" = "$MIN_VERSION" ]; then
echo "COMPLIANT: Chrome $CURRENT"
else
echo "NON_COMPLIANT: Chrome $CURRENT < $MIN_VERSION"
apt-get update && apt-get install -y --only-upgrade google-chrome-stable || \
yum update -y google-chrome-stable
fi
Remediation
-
Patch immediately. Update all Chrome installations to 152.0.7977.82/.83 (Windows/Mac) or 152.0.7977.82 (Linux). Chrome auto-updates, but enterprise environments with pinned versions, kiosk systems, and users who never restart the browser are your exposure window. Enforce a browser restart policy — the patch does not take effect until relaunch.
-
Verify via enterprise tooling. Query your MDM/EDR for
chrome.exefile versions below 152.0.7977.82. The KQL inventory query above gives you a fleet-wide picture in seconds. -
Don't forget Chromium derivatives. Microsoft Edge, Brave, Opera, and Vivaldi all embed V8. Track their respective security releases — Edge typically follows within 24–48 hours of a Chromium security drop.
-
Enable site isolation and strict site isolation policies if not already enforced (
SitePerProcessis default-on, but verify viachrome://policy). Renderer-level mitigations raise the cost of chaining CVE-2026-85046 into a full compromise. -
Monitor for exploitation indicators using the detection content above. If Google later flags either CVE as exploited in the wild, escalate to emergency change and check CISA KEV for a federal remediation deadline (typically 3 weeks for browser CVEs once cataloged).
-
Reference the official advisory: Chrome Releases Blog — Stable Channel Update for Desktop and the Chrome Security Page for the full fix list as details are de-restricted.
The pattern here is one we've seen repeat across every major browser exploitation campaign: a V8 primitive, a sandbox escape, and a delivery vector that requires nothing from the user but a click. Your patch window is your exploit window. Close it.
Related Resources
Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub
Is your security operations ready?
Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.