Skip to main content

Apple CVE-2026-34770

HIGH
Use After Free (CWE-416)
2026-04-03 https://github.com/electron/electron GHSA-jjp3-mq3x-295m
8.8
CVSS 3.1 · NVD
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Trigger garbage collection of PowerMonitor object
  2. Delivery
    OS resources retain dangling references
  3. Exploit
    System session change event occurs
  4. Execution
    Dereference freed memory
  5. Impact
    Crash 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 powerMonitor module with event listeners (suspend, resume, lock-screen). Exploitation triggered by system session change (Windows) or shutdown (macOS). Requires local user interaction (system event). User must run vulnerable application.

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.

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

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

Alert me

AnalysisAIv1 – 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

npm electron fix: 38.8.6, 39.8.1, 40.8.0, 41.0.0-beta.8

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

NVD PRIMARY 8.8 HIGH
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

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

Lifecycle Timeline

3
CVSS changed
Jul 24, 2026 - 22:23 NVD
7.0 (HIGH) 8.8 (HIGH)
Patch released
Apr 03, 2026 - 08:30 nvd
Patch available
CVE Published
Apr 03, 2026 - 02:39 nvd
HIGH 7.0

DescriptionNVD

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.8
  • 40.8.0
  • 39.8.1
  • 38.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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.0%
Top 97% exploitable
Threat Intel
1
1 source
Data Quality
5 sources
Confidence: Medium
NVD CVE.org EPSS Vulnrichment GHSA 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.0%
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
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact
High
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

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.

Affected Products (CPE)NVD

pkg:npm/electron
pkg:npm/electron
pkg:npm/electron
pkg:npm/electron

Related Vulnerabilities in Electron Multiple Use-After-Free Flaws

View all 4

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