Google has promoted Chrome 156 to the stable channel for Windows, Mac, and Linux, rolling out version 156.0.8078.47 on Linux and 156.0.8078.47/.48 on Windows and Mac over the coming days and weeks. The headline number here is the one that should get every vulnerability management team's attention: this update includes 353 security fixes.
Google's release note follows the standard Chromium disclosure policy — access to individual bug details and links remains restricted until a majority of users have updated, and restrictions persist where bugs live in third-party libraries that downstream projects have not yet patched. That means the public details are thin right now, and that is precisely why defenders should treat this as an urgent patch event rather than waiting for per-CVE write-ups. Historically, Chrome stable releases carrying this volume of fixes include high-severity memory corruption bugs in V8, Blink, Skia, and ANGLE — the same component classes that have repeatedly shown up in exploited-in-the-wild Chrome zero-days throughout 2025 and 2026.
The browser is the single largest attack surface on the modern endpoint. Drive-by exploitation, malvertising, watering-hole campaigns, and renderer-to-sandbox-escape chains all begin with an unpatched browser. A fleet running anything below 156.0.8078.47 after this rollout window closes is a fleet exposed to 353 known-fixed conditions — some percentage of which threat actors will reverse-engineer from the Chromium source diffs within days.
Technical Analysis
Affected Products and Versions
| Platform | Fixed Version |
|---|---|
| Windows | 156.0.8078.47 / 156.0.8078.48 |
| Mac | 156.0.8078.47 / 156.0.8078.48 |
| Linux | 156.0.8078.47 |
Any Chrome installation reporting a version below 156.0.8078.47 is unpatched against all 353 fixes. Extended Stable channel users should verify their channel-specific build against the Chrome Security Page.
CVEs and Scoring
Google has not yet published the individual CVE identifiers, CVSS scores, or the reward breakdown for this release — consistent with its policy of withholding bug details until the majority of users are updated. Per the advisory: "Access to bug details and links may be kept restricted until a majority of users are updated with a fix." Do not wait for the CVE list. The defensive priority is fleet version compliance, not per-CVE triage. Once details are un-restricted on the Chromium issue tracker and the Chrome Security Page, re-prioritize any Critical/High entries for expedited verification.
Why This Update Matters From a Defender's Perspective
A 353-fix release is at the high end of Chrome patch volume. Practically, this tells us:
- Patch diffing is already underway. Because Chrome is built on open-source Chromium, every fix maps to a visible commit. Skilled exploit developers routinely diff stable releases against prior builds to identify the patched vulnerability classes and build n-day exploits before enterprises finish their rollout. The window between stable release and reliable n-day exploitation has compressed to days — sometimes hours — for renderer and V8 bugs.
- Third-party library risk propagates. Google's note about retaining restrictions for bugs in third-party libraries means some of these fixes cover shared components (historically libraries like libwebp, libvpx, Skia, ANGLE, and zlib) that other vendors' products also embed. Watch for downstream advisories from Electron-based applications, Edge, and embedded Chromium frameworks.
- Restart is the enforcement point. Chrome downloads updates automatically, but the patch does not take effect until the browser restarts. In environments where users keep browser sessions open for weeks, the binary on disk may be updated while the running process remains the vulnerable version. Your detection logic must check the running process version, not just the installed binary.
Exploitation Status
As of this release, Google has not flagged any of the 353 fixes as actively exploited zero-days (such announcements are typically called out explicitly in the release post, as they were for multiple in-the-wild Chrome zero-days patched in 2025). However, the volume of fixes and the embargo on bug details warrant treating this as a high-urgency update. Monitor the CISA Known Exploited Vulnerabilities catalog and the Chrome Security Page for post-release additions.
Detection & Response
The highest-value detection work for a mass browser patch is fleet version compliance hunting — identifying endpoints still running pre-156 builds — plus behavioral detections for post-exploitation activity originating from the browser process, which is how successful renderer exploitation typically surfaces.
SIGMA Rules
---
title: Chrome Renderer or Utility Process Spawning Command Shell
description: Detects chrome.exe spawning cmd.exe, powershell.exe, or script interpreters — a strong post-exploitation indicator following renderer or sandbox compromise. Browsers should essentially never spawn shells in normal operation.
references:
- https://chromereleases.googleblog.com/
- https://attack.mitre.org/techniques/T1203/
author: Security Arsenal
date: 2026/10/21
id: 6b1f3a9c-2d4e-4f8a-b7c1-9e5d2a8f3c04
status: experimental
tags:
- attack.execution
- attack.t1203
- attack.t1059
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'
condition: selection_parent and selection_child
falsepositives:
- Rare enterprise browser extensions invoking local helpers
- Legitimate software updaters launched from browser (investigate command line)
level: high
---
title: Outdated Chrome Version Executing on Endpoint
description: Detects execution of Chrome builds older than 156.0.8078.47 via command-line version artifacts or non-standard install paths. Correlate with software inventory; tunable to environment baseline.
references:
- https://chromereleases.googleblog.com/
- https://attack.mitre.org/techniques/T1203/
author: Security Arsenal
date: 2026/10/21
id: 3c8e5f1a-7b2d-4a9e-8c6f-1d4b7e2a5f09
status: experimental
tags:
- attack.execution
- attack.t1203
logsource:
category: process_creation
product: windows
detection:
selection_path:
Image|contains:
- '\AppData\Local\Google\Chrome\'
- '\AppData\Local\Temp\'
- '\Users\Public\'
- '\ProgramData\'
filter_standard:
Image|startswith:
- 'C:\Program Files\Google\Chrome\Application\'
- 'C:\Program Files (x86)\Google\Chrome\Application\'
condition: selection_path and not filter_standard
falsepositives:
- Portable Chrome deployments
- User-scope Chrome installs under AppData (legitimate but unmanaged — flag for review)
level: medium
---
title: Suspicious Child Process From Chromium-Based Browser on Linux
description: Detects chrome or chromium processes spawning shells or download tools on Linux, consistent with post-exploitation behavior following browser compromise.
references:
- https://chromereleases.googleblog.com/
- https://attack.mitre.org/techniques/T1203/
author: Security Arsenal
date: 2026/10/21
id: 9d2a7c4e-5f1b-4e8a-9d3c-6a8f1b4e7c02
status: experimental
tags:
- attack.execution
- attack.t1203
- attack.t1059.004
logsource:
category: process_creation
product: linux
detection:
selection_parent:
ParentImage|endswith:
- '/chrome'
- '/chromium'
- '/chromium-browser'
selection_child:
Image|endswith:
- '/bash'
- '/sh'
- '/dash'
- '/curl'
- '/wget'
- '/python'
- '/python3'
- '/perl'
- '/nc'
- '/ncat'
condition: selection_parent and selection_child
falsepositives:
- Developer workflows launching terminals from browser-based IDEs
level: high
KQL — Microsoft Sentinel / Defender
The most important hunt this week is not a behavioral query — it is the version compliance sweep. This query inventories Chrome process execution across the fleet and flags anything below the patched build, including the case where the updated binary is installed but the old process is still running.
// Hunt 1: Fleet-wide Chrome version compliance — flag any running Chrome below 156.0.8078.47
DeviceProcessEvents
| where TimeGenerated > ago(7d)
| where FileName =~ "chrome.exe"
| extend VersionParts = split(FileVersion, ".")
| extend Major = toint(VersionParts[0]), Build = toint(VersionParts[2]), Patch = toint(VersionParts[3])
| extend IsCompliant = iff(Major > 156 or (Major == 156 and Build > 8078) or (Major == 156 and Build == 8078 and Patch >= 47), true, false)
| where IsCompliant == false
| summarize LastSeen = max(TimeGenerated), ReportedVersion = any(FileVersion) by DeviceName, ReportedVersion
| order by LastSeen desc
// Hunt 2: Behavioral — Chrome spawning LOLBins or shells (post-exploitation TTP)
DeviceProcessEvents
| where TimeGenerated > ago(14d)
| where InitiatingProcessFileName =~ "chrome.exe"
| where FileName in~ ("cmd.exe", "powershell.exe", "pwsh.exe", "mshta.exe", "wscript.exe", "cscript.exe", "rundll32.exe", "regsvr32.exe", "certutil.exe", "bitsadmin.exe")
| project TimeGenerated, DeviceName, AccountName, InitiatingProcessCommandLine, FileName, ProcessCommandLine, SHA256
| order by TimeGenerated desc
// Hunt 3: Linux endpoints ingested via Syslog/CEF — shell spawned by browser process
Syslog
| where TimeGenerated > ago(14d)
| where ProcessName has_any ("chrome", "chromium")
| where SyslogMessage has_any ("/bin/bash", "/bin/sh", "curl ", "wget ", "python")
| project TimeGenerated, Computer, ProcessName, SyslogMessage
| order by TimeGenerated desc
Velociraptor VQL
Use this artifact during triage sweeps to pull the on-disk Chrome version and identify endpoints where the installed binary has been updated but a stale, vulnerable process is still running — a common gap when users defer restarts.
-- Enumerate Chrome version from registry/uninstall keys and running processes
SELECT
Name AS ProcessName,
Pid,
Exe AS ProcessPath,
CreateTime AS ProcessStart,
Username
FROM pslist()
WHERE Name =~ '(?i)chrome\.exe' OR Exe =~ '(?i)chrome'
-- Companion: read installed Chrome version from Windows registry
SELECT
FullPath,
Data.value AS InstalledVersion,
Mtime AS KeyLastWrite
FROM glob(
globs='HKEY_LOCAL_MACHINE\\SOFTWARE\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Google Chrome\\DisplayVersion',
accessor='registry'
)
Remediation and Verification Script
Run this PowerShell via your RMM, Intune, or GPO startup script to verify Chrome version compliance and force the update path. It reports the installed version, flags non-compliant hosts, and triggers Chrome's update mechanism where Google Update is present.
# Chrome 156 Compliance Verification - Security Arsenal
# Target: 156.0.8078.47 or higher
$targetVersion = [version]"156.0.8078.47"
$results = [PSCustomObject]@{
Hostname = $env:COMPUTERNAME
InstalledVersion = $null
RunningVersion = $null
Compliant = $false
StaleProcessFound = $false
}
# Check installed version via registry (covers both machine and user scope)
$regPaths = @(
"HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\Google Chrome",
"HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\Google Chrome",
"HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\Google Chrome"
)
foreach ($path in $regPaths) {
if (Test-Path $path) {
$v = (Get-ItemProperty $path -ErrorAction SilentlyContinue).DisplayVersion
if ($v) { $results.InstalledVersion = $v; break }
}
}
# Check RUNNING chrome.exe processes - patch not effective until restart
$chromeProcs = Get-Process chrome -ErrorAction SilentlyContinue
if ($chromeProcs) {
$runningFile = $chromeProcs[0].Path
if ($runningFile) {
$results.RunningVersion = (Get-Item $runningFile).VersionInfo.ProductVersion
if ($results.InstalledVersion -and $results.RunningVersion) {
if ([version]$results.RunningVersion -lt $targetVersion -and [version]$results.InstalledVersion -ge $targetVersion) {
$results.StaleProcessFound = $true
}
}
}
}
# Compliance check on installed version
if ($results.InstalledVersion) {
$results.Compliant = ([version]$results.InstalledVersion -ge $targetVersion)
}
# Trigger Google Update if non-compliant and update service exists
if (-not $results.Compliant) {
$updateExe = "$env:ProgramFiles(x86)\Google\Update\GoogleUpdate.exe"
if (Test-Path $updateExe) {
Start-Process $updateExe -ArgumentList "/ua /installsource scheduler" -NoNewWindow
Write-Output "Triggered Google Update on $env:COMPUTERNAME"
}
}
$results | Format-List
# Exit code for RMM alerting: 1 if non-compliant or stale process, 0 if clean
if (-not $results.Compliant -or $results.StaleProcessFound) { exit 1 } else { exit 0 }
Remediation
- Patch to 156.0.8078.47/.48 immediately. Do not wait for the CVE detail embargo to lift. Chrome stable releases of this fix volume historically include Critical and High severity memory-corruption bugs that become n-day targets within days of disclosure.
- Enforce browser restarts. Automatic update delivery is not the same as patch application. Set an enterprise policy forcing relaunch: on Windows, deploy the
RelaunchNotificationandRelaunchNotificationPeriodChrome enterprise policies (maximum 168 hours recommended — tighter for high-risk user populations); on managed Linux/macOS, use your MDM to prompt or force restart. - Verify the running process, not the binary. As covered above, the vulnerable renderer stays in memory until restart. Use the KQL compliance query and the PowerShell script above weekly until fleet compliance exceeds 98%.
- Audit Electron and embedded Chromium applications. With Google explicitly noting third-party library fixes, inventory applications bundling Chromium (Electron apps, CEF-based tooling, Edge WebView2 consumers) and track their downstream patches — they will lag Chrome stable by days to weeks.
- Monitor for post-release escalation. Watch the Chrome Releases blog, the Chrome Security Page, and the CISA KEV catalog. If any fix from this release is later confirmed exploited in the wild, CISA KEV inclusion typically carries a 7–21 day federal remediation deadline that private-sector teams should mirror.
- Reduce browser attack surface as compensating control. Enforce site isolation (on by default in current builds — verify it has not been disabled via policy), block legacy protocol handlers, restrict browser extension installation to an allowlist via
ExtensionInstallAllowlist, and consider network-level filtering of newly registered domains while the fleet patches.
The gap between "update available" and "update applied and restarted" is where browser exploitation lives. Close it deliberately, measure it continuously, and treat the running-process check as your source of truth.
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.