Skip to main content

Microsoft CVE-2026-34765

| EUVDEUVD-2026-19949 HIGH
Exposure of Resource to Wrong Sphere (CWE-668)
2026-04-07 https://github.com/electron/electron GHSA-f3pv-wv63-48x8
8.8
CVSS 3.1 · NVD
View

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Resource sphere isolation
MITRE ATT&CK

1 technique across 1 tactic: Collection

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Impact

CVSS 6.0 (AC:H - attack complexity is high because the attacker must satisfy multiple preconditions) combined with CVSS vector PR:L (authenticated attacker; in Electron context, this means the attacker must control a renderer process, typically via loading untrusted web content) and S:C (scope change - the vulnerability allows escaping normal renderer isolation) yields a moderate-to-high real-world risk for vulnerable applications. However, the actual attack surface is significantly constrained: the vulnerability only affects applications that (1) open multiple top-level windows with different trust levels, (2) use setWindowOpenHandler to grant child windows elevated webPreferences, and (3) load untrusted content in at least one renderer. Applications using a single top-level window, or those that do not elevate child window permissions, are unaffected. The RCE tag is only realized if child windows are granted nodeIntegration:true or sandbox:false (explicitly discouraged by Electron security guidance), suggesting many real-world applications may be partially protected by developers following security best practices. The high CVSS AC:H rating and restrictive impact conditions suggest this is a genuine but not universal priority vulnerability.

Exploit ScenarioDerived

An attacker controls a renderer process in a multi-window Electron application (e.g., by hosting untrusted web content in a content/preview window). The attacker calls window.open() with the same target name as a child window that was previously opened by a different, trusted renderer (e.g., a settings or admin panel). Because the lookup is not scoped to the original opener's context, the attacker's call hijacks and navigates the trusted child window to attacker-controlled content. If that trusted child window was granted elevated webPreferences such as a privileged preload script by setWindowOpenHandler, the attacker's content inherits those permissions and can execute arbitrary code with the privileges of the preload script. No public exploit code is known at time of analysis, but the attack only requires basic JavaScript knowledge and control of a single untrusted renderer.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.1% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Apr 07, 2026

Electron's window.open() handler fails to properly scope named-window lookups to the opener's browsing context group, allowing a renderer to hijack an existing child window opened by a different renderer and potentially inherit elevated webPreferences including privileged preload scripts. This affects Electron versions before 39.8.5, 40.8.5, 41.1.0, and 42.0.0-alpha.5, and poses a remote code execution risk only in applications that open multiple top-level windows with differing trust levels and grant child windows elevated permissions via setWindowOpenHandler. No public exploit identified at time of analysis.

RemediationAI

Immediately upgrade to patched versions: Electron 39.8.5, 40.8.5, 41.1.0, or 42.0.0-alpha.5 or later, selecting the version that matches your current major/minor branch. For applications still on older major versions without patches, apply the following workarounds: (1) Return { action: 'deny' } from setWindowOpenHandler in any renderer that loads untrusted content to completely block window.open() calls; (2) Avoid granting child windows more permissive webPreferences than their opener window; (3) Do not grant nodeIntegration:true or sandbox:false to child windows unless absolutely necessary and the content is fully trusted. See https://github.com/electron/electron/releases/tag/v39.8.5, https://github.com/electron/electron/releases/tag/v40.8.5, https://github.com/electron/electron/releases/tag/v41.1.0, and https://github.com/electron/electron/releases/tag/v42.0.0-alpha.5 for patch details and https://github.com/advisories/GHSA-f3pv-wv63-48x8 for full advisory.

Affected VersionsENISA

electron < 39.8.5
electron 41.0.0-alpha.1, < 41.1.0
electron 40.0.0-alpha.1, < 40.8.5
electron 42.0.0-alpha.1, < 42.0.0-alpha.5

Affected Packages

npm electron fix: 39.8.5, 40.8.5, 41.1.0, 42.0.0-alpha.5
euvd electron_40_0_0_alpha_1 fix: 40.8.5
euvd electron_41_0_0_alpha_1 fix: 41.1.0
euvd electron_42_0_0_alpha_1 fix: 42.0.0-alpha.5

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 4 packages in npm, euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

Electron is a framework for building cross-platform desktop applications using web technologies (HTML, CSS, JavaScript). The vulnerability exists in Electron's renderer process implementation of the window.open() API. The root cause (CWE-668: Operation on Resource in the Wrong Phase of Lifetime) stems from improper scoping of the named-window lookup mechanism. When a renderer invokes window.open() with a target name, Electron should restrict the lookup to windows within that renderer's browsing context group (conceptually similar to browser same-origin policy). Instead, the renderer-side lookup was global across all windows, enabling cross-renderer window hijacking. When a second, untrusted renderer navigates an existing child window created by a trusted renderer, the child inherits the webPreferences (including preload scripts, nodeIntegration settings, sandbox configuration) of its original opener. The affected product is npm package 'electron' across multiple major/minor versions.

Know when the next one hits your stack

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

NVD PRIMARY 8.8 HIGH
AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
Red Hat 7.1 MEDIUM

Primary rating from NVD.

CVSS VectorNVD

Attack Vector
Network
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

4
Severity Changed
Jul 24, 2026 - 22:23 NVD
MEDIUM HIGH
CVSS changed
Jul 24, 2026 - 22:23 NVD
6.0 (MEDIUM) 8.8 (HIGH)
Patch released
Apr 07, 2026 - 20:30 nvd
Patch available
CVE Published
Apr 07, 2026 - 15:52 nvd
MEDIUM 6.0

DescriptionNVD

Impact

When a renderer calls window.open() with a target name, Electron did not correctly scope the named-window lookup to the opener's browsing context group. A renderer could navigate an existing child window that was opened by a different, unrelated renderer if both used the same target name. If that existing child was created with more permissive webPreferences (via setWindowOpenHandler's overrideBrowserWindowOptions), content loaded by the second renderer inherits those permissions.

Apps are only affected if they open multiple top-level windows with differing trust levels and use setWindowOpenHandler to grant child windows elevated webPreferences such as a privileged preload script. Apps that do not elevate child window privileges, or that use a single top-level window, are not affected.

Apps that additionally grant nodeIntegration: true or sandbox: false to child windows (contrary to the security recommendations) may be exposed to arbitrary code execution.

Workarounds

Deny window.open() in renderers that load untrusted content by returning { action: 'deny' } from setWindowOpenHandler. Avoid granting child windows more permissive webPreferences than their opener.

Fixed Versions

  • 42.0.0-alpha.5
  • 41.1.0
  • 40.8.5
  • 39.8.5

For more information

If you have any questions or comments about this advisory, email us at [security@electronjs.org](mailto:security@electronjs.org)

Threat Intelligence Overview

EPSS Score
0.1%
Top 84% exploitable
Threat Intel
1
1 source
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA Vendor GitHub

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact· derived
Medium
Technical Impact
Total

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

Vendor StatusVendor

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy