Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.
Sources: National Vulnerability Database, CISA KEV, Exploit-DB
CVE-2026-113798 Overview
CVE-2026-113798 is an origin confusion vulnerability in the Electron framework for building cross-platform desktop applications with JavaScript, HTML, and CSS. When a cross-origin iframe requested the pointerLock permission, the handler registered via session.setPermissionRequestHandler() received the top-level frame's requestingUrl and isMainFrame values rather than those of the actual requesting frame. Applications that embed untrusted iframe content and grant pointer lock based on the requesting origin may therefore grant the permission under the top-level page's identity. The flaw is tracked as CWE-346: Origin Validation Error.
Critical Impact
Untrusted embedded content can obtain pointerLock under the trusted top-level origin's identity, enabling UI redress and input hijacking in Electron apps that embed third-party iframes.
Affected Products
- Electron versions prior to 42.11.9 on the 42.x branch
- Electron versions prior to 43.7.6 on the 43.x branch and prior to 44.5.0 on the 44.x branch
- Electron 45.0.0 pre-release versions prior to 45.0.0-alpha.13
Discovery Timeline
- 2026-10-21 - CVE-2026-113798 published to NVD
- 2026-10-22 - CVE-2026-113798 last updated in NVD database
Technical Details for CVE-2026-113798
Vulnerability Analysis
Electron exposes session.setPermissionRequestHandler() so applications can decide whether to grant privileged capabilities such as pointer lock. The handler receives metadata including the requestingUrl and an isMainFrame flag that applications use to differentiate trusted top-level content from embedded iframes. For pointerLock requests originating in some cross-origin iframes, Electron supplied the top-level frame's values instead of the requesting frame's values. An application that allowlists its own origin for pointer lock will see a trusted-looking requestingUrl even when the request actually originated from an embedded, untrusted iframe. Pointer lock capture allows the embedding attacker-controlled content to monopolize cursor input, which combined with full-screen or overlay tricks can be used for clickjacking, keystroke misdirection, or user-interface spoofing within the desktop app.
Root Cause
The browser-side permission plumbing in shell/browser/web_contents_permission_helper.cc resolved the requesting frame incorrectly for in-process iframes, so the permission request was attributed to the top-level RenderFrameHost rather than the child frame actually calling requestPointerLock(). The upstream fix is titled fix_plumb_the_requesting_frame_through_pointer_lock_requests.patch and threads the real requesting frame through the pointer lock request path.
Attack Vector
Exploitation requires an Electron application that (1) embeds third-party or user-controlled web content inside an iframe and (2) grants pointerLock based on requestingUrl or isMainFrame in its permission handler. The embedded content calls element.requestPointerLock(), triggering the misattributed permission request. Applications that deny pointerLock for untrusted embedded content are not affected. User interaction is required to engage with the iframe content.
// Upstream patch reference (chromium patches manifest)
cherry-pick-0728ae248ac5.patch
fix_don_t_leave_gdk_backend_set_in_the_environment_after_gtk_init.patch
+fix_plumb_the_requesting_frame_through_pointer_lock_requests.patch
// shell/browser/web_contents_permission_helper.cc
#include "content/public/browser/permission_descriptor_util.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/render_process_host.h"
-#include "content/public/browser/render_widget_host.h"
#include "content/public/browser/web_contents_user_data.h"
Source: Electron commit 076c7496
Detect Identity Attacks the Moment Authentication Fails
Singularity™ Identity surfaces credential misuse, lateral movement, and privilege escalation in real time, so you can contain the breach before it spreads.
Stop Identity AttacksDetection Methods for CVE-2026-113798
Indicators of Compromise
- Electron application binaries bundling Electron runtime versions below 42.11.9, 43.7.6, or 44.5.0.
- Application code that calls session.setPermissionRequestHandler() and conditionally grants pointerLock based on details.requestingUrl or details.isMainFrame.
- Renderer telemetry showing requestPointerLock() invocations originating from cross-origin iframe contexts followed by granted pointer capture.
Detection Strategies
- Inventory installed Electron applications and extract the embedded Electron version from each application's resources to identify builds predating the fixed releases.
- Audit application source for permission handlers that treat pointerLock as a frame-origin-sensitive decision and verify they also check embeddingOrigin or frame ancestry.
- Review iframe sandbox and allow attribute policies in bundled renderer HTML to flag embeds that permit pointer lock from untrusted origins.
Monitoring Recommendations
- Monitor endpoint software inventory for outdated Electron-based desktop applications and alert on versions below the patched releases.
- Log and review developer-tool and renderer process events in managed Electron apps for repeated pointer-lock permission prompts from embedded content.
- Track vendor advisories for downstream applications (chat clients, IDEs, collaboration tools) that embed Electron and republish patched builds.
How to Mitigate CVE-2026-113798
Immediate Actions Required
- Upgrade Electron to 42.11.9, 43.7.6, 44.5.0, or 45.0.0-alpha.13 and rebuild and redistribute affected desktop applications.
- In application permission handlers, deny pointerLock by default for any content that is not strictly first-party, independent of the reported requestingUrl.
- Review and harden iframe embedding policies so untrusted content cannot request pointer lock through allow="pointer-lock" or equivalent permissions-policy declarations.
Patch Information
The Electron maintainers shipped fixes in Electron v42.11.9, v43.7.6, v44.5.0, and v45.0.0-alpha.13. The coordinated advisory is published as GHSA-x562-297c-g43g, with implementation details in PR #54432 and backports #54463, #54464, #54465, and #54466.
Workarounds
- Explicitly reject pointerLock permission requests inside session.setPermissionRequestHandler() until the Electron runtime is upgraded.
- Restrict iframe usage in renderer content; apply the sandbox attribute without allow-pointer-lock and omit pointer-lock from any Permissions-Policy header.
- Isolate untrusted web content in a separate BrowserWindow or webContents instance with its own session that denies all sensitive permissions.
# Example: deny pointerLock in Electron permission handler
const { session } = require('electron')
session.defaultSession.setPermissionRequestHandler((webContents, permission, callback, details) => {
if (permission === 'pointerLock') {
// Deny pointerLock for embedded or untrusted content
if (!details.isMainFrame || details.requestingUrl !== 'https://app.example.com/') {
return callback(false)
}
}
callback(true)
})
Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.
Sources: National Vulnerability Database, CISA KEV, Exploit-DB

