Back to Intelligence

CVE-2026-19137 & CVE-2026-19149: Critical Chrome Use-After-Free Flaws (v151.0.7922.108) — Detection and Remediation Guide

SA
Security Arsenal Team
August 7, 2026
10 min read

Google has pushed an out-of-cycle stable channel update for Chrome on desktop, addressing 41 security fixes in a single build. Among them are two Critical-severity use-after-free vulnerabilities:

  • CVE-2026-19137 — Use after free in WebGL, reported anonymously on 2026-04-05 (bug ID 499602793)
  • CVE-2026-19149 — Use after free in Aura (Chrome's UI framework), reported internally by Google on 2026-06-17 (bug ID 524824288)

The fixed builds are 151.0.7922.108/.109 for Windows and macOS and 151.0.7922.108 for Linux, rolling out over the coming days and weeks.

Use-after-free vulnerabilities in browser renderers and UI frameworks are the bread and butter of both exploit brokers and advanced threat actors. WebGL is reachable from any web page via JavaScript without user interaction beyond visiting a page, which makes CVE-2026-19137 a prime candidate for drive-by exploitation — potentially leading to full renderer compromise and, when chained with a sandbox escape, complete host takeover. If your organization hasn't enforced this update, your browser fleet is your attack surface.

Technical Analysis

Affected Products and Versions

ProductAffected VersionsFixed VersionPlatform
Google Chrome< 151.0.7922.108151.0.7922.108/.109Windows
Google Chrome< 151.0.7922.108151.0.7922.108/.109macOS
Google Chrome< 151.0.7922.108151.0.7922.108Linux

Chromium-based downstream browsers (Microsoft Edge, Brave, Vivaldi, Opera) typically inherit Blink/V8/WebGL fixes on their own release cadence. Track their respective security release notes — do not assume a Chromium engine version match means the fix has landed downstream.

CVE Details

  • CVE-2026-19137 — Use after free in WebGL. Chrome's WebGL implementation (built on ANGLE, which translates OpenGL ES calls to Direct3D/Metal/Vulkan) processes attacker-controlled shader and buffer objects from any web page. A UAF here means an object is freed and subsequently referenced, allowing heap manipulation that — with precise grooming — can yield arbitrary read/write primitives inside the renderer process. The bug was reported by an external anonymous researcher, which historically correlates with higher exploit maturity at time of disclosure.
  • CVE-2026-19149 — Use after free in Aura, Chrome's windowing and UI compositing framework. Aura bugs are less commonly exploited remotely because the attack surface isn't directly reachable from web content in the same way WebGL is, but critical-rated UAFs in UI code have been leveraged in sandbox-escape chains.

Google has restricted bug details — standard practice until a majority of users are patched. No CVSS scores have been published in the advisory; both carry Chrome's own Critical severity rating, the highest tier, reserved for flaws that could allow an attacker to escape the sandbox or execute code beyond the renderer.

Exploitation Status

As of this writing, Google's advisory does not flag either CVE as exploited in the wild (no "Google is aware that an exploit exists" notice was included), and neither CVE appears in CISA's Known Exploited Vulnerabilities catalog yet. However, treat this as a narrowing window, not a comfort blanket:

  • Anonymous external reports of critical WebGL UAFs frequently originate from exploit development circles.
  • Bug details, once un-restricted, often enable rapid reverse engineering of the patch diff. Patch-diff-to-working-PoC turnaround for Chrome renderer bugs is routinely measured in days, not weeks.
  • The 41-fix volume means multiple lower-severity bugs in the same build may provide the sandbox-escape or info-leak primitives needed to chain with these criticals.

Attack Chain (Defender's View)

  1. User visits a malicious or compromised web page (watering hole, malvertising, phishing link).
  2. JavaScript executes crafted WebGL operations (shader compilation, buffer deletion/reuse sequences) triggering the UAF in the GPU/renderer process.
  3. Heap grooming converts the UAF into arbitrary read/write within the renderer.
  4. A second flaw (potentially among the other 39 fixes in this build, or a UI-layer bug like CVE-2026-19149) is used to escape the sandbox.
  5. Post-exploitation payload executes as the user — credential theft, persistence, lateral movement staging.

The observable telemetry for defenders centers on renderer/GPU process crashes, crash loops on specific domains, and post-crash child process anomalies — chrome.exe spawning unexpected children, renderer processes communicating to unusual destinations, and crash dump artifacts.

Detection & Response

Because the exploitation vector is JavaScript-driven, pre-patch detection is about identifying crash patterns consistent with UAF exploitation attempts and post-exploitation behavior from the browser process. Post-patch, detection pivots to identifying unpatched endpoints, which is your highest-fidelity signal of residual risk.

Sigma Rules

YAML
---
title: Chrome Renderer Crash Loop Indicative of Exploitation Attempt
id: 6c1a2b94-3e78-4f2a-9d51-8b7e6c5a1234
status: experimental
description: Detects repeated chrome.exe renderer or GPU process crashes within a short window, a pattern consistent with use-after-free exploitation attempts against WebGL (CVE-2026-19137) where heap grooming frequently requires multiple attempts before success.
references:
  - https://chromereleases.googleblog.com/2026/08/stable-channel-update-for-desktop_01193673229.html
  - https://attack.mitre.org/techniques/T1189/
author: Security Arsenal
date: 2026/08/12
tags:
  - attack.initial_access
  - attack.t1189
logsource:
  category: process_creation
  product: windows
detection:
  selection_crash_handler:
    Image|endswith:
      - '\chrome_crashpad.exe'
      - '\chrome_crashpad_handler.exe'
    CommandLine|contains:
      - '--no-rate-limit'
      - '--attachment'
  condition: selection_crash_handler
falsepositives:
  - Legitimate browser instability on misbehaving sites or driver issues
level: medium
---
title: Chrome Browser Process Spawning Suspicious Child Processes
id: 9f3d7c21-5a48-4e91-b6d2-2c8f1a4e5678
status: experimental
description: Detects chrome.exe spawning script interpreters, command shells, or system utilities. Legitimate Chrome usage rarely spawns such children; this behavior is characteristic of post-renderer-compromise payloads following successful exploitation of renderer bugs such as CVE-2026-19137.
references:
  - https://chromereleases.googleblog.com/2026/08/stable-channel-update-for-desktop_01193673229.html
  - https://attack.mitre.org/techniques/T1189/
author: Security Arsenal
date: 2026/08/12
tags:
  - attack.initial_access
  - attack.execution
  - attack.t1189
  - 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'
      - '\certutil.exe'
      - '\bitsadmin.exe'
      - '\wmic.exe'
  condition: selection_parent and selection_child
falsepositives:
  - Browser extensions or enterprise SSO helpers spawning system tools (rare; tune per environment)
level: high
---
title: Unpatched Chrome Version Execution Below 151.0.7922.108
id: 2b8e4f63-7d19-4a35-c8e4-5d9a3b7c9012
status: experimental
description: Detects launch of chrome.exe from a user profile path where the binary version directory indicates a build older than 151.0.7922.108. Complements file-version inventory checks by catching execution of stale Chrome installs, portable copies, and per-user installs that evade managed patching.
references:
  - https://chromereleases.googleblog.com/2026/08/stable-channel-update-for-desktop_01193673229.html
author: Security Arsenal
date: 2026/08/12
tags:
  - attack.initial_access
  - attack.t1189
logsource:
  category: process_creation
  product: windows
detection:
  selection:
    Image|contains:
      - '\AppData\Local\Google\Chrome\'
      - '\Chrome SxS\'
  filter_current:
    Image|contains:
      - '\151.0.7922.108\'
      - '\151.0.7922.109\'
  condition: selection and not filter_current
falsepositives:
  - Canary or enterprise-pinned builds managed under separate policy; verify version via file metadata rather than path alone where possible
level: medium

KQL — Microsoft Sentinel / Defender

The following hunts cover three angles: vulnerable version inventory, crash-pattern hunting, and post-exploitation process behavior.

KQL — Microsoft Sentinel / Defender
// Hunt 1: Inventory Chrome file versions across the fleet — flag anything below 151.0.7922.108
DeviceFileEvents
| where TimeGenerated > ago(7d)
| where FileName =~ "chrome.exe"
| extend Version = tostring(split(FolderPath, "\\")[array_length(split(FolderPath, "\\")) - 2])
| where Version startswith "1" and Version !startswith "151.0.7922.108" and Version !startswith "151.0.7922.109"
| summarize LastSeen = max(TimeGenerated), Version = any(Version) by DeviceName, FolderPath
| sort by DeviceName asc
;
// Hunt 2: Chrome spawning script interpreters or LOLBins — post-renderer-compromise behavior
DeviceProcessEvents
| where TimeGenerated > ago(14d)
| where InitiatingProcessFileName =~ "chrome.exe"
| where FileName in~ ("cmd.exe","powershell.exe","pwsh.exe","wscript.exe","cscript.exe","mshta.exe","rundll32.exe","regsvr32.exe","certutil.exe","bitsadmin.exe","wmic.exe")
| project TimeGenerated, DeviceName, AccountName, InitiatingProcessCommandLine, FileName, ProcessCommandLine, SHA256
| sort by TimeGenerated desc
;
// Hunt 3: Renderer/GPU crash loop correlation — repeated chrome crashpad activity per device
DeviceProcessEvents
| where TimeGenerated > ago(7d)
| where FileName has "chrome_crashpad"
| summarize CrashEvents = count(), DistinctTimes = makeset(TimeGenerated, 20) by DeviceName, bin(TimeGenerated, 1h)
| where CrashEvents >= 5
| sort by CrashEvents desc

Velociraptor VQL

Use this hunt artifact to enumerate installed Chrome versions at scale and simultaneously flag suspicious child processes of chrome.exe — the two questions you need answered during triage.

VQL — Velociraptor
-- Enumerate Chrome binary version and flag suspicious children of chrome.exe
SELECT Pid, Name, Exe, CommandLine, Username, CreateTime,
       version(string=Exe) AS ExeVersion
FROM pslist()
WHERE Name =~ '(?i)chrome'
UNION
SELECT Pid, Name, Exe, CommandLine, Username, CreateTime,
       NULL AS ExeVersion
FROM pslist()
WHERE Name =~ '(?i)(cmd|powershell|pwsh|wscript|cscript|mshta|rundll32|regsvr32|certutil|bitsadmin|wmic)'
  AND get(pid=Pid).Ppid IN (SELECT Pid FROM pslist() WHERE Name =~ '(?i)chrome')

For a cleaner version-only sweep across endpoints, glob the install directories directly:

VQL — Velociraptor
-- Enumerate all Chrome installation version folders to identify unpatched builds
SELECT FullPath, Mtime,
       basename(path=FullPath) AS VersionDir
FROM glob(globs=['C:/Program Files/Google/Chrome/Application/*/chrome.exe',
                 'C:/Program Files (x86)/Google/Chrome/Application/*/chrome.exe',
                 'C:/Users/*/AppData/Local/Google/Chrome/Application/*/chrome.exe'])
WHERE VersionDir !~ '151\\.0\\.7922\\.10[89]'

Remediation Script

The following PowerShell audits installed Chrome versions (system and per-user), reports non-compliant hosts, and optionally triggers the enterprise installer. Deploy via Intune, SCCM, or your RMM.

PowerShell
# Chrome CVE-2026-19137 / CVE-2026-19149 compliance audit and remediation
# Fixed versions: 151.0.7922.108 (Win/Linux) / 151.0.7922.109 (Mac)
$FixedVersion = [version]"151.0.7922.108"
$chromePaths = @(
    "$env:ProgramFiles\Google\Chrome\Application\chrome.exe",
    "${env:ProgramFiles(x86)}\Google\Chrome\Application\chrome.exe",
    "$env:LOCALAPPDATA\Google\Chrome\Application\chrome.exe"
)
$nonCompliant = $false
foreach ($path in $chromePaths) {
    if (Test-Path $path) {
        $installed = [version](Get-Item $path).VersionInfo.ProductVersion
        if ($installed -lt $FixedVersion) {
            Write-Warning "NON-COMPLIANT: $path is version $installed (requires >= $FixedVersion)"
            $nonCompliant = $true
        } else {
            Write-Host "OK: $path is version $installed"
        }
    }
}
if ($nonCompliant) {
    # Trigger Chrome Enterprise silent update via winget, or download the MSI from:
    # https://chromeenterprise.google/browser/download/
    Write-Host "Triggering update via winget..."
    winget upgrade --id Google.Chrome --silent --accept-package-agreements --accept-source-agreements
    # Force-close running Chrome to allow the updater to complete (users will need to relaunch)
    Get-Process chrome -ErrorAction SilentlyContinue | Stop-Process -Force
    exit 1  # Signal management platform that remediation was required
} else {
    exit 0
}

For Linux fleets managed via package managers:

Bash / Shell
#!/bin/bash
# Audit and patch Chrome on Debian/Ubuntu and RHEL/Fedora systems
FIXED="151.0.7922.108"
CURRENT=$(google-chrome --version 2>/dev/null | awk '{print $3}')
if [ -z "$CURRENT" ]; then echo "Chrome not installed"; exit 0; fi
if [ "$(printf '%s\n' "$FIXED" "$CURRENT" | sort -V | head -n1)" != "$FIXED" ]; then
  echo "NON-COMPLIANT: $CURRENT < $FIXED — updating"
  if command -v apt-get >/dev/null; then
    apt-get update && apt-get install --only-upgrade -y google-chrome-stable
  elif command -v dnf >/dev/null; then
    dnf upgrade -y google-chrome-stable
  elif command -v yum >/dev/null; then
    yum update -y google-chrome-stable
  fi
  echo "Post-update version: $(google-chrome --version)"
else
  echo "OK: Chrome $CURRENT meets $FIXED"
fi

Remediation

  1. Patch immediately. Enforce Chrome 151.0.7922.108/.109 (Windows/macOS) and 151.0.7922.108 (Linux) across the fleet. Chrome auto-updates on relaunch — but only on relaunch. Force a browser restart policy or communicate the relaunch requirement to users; a running 150.x process is still a vulnerable process.
  2. Use enterprise controls to verify, not trust. Chrome Browser Cloud Management or your MDM should report actual installed versions. Query for stale installs, portable Chrome copies in user profiles, and per-user installs that evade system-level patching.
  3. Patch Chromium-based downstreams. Confirm Edge and any other Chromium browsers in your environment have shipped the equivalent fix. Their release trains lag upstream Chrome.
  4. Reduce the WebGL attack surface where business-tolerable. For high-risk user populations (executives, finance, admins), consider Chrome policies disabling WebGL (WebGLAllowed / DefaultWebGL2ContextSetting) or hardware acceleration on machines where it isn't needed. This is a workaround, not a substitute for patching.
  5. Monitor for exploitation attempts. Deploy the detections above. Pay particular attention to crash loops followed by anomalous child process activity — the signature of a successful exploit after repeated grooming attempts.
  6. Network-layer compensating controls. Ensure web filtering and DNS security are blocking known-malicious and newly-registered domains; drive-by exploitation requires delivery infrastructure.
  7. Track the advisory. Official source: Chrome Releases Blog — Stable Channel Update for Desktop. Watch for Google adding an "exploited in the wild" notice and for CISA KEV additions, which would trigger federal remediation deadlines under BOD 22-01 (typically a 2-week window for browser CVEs).

Bug details for CVE-2026-19137 and CVE-2026-19149 remain restricted until the update reaches majority deployment — which is itself a signal that Google considers these genuinely dangerous. Don't wait for the PoC writeups; by then, the window has closed.

Related Resources

Security Arsenal Alert Triage Automation AlertMonitor Platform Book a SOC Assessment platform Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.