Apple
CVE-2026-34770
HIGH
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessTrigger garbage collection of PowerMonitor object
-
DeliveryOS resources retain dangling references
-
ExploitSystem session change event occurs
-
ExecutionDereference freed memory
-
ImpactCrash or memory corruption
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory lifecycle management
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires Electron application using the |
| Impact | Real-world risk is MODERATE despite the 7.0 CVSS score. The CVSS vector (AV:L/AC:H/PR:N/UI:R) indicates several mitigating factors: local access is required, attack complexity is high, and user interaction is necessary. No public exploit identified at time of analysis and no CISA KEV listing indicates this is not being actively exploited. The high attack complexity stems from needing to trigger garbage collection of the PowerMonitor object while simultaneously inducing specific OS power events-a difficult timing window to control reliably. The requirement for user interaction (system shutdown, sleep, or session change) further reduces exploitability. However, the potential impact is significant (C:H/I:H/A:H) as successful exploitation could enable memory corruption leading to code execution with the application's privileges. Priority should be MEDIUM for most organizations: the vulnerability affects a widely-deployed framework (Electron powers major applications like VS Code, Slack, Discord), patches are readily available across multiple version branches, and the fix requires only an Electron version upgrade. Organizations running Electron applications in high-security environments or multi-user systems should prioritize patching, while those with standard desktop deployments can remediate during normal maintenance windows. The issue is not renderer-controllable, meaning web content cannot directly trigger the vulnerability, which significantly reduces the attack surface compared to typical Electron security issues. |
| Exploit ScenarioDerived | A local attacker with access to a system running a vulnerable Electron application could potentially exploit this vulnerability by first triggering JavaScript garbage collection of the powerMonitor object through memory pressure or application state manipulation, then inducing a system power event. On Windows, this could involve forcing a session change (lock/unlock, user switching) while on macOS, initiating a system shutdown or sleep cycle. If timing is precise, the OS-level event handler fires after the PowerMonitor object has been freed, dereferencing invalid memory. In a crash scenario, this causes application termination and potential denial of service. In a more sophisticated attack, if the attacker can control heap allocation to place malicious data in the freed memory region, the use-after-free could potentially be leveraged for arbitrary code execution with the application's privileges. Publicly available exploit code exists in the form of technical details in the GitHub advisory, though no weaponized proof-of-concept has been identified. The high attack complexity and requirement for local access with specific timing significantly limit practical exploitation in most deployment scenarios. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Apr 03, 2026
Use-after-free in Electron's powerMonitor module allows local attackers to trigger memory corruption or application crashes through system power events. All Electron applications (versions <38.8.6, <39.8.1, <40.8.0, <41.0.0-beta.8) that subscribe to powerMonitor events (suspend, resume, lock-screen) are vulnerable when garbage collection frees the PowerMonitor object while OS-level event handlers retain dangling pointers. Exploitation requires local access and specific timing conditions (CVSS 7.0 HIGH, AC:H). No public exploit identified at time of analysis, though the technical details are publicly documented in the GitHub security advisory.
RemediationAI
Immediately upgrade to patched Electron versions: 41.0.0-beta.8 or later for the 41.x beta branch, 40.8.0 or later for the 40.x stable branch, 39.8.1 or later for the 39.x branch, or 38.8.6 or later for the 38.x LTS branch. Application developers should update the Electron dependency in package.json and rebuild their applications with the patched framework version. No application-side code changes are required beyond the Electron version upgrade, as the fix addresses the underlying framework issue. No workarounds exist-upgrading is the only remediation path. Organizations should prioritize applications deployed in multi-user environments or those processing sensitive data. For applications still on unsupported Electron versions (below 38.x), migration to a supported branch is strongly recommended. Verify the Electron version in deployed applications using electron.version or by checking node_modules/electron/package.json. Detailed advisory and patch information is available at https://github.com/electron/electron/security/advisories/GHSA-jjp3-mq3x-295m. After upgrading, test application functionality particularly around power management events to ensure compatibility with the patched implementation.
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in npm
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The vulnerability stems from improper lifetime management between Electron's JavaScript powerMonitor API and native OS event handlers. When the JavaScript PowerMonitor object is garbage-collected, the associated platform-specific resources are not properly cleaned up: Windows retains a message window and macOS retains a shutdown handler, both holding dangling pointers to freed memory. This creates a use-after-free condition (CWE-416) where subsequent OS power events-such as session changes on Windows or system shutdown on macOS-trigger callbacks that dereference the freed memory region. The vulnerability exists in the pkg:npm/electron package across multiple major versions. The issue represents a classic object lifetime mismatch between managed JavaScript objects and unmanaged native resources, a common pitfall in frameworks that bridge high-level and low-level code. Memory corruption vulnerabilities of this class can potentially be exploited for arbitrary code execution if an attacker can control the contents of the freed memory region, though the local attack vector and high complexity limit practical exploitation scenarios.
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:L/PR:N/UI:R/S:U/C:H/I:H/A:H
Primary rating from NVD · only source for this CVE.
CVSS VectorNVD
Lifecycle Timeline
3DescriptionNVD
Impact
Apps that use the powerMonitor module may be vulnerable to a use-after-free. After the native PowerMonitor object is garbage-collected, the associated OS-level resources (a message window on Windows, a shutdown handler on macOS) retain dangling references. A subsequent session-change event (Windows) or system shutdown (macOS) dereferences freed memory, which may lead to a crash or memory corruption.
All apps that access powerMonitor events (suspend, resume, lock-screen, etc.) are potentially affected. The issue is not directly renderer-controllable.
Workarounds
There are no app side workarounds, you must update to a patched version of Electron.
Fixed Versions
41.0.0-beta.840.8.039.8.138.8.6
For more information
If there are any questions or comments about this advisory, please email [security@electronjs.org](mailto:security@electronjs.org)
Executive ViewAI
A use-after-free vulnerability in Electron's powerMonitor module affects all versions below 38.8.6, 39.8.1, 40.8.0, and 41.0.0-beta.8, enabling local attackers to corrupt memory or crash applications through system power events. Organizations distributing Electron-based applications must inventory affected versions immediately, as exploitation requires only local system access and could impact application availability and data integrity across deployed instances.
No interim mitigations available for this memory corruption vulnerability. Apply vendor patch to all affected Electron versions immediately upon availability of patched releases. Until patching is complete, restrict local system access to trusted users and disable powerMonitor event subscriptions where operationally feasible.
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
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
Use-after-free vulnerabilities occur when a program continues to access memory through a pointer after that memory has been deallocated.
Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.
GHSA-jjp3-mq3x-295m
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB