The U.S. Cybersecurity and Infrastructure Security Agency (CISA) has added CVE-2026-85046 — a high-severity vulnerability in Google's Chromium V8 JavaScript engine with a CVSS score of 8.8 — to its Known Exploited Vulnerabilities (KEV) catalog. KEV inclusion is not an academic exercise: CISA only adds vulnerabilities when there is confirmed, in-the-wild exploitation. That means threat actors are already weaponizing this bug against real targets, and any unpatched Chromium-based browser in your environment is a live attack surface.
This week, Google shipped a Chrome stable-channel security update addressing 12 vulnerabilities, with CVE-2026-85046 standing out as the one under confirmed attack. Under CISA Binding Operational Directive (BOD) 22-01, Federal Civilian Executive Branch agencies are mandated to remediate KEV-listed vulnerabilities within defined timelines — but the practical reality is that this affects far more than federal networks. Every enterprise running Chrome, Microsoft Edge, Brave, Opera, Vivaldi, or embedded Chromium (Electron applications, WebView2 components) needs to treat this as an emergency patching event.
Browser-based exploitation remains one of the most reliable initial-access vectors we see in IR engagements. A single drive-by compromise of an endpoint with a privileged user can cascade into domain-wide compromise within hours. Treat this accordingly.
Technical Analysis
Affected Component: The V8 JavaScript Engine
V8 is the open-source JavaScript and WebAssembly engine at the heart of Chromium. It executes every piece of JavaScript your users encounter — which makes it a premier target for exploit developers. V8 vulnerabilities are particularly dangerous because:
- Attack surface is unavoidable. Every web page, every advertisement network, every compromised legitimate site becomes a potential delivery vehicle. No user interaction beyond visiting a page is required.
- Type confusion and memory corruption bugs in V8 (the classic pattern for high-severity V8 CVEs) allow attackers to manipulate JavaScript object types at runtime, leading to arbitrary read/write primitives within the renderer process — the foundation for remote code execution.
- Renderer compromise is often chained with a sandbox escape to achieve full system-level code execution. Modern exploit kits chain a V8 RCE with a separate sandbox-escape or kernel bug to break out of Chrome's sandbox.
Vulnerability Profile
| Attribute | Detail |
|---|---|
| CVE | CVE-2026-85046 |
| CVSS 3.x Score | 8.8 (High) |
| Affected Component | Google Chromium V8 JavaScript engine |
| Exploitation Status | Actively exploited in the wild — confirmed via CISA KEV listing |
| Attack Vector | Remote, via malicious or compromised web content (drive-by) |
| User Interaction | Victim must render attacker-controlled JavaScript (visiting a page) |
| Impact | Remote code execution within renderer context; potentially chained to full system compromise |
A CVSS of 8.8 typically maps to a network vector with no privileges required, user interaction required, and high confidentiality/integrity/availability impact — consistent with a browser drive-by RCE scenario.
Affected Products and Platforms
CVE-2026-85046 lives in the shared Chromium codebase, so exposure extends well beyond Google Chrome:
- Google Chrome — Windows, macOS, and Linux stable channels prior to this week's security update
- Microsoft Edge — Chromium-based (Edge typically ingests Chromium security fixes within days of upstream release; verify your Edge build against Microsoft's Security Update Guide)
- Other Chromium-based browsers — Brave, Opera, Vivaldi, Arc
- Embedded Chromium — Electron-based desktop applications (Teams, Slack, Discord, VS Code), Chromium Embedded Framework (CEF) integrations, and Android System WebView / Windows WebView2 runtimes
This last category is chronically under-patched. Your vulnerability scanner will flag Chrome, but it will almost certainly miss the Electron apps and WebView2 runtimes that share the same vulnerable engine. Enumerate them explicitly.
How Exploitation Works (Defender's Perspective)
Based on the standard kill chain for V8 memory-corruption exploitation:
- Delivery: Victim browses to an attacker-controlled site, a compromised legitimate site (watering hole), or a page serving malicious JavaScript via malvertising or injected third-party scripts.
- Trigger: Malicious JavaScript executes in the V8 engine, triggering the memory corruption condition and establishing read/write primitives inside the renderer process.
- Code execution: Shellcode or JIT-sprayed payloads execute within the sandboxed renderer (
chrome.exewith--type=renderer). - Sandbox escape (in sophisticated campaigns): A second vulnerability or misconfiguration is used to escape the Chrome sandbox, yielding code execution as the logged-in user.
- Post-exploitation: The attacker drops a loader, establishes persistence, and begins credential theft and lateral movement. In observed browser-exploit campaigns historically, this phase involves the browser process spawning unexpected child processes —
cmd.exe,powershell.exe, script interpreters, or unsigned binaries dropped to user-writable directories like%TEMP%,%APPDATA%, orC:\ProgramData.
That last stage is where defenders have their best telemetry opportunity. The exploit itself executes inside a legitimate, signed browser process — but post-exploitation activity is loud if you're looking.
Exploitation Status
Confirmed active exploitation. CISA KEV inclusion requires evidence of real-world abuse. Treat this as a zero-day under active weaponization. There is no "wait for the next patch cycle" option.
Detection & Response
The detection strategy here focuses on two layers: (1) identifying unpatched and potentially compromised browser instances, and (2) detecting post-exploitation behavior — browser processes spawning anomalous child processes or establishing unusual network connections. These are high-fidelity signals that veteran SOC teams already use against drive-by browser exploitation.
Sigma Rules
---
title: Chromium Browser Spawning Suspicious Child Process - Potential CVE-2026-85046 Post-Exploitation
id: 8f2e4b61-7c3d-4a9e-b5f1-2d8c6e4a9b3f
status: experimental
description: Detects Chrome, Edge, or other Chromium-based browsers spawning command shells, script interpreters, or LOLBins — a strong indicator of successful browser exploitation leading to sandbox escape and code execution, consistent with post-exploitation following CVE-2026-85046 V8 compromise.
references:
- https://www.cisa.gov/known-exploited-vulnerabilities-catalog
- https://attack.mitre.org/techniques/T1203/
author: Security Arsenal
date: 2026/04/06
tags:
- attack.execution
- attack.t1203
- attack.t1059
logsource:
category: process_creation
product: windows
detection:
selection_parent:
ParentImage|endswith:
- '\chrome.exe'
- '\msedge.exe'
- '\brave.exe'
- '\opera.exe'
- '\vivaldi.exe'
selection_child:
Image|endswith:
- '\cmd.exe'
- '\powershell.exe'
- '\pwsh.exe'
- '\wscript.exe'
- '\cscript.exe'
- '\mshta.exe'
- '\rundll32.exe'
- '\regsvr32.exe'
- '\wmic.exe'
- '\certutil.exe'
- '\bitsadmin.exe'
condition: selection_parent and selection_child
falsepositives:
- Rare legitimate browser extensions or enterprise tooling invoking scripts
- Software deployment tools wrapped in browser download handlers
level: high
---
title: Executable Dropped by Chromium Browser Process Outside Standard Download Flow
id: 3c7a9f25-1e8b-4d62-c4a7-9f3b5d1e8a26
status: experimental
description: Detects a Chromium-based browser process writing executable or script files to suspicious user-writable locations such as Temp, AppData, or ProgramData — consistent with payload staging after a V8 renderer compromise such as CVE-2026-85046.
references:
- https://www.cisa.gov/known-exploited-vulnerabilities-catalog
- https://attack.mitre.org/techniques/T1203/
author: Security Arsenal
date: 2026/04/06
tags:
- attack.execution
- attack.t1203
- attack.t1105
logsource:
category: file_event
product: windows
detection:
selection_source:
Image|endswith:
- '\chrome.exe'
- '\msedge.exe'
- '\brave.exe'
- '\opera.exe'
- '\vivaldi.exe'
selection_path:
TargetFilename|contains:
- '\AppData\Local\Temp\'
- '\AppData\Roaming\'
- '\ProgramData\'
- '\Users\Public\'
selection_ext:
TargetFilename|endswith:
- '.exe'
- '.dll'
- '.ps1'
- '.bat'
- '.vbs'
- '.js'
- '.hta'
filter_downloads:
TargetFilename|contains:
- '\Downloads\'
condition: selection_source and selection_path and selection_ext and not filter_downloads
falsepositives:
- Browser self-update mechanisms writing to AppData (verify against Google Update / Edge Update process trees)
- Legitimate extension installations
level: medium
---
title: Chromium Renderer Process Establishing Unusual Network Connection
id: 5b1d8e74-2a6c-4f39-d8e2-7c4a1b9f5e38
status: experimental
description: Detects Chromium renderer or utility processes making outbound network connections to rare external hosts. A renderer compromise via CVE-2026-85046 may be followed by C2 communication directly from the compromised browser process before a full payload is staged.
references:
- https://www.cisa.gov/known-exploited-vulnerabilities-catalog
- https://attack.mitre.org/techniques/T1071/
author: Security Arsenal
date: 2026/04/06
tags:
- attack.command_and_control
- attack.t1071.001
logsource:
category: network_connection
product: windows
detection:
selection_image:
Image|endswith:
- '\chrome.exe'
- '\msedge.exe'
selection_renderer:
CommandLine|contains:
- '--type=renderer'
- '--type=utility'
filter_common:
DestinationHostname|contains:
- '.google.com'
- '.gstatic.com'
- '.googleapis.com'
- '.googlevideo.com'
- '.microsoft.com'
- '.windows.net'
- '.akamaized.net'
- '.cloudflare.com'
condition: selection_image and selection_renderer and not filter_common
falsepositives:
- Renderer processes legitimately load third-party content from diverse domains — tune with a frequency baseline; alert on connections to newly observed or low-prevalence destinations only
level: low
KQL — Microsoft Sentinel / Defender
The following hunt queries identify (a) post-exploitation process behavior from Chromium browsers and (b) fleet-wide exposure by enumerating browser versions for patch verification.
// Hunt 1: Chromium browsers spawning suspicious child processes (post-exploitation behavior)
DeviceProcessEvents
| where InitiatingProcessFileName in~ ("chrome.exe", "msedge.exe", "brave.exe", "opera.exe", "vivaldi.exe")
| where FileName in~ ("cmd.exe", "powershell.exe", "pwsh.exe", "wscript.exe", "cscript.exe",
"mshta.exe", "rundll32.exe", "regsvr32.exe", "wmic.exe", "certutil.exe", "bitsadmin.exe")
| project TimeGenerated, DeviceName, AccountName, InitiatingProcessFileName,
InitiatingProcessCommandLine, FileName, ProcessCommandLine, SHA256
| order by TimeGenerated desc
// Hunt 2: Browser processes writing executables/scripts to suspicious staging paths
DeviceFileEvents
| where InitiatingProcessFileName in~ ("chrome.exe", "msedge.exe", "brave.exe", "opera.exe", "vivaldi.exe")
| where FolderPath has_any ("\\AppData\\Local\\Temp\\", "\\AppData\\Roaming\\", "\\ProgramData\\", "\\Users\\Public\\")
| where FolderPath !has "\\Downloads\\"
| where FileName endswith_any (".exe", ".dll", ".ps1", ".bat", ".vbs", ".js", ".hta")
| project TimeGenerated, DeviceName, InitiatingProcessFileName, FolderPath, FileName, SHA256
| order by TimeGenerated desc
// Hunt 3: Fleet exposure — enumerate installed Chrome versions to identify unpatched endpoints
// Compare detected versions against the fixed build in Google's stable channel advisory
DeviceTvmSoftwareInventory
| where SoftwareName has_any ("google chrome", "microsoft edge")
| summarize Devices = dcount(DeviceId), DeviceList = make_set(DeviceName, 50) by SoftwareName, SoftwareVersion
| order by SoftwareName asc, SoftwareVersion asc
Velociraptor VQL
For DFIR teams running Velociraptor, the following artifact hunts for post-exploitation process execution spawned by browser processes across the fleet — useful both for proactive hunting and for scoping a suspected compromise.
-- Hunt: Chromium browser processes spawning suspicious child processes
-- Indicator of post-exploitation following V8 renderer compromise (CVE-2026-85046)
SELECT Pid,
Ppid,
Name,
Exe,
CommandLine,
Username,
CreateTime,
get_item(field=pslist(pid=Ppid), member='Exe') AS ParentExe,
get_item(field=pslist(pid=Ppid), member='CommandLine') AS ParentCommandLine
FROM pslist()
WHERE (Exe =~ '(?i)\\\\(cmd|powershell|pwsh|wscript|cscript|mshta|rundll32|regsvr32|wmic|certutil|bitsadmin)\.exe$')
AND ParentExe =~ '(?i)\\\\(chrome|msedge|brave|opera|vivaldi)\.exe$'
Remediation Script — Fleet-Wide Chrome Version Verification and Enforcement
The following PowerShell script inventories Chrome and Edge versions across endpoints, compares them against a minimum patched baseline you define from the vendor advisory, and optionally forces an update check. Run it via your RMM, GPO startup script, or Intune remediation.
# CVE-2026-85046 — Chromium V8 Patch Verification & Enforcement
# Run as SYSTEM/admin via RMM, Intune, or GPO.
# IMPORTANT: Set $MinChromeVersion to the FIXED build from Google's stable channel advisory.
$MinChromeVersion = [version]"0.0.0.0" # <-- Replace with the fixed version from https://chromereleases.googleblog.com/
$MinEdgeVersion = [version]"0.0.0.0" # <-- Replace with the fixed Edge build from Microsoft's Security Update Guide
function Get-BrowserVersion {
param([string]$Path)
if (Test-Path $Path) { return (Get-Item $Path).VersionInfo.ProductVersion }
return $null
}
$chromePaths = @(
"$env:ProgramFiles\Google\Chrome\Application\chrome.exe",
"${env:ProgramFiles(x86)}\Google\Chrome\Application\chrome.exe",
"$env:LOCALAPPDATA\Google\Chrome\Application\chrome.exe"
)
$edgePaths = @(
"${env:ProgramFiles(x86)}\Microsoft\Edge\Application\msedge.exe",
"$env:ProgramFiles\Microsoft\Edge\Application\msedge.exe"
)
$results = @()
foreach ($p in $chromePaths) {
$v = Get-BrowserVersion -Path $p
if ($v) { $results += [pscustomobject]@{ Browser = 'Chrome'; Path = $p; Version = [version]$v } }
}
foreach ($p in $edgePaths) {
$v = Get-BrowserVersion -Path $p
if ($v) { $results += [pscustomobject]@{ Browser = 'Edge'; Path = $p; Version = [version]$v } }
}
$nonCompliant = $false
foreach ($r in $results) {
$min = if ($r.Browser -eq 'Chrome') { $MinChromeVersion } else { $MinEdgeVersion }
if ($r.Version -lt $min) {
Write-Output "[NON-COMPLIANT] $($r.Browser) $($r.Version) at $($r.Path) — below required $min"
$nonCompliant = $true
} else {
Write-Output "[COMPLIANT] $($r.Browser) $($r.Version)"
}
}
if ($nonCompliant) {
# Trigger Google Update and Edge update tasks to accelerate patching
Get-ScheduledTask | Where-Object { $_.TaskName -match 'GoogleUpdate|MicrosoftEdgeUpdate' } |
ForEach-Object { Start-ScheduledTask -TaskName $_.TaskName -ErrorAction SilentlyContinue }
Write-Output "[ACTION] Update tasks triggered. Re-run this script after update cycle completes."
exit 1
} else {
Write-Output "[PASS] All detected Chromium browsers meet the patched baseline for CVE-2026-85046."
exit 0
}
# Additionally: audit WebView2 and Electron exposure — these embed the same V8 engine
Get-ChildItem "$env:ProgramFiles","${env:ProgramFiles(x86)}","$env:LOCALAPPDATA" -Recurse -Filter "msedgewebview2.exe" -ErrorAction SilentlyContinue -Depth 4 |
ForEach-Object { Write-Output "[WEBVIEW2] $($_.FullName) — Version: $($_.VersionInfo.ProductVersion)" }
Remediation
Given confirmed active exploitation, this is an emergency change, not a standard patch-Tuesday item.
Immediate Actions (24–48 Hours)
- Update Google Chrome fleet-wide. Deploy this week's stable-channel security update that resolves the 12 disclosed vulnerabilities including CVE-2026-85046. Verify the exact fixed build number against the official Google Chrome Releases blog (https://chromereleases.googleblog.com/) and enforce it as your minimum baseline using the script above. Do not rely on users restarting their browsers — force restart or deploy via enterprise software distribution (SCCM/MECM, Intune, Jamf, or your RMM).
- Patch all Chromium-based browsers. Microsoft Edge, Brave, Opera, and Vivaldi all inherit the same V8 engine. Track Microsoft's ingestion of the Chromium fix via the Microsoft Security Update Guide and push Edge updates concurrently.
- Enumerate and patch embedded Chromium. Identify Electron applications, CEF integrations, and WebView2 runtimes in your environment. WebView2 auto-updates via the Evergreen model — verify it's current. For Electron apps, pressure vendors for updated builds; a vulnerable Slack or Teams client is the same exploit surface.
- Meet CISA KEV deadlines. Federal agencies are bound by BOD 22-01 remediation timelines from the KEV listing date (https://www.cisa.gov/known-exploited-vulnerabilities-catalog). Private-sector organizations should adopt the same deadline as internal policy — KEV-listed browser bugs are routinely weaponized at scale within days.
Hardening and Compensating Controls
- Enforce Chrome enterprise policies: Enable
SiteIsolation(on by default — verify it hasn't been disabled), restrict JavaScript on untrusted sites viaDefaultJavaScriptSettingfor high-risk user groups, and block outdated plugin execution. - Browser isolation for high-risk users: Route browsing for executives, finance, and privileged admins through remote browser isolation (RBI) or secured virtualized browsing until patch compliance is confirmed.
- Web filtering: Enforce DNS-layer and proxy-layer filtering of newly registered domains and known malvertising infrastructure — the primary delivery vectors for drive-by V8 exploitation.
- EDR coverage: Confirm your EDR sensors capture browser process trees with command-line arguments. The detection rules above are only as good as your telemetry.
- Hunt retroactively. Exploitation predates the KEV listing. Run the KQL hunts above over the past 30 days minimum. A browser spawning
powershell.exethree weeks ago is not a patching problem — it's an incident.
Verification
Patching is not complete until verified. Establish reporting on browser version distribution across the fleet (Hunt 3 in the KQL section), set a compliance gate (100% of endpoints at or above the fixed build within 72 hours), and escalate stragglers — unmanaged and BYOD devices with access to corporate SaaS are the usual tail-end risk.
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.