Back to Intelligence

Chrome 156 Stable Channel Update: 353 Security Fixes — Enterprise Patch Verification and Detection Guide

SA
Security Arsenal Team
October 21, 2026
10 min read

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

PlatformFixed Version
Windows156.0.8078.47 / 156.0.8078.48
Mac156.0.8078.47 / 156.0.8078.48
Linux156.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:

  1. 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.
  2. 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.
  3. 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

YAML
---
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.

KQL — Microsoft Sentinel / Defender
// 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.

VQL — Velociraptor
-- 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.

PowerShell
# 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

  1. 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.
  2. Enforce browser restarts. Automatic update delivery is not the same as patch application. Set an enterprise policy forcing relaunch: on Windows, deploy the RelaunchNotification and RelaunchNotificationPeriod Chrome enterprise policies (maximum 168 hours recommended — tighter for high-risk user populations); on managed Linux/macOS, use your MDM to prompt or force restart.
  3. 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%.
  4. 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.
  5. 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.
  6. 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.