Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDeliver malicious page with sandboxed iframe to Electron app
-
DeliverySandboxed iframe navigates to external protocol URL (e.g., magnet:)
-
ExploitElectron skips sandbox flag enforcement in HandleExternalProtocolInUI
-
ExecutionPermission handler invoked without sandbox context, grants openExternal by default
-
ImpactOS launches registered external protocol handler with attacker-controlled URI
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Access control enforcement
MITRE ATT&CK
1 technique across 1 tactic: Defense Evasion The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires two simultaneous conditions in the target Electron application: first, the application must render untrusted or attacker-influenced web content inside an HTML iframe element that carries sandbox restrictions (i.e., a sandboxed iframe); second, the application must not have installed a setPermissionRequestHandler, OR the installed handler must grant the openExternal permission for untrusted content - the default Electron behavior when no handler is configured grants this permission automatically. Apps that explicitly deny openExternal for untrusted sources in their permission handler are not exploitable. Additionally, the sandboxed iframe must not include the allow-top-navigation-to-custom-protocols, allow-top-navigation-by-user-activation (combined with user gesture), allow-top-navigation, or allow-popups tokens, because those tokens legitimately permit the navigation. What limits exploitation: the combination of sandbox-aware rendering plus absent permission hardening is a specific-but-default configuration; apps serving only trusted first-party content in iframes or apps with strict permission handlers are not at risk. |
| Impact | The NVD-assigned CVSS 3.1 score of 5.4 (Medium) with vector AV:N/AC:H/PR:N/UI:N/S:C reflects a realistic assessment. The Changed Scope (S:C) is significant: the vulnerability crosses process and OS boundaries to invoke an external application outside Electron's control, which could be leveraged to exploit vulnerabilities in the launched application or expose UX-level phishing surfaces (e.g., opening a mailto: handler to pre-fill a phishing email). The AC:H rating is justified because the attack requires two concurrent conditions: the Electron app must be rendering untrusted content inside sandboxed iframes AND must be running with the default openExternal permission (no setPermissionRequestHandler installed or handler that grants the permission). These are specific but not uncommon deployment patterns in Electron apps that act as web content browsers. No EPSS data was provided in the input, and the vulnerability is not listed in CISA KEV, so real-world exploitation probability cannot be quantified beyond what the CVSS signals indicate. There is no conflicting data between the CVSS vector and the description; both consistently indicate a network-delivered, unauthenticated attack against a specific configuration. The absence of a public POC and KEV listing reduces urgency somewhat, but Electron's broad deployment surface and the default-vulnerable configuration elevate practical priority for affected app developers. |
| Exploit ScenarioDerived | An attacker hosts a malicious web page containing an iframe with only the allow-scripts sandbox token, embedding a child page that immediately navigates to a custom protocol URL such as magnet:// or a proprietary scheme. When an Electron application without a setPermissionRequestHandler loads this page, the iframe's navigation to the external protocol bypasses sandbox enforcement, prompting the OS to launch the registered handler - for example, a BitTorrent client, an email client with pre-filled fields, or a custom enterprise application - potentially exposing that application to attacker-controlled input. No public exploit code has been identified at time of analysis, but the attack logic is straightforward and closely mirrors the test cases included in the vendor patch. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 05, 2026
External protocol handler bypass in Electron allows sandboxed iframes to launch OS-registered external applications, circumventing iframe sandbox enforcement in all Electron versions below 39.8.8, 40.9.0, 41.2.1, and 42.0.0-beta.3. The root cause is that Electron's HandleExternalProtocolInUI function in electron_browser_client.cc failed to inspect WebSandboxFlags before processing external protocol navigation requests, and critically did not forward the frame's sandbox state to the app's permission handler - so even a custom handler could not make an informed allow/deny decision. No active exploitation is confirmed (not in CISA KEV) and no public exploit code has been identified at time of analysis, but the attack is network-deliverable with no authentication required against apps relying on Electron's default permission configuration.
RemediationAI
The primary fix is to upgrade Electron to one of the patched releases: 39.8.8, 40.9.0, 41.2.1, or 42.0.0-beta.3, available at the respective GitHub release pages (https://github.com/electron/electron/releases/tag/v39.8.8, v40.9.0, v41.2.1, v42.0.0-beta.3). The patch backports Chromium's sandbox flag enforcement into HandleExternalProtocolInUI and ensures sandbox state is forwarded to permission handlers. For applications that cannot immediately upgrade, the documented workaround is to install a setPermissionRequestHandler that explicitly denies the openExternal permission for untrusted content - this is effective because it closes the permission gate regardless of whether sandbox flags are checked. The trade-off of the workaround is that legitimate openExternal navigations from untrusted iframes will also be blocked, which is the desired security posture. Applications that already have a permission handler denying openExternal for untrusted content are confirmed not affected by this vulnerability.
Affected VersionsENISA
Affected Packages
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 (pkg:npm/electron) is a cross-platform desktop application framework that embeds Chromium and Node.js. The vulnerability resides in shell/browser/electron_browser_client.cc within the HandleExternalProtocolInUI function, which is invoked when web content attempts to navigate to a URL using a non-web protocol (e.g., magnet:, mailto:, custom:). The fix mirrors logic already present in Chromium (crbug.com/1148777): before allowing an external protocol launch from a sub-frame, the implementation must check network::mojom::WebSandboxFlags against the frame's active sandbox tokens. Prior to the fix, the sandbox_flags parameter was not passed to HandleExternalProtocolInUI at all, so the function treated sandboxed iframes identically to top-level frames. CWE-284 (Improper Access Control) accurately characterizes the root cause: an access control boundary - the HTML iframe sandbox - was not enforced on a specific code path. The sandbox tokens relevant to this check are allow-top-navigation-to-custom-protocols, allow-top-navigation-by-user-activation (with user gesture), allow-top-navigation, and allow-popups.
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
AV:N/AC:H/PR:N/UI:N/S:C/C:L/I:L/A:N
Network-delivered, no auth required against default config; AC:H for dual prerequisite (sandboxed iframe + absent permission handler); S:C for OS-level handler launch crossing scope boundary; no availability impact.
Primary rating from Vendor (https://github.com/electron/electron).
CVSS VectorVendor: https://github.com/electron/electron
DescriptionCVE.org
Impact
Requests to open external protocol URLs from web content did not take iframe sandbox restrictions into account, so a sandboxed iframe could cause an OS-registered external application to be launched. The frame's sandbox state was also not made available to the app's permission handlers.
Apps are only affected if they render untrusted content in sandboxed iframes and grant the openExternal permission (granted by default when no setPermissionRequestHandler is installed). Apps whose permission handler denies openExternal for untrusted content are not affected.
Workarounds
Install a setPermissionRequestHandler that denies the openExternal permission for untrusted content.
Fixed Versions
42.0.0-beta.341.2.140.9.039.8.8
For more information
If you have any questions or comments about this advisory, email Electron at [security@electronjs.org](mailto:security@electronjs.org)
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
EUVD-2026-53546
GHSA-p2rr-rvmm-c5fp
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB