Apple
CVE-2026-34776
MEDIUM
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
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 5.3 with vector CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:N/A:L indicates local attack vector requiring low privileges and high complexity, with high confidentiality impact but no integrity impact and low availability impact. The exploitation requires the attacker to run code as the same user as the Electron app, significantly limiting real-world attack surface compared to remote vulnerabilities. EPSS probability and KEV status are not provided in the input, so we cannot assess active exploitation; however, the lack of any public exploit code, combined with the prerequisite that applications must explicitly call requestSingleInstanceLock() and the local same-user requirement, suggests this is a moderate-priority vulnerability with limited real-world exploitability. The high-complexity attack vector (AC:H) further reduces immediate threat, though applications handling sensitive data in memory should prioritize patching. This is a real security concern but not a critical priority for most users due to privilege and complexity requirements. |
| Exploit ScenarioDerived | A local attacker with user-level access on a macOS or Linux system running an Electron application that calls requestSingleInstanceLock() crafts a second-instance message with malformed data designed to read beyond heap boundaries. When the running Electron app receives this message, the out-of-bounds read exposes sensitive data from adjacent heap memory (such as cryptographic keys, session tokens, or user data) which is delivered to the application's second-instance event handler, where the attacker can retrieve it if they control the delivery mechanism. This attack requires the attacker to operate in the same user context and construct a non-trivial malformed message, placing it in the category of low-probability but high-impact local vulnerabilities; no public proof-of-concept is currently known. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Apr 03, 2026
Out-of-bounds heap read in Electron's single-instance lock mechanism on macOS and Linux allows local attackers with same-user privileges to leak sensitive application memory through crafted second-instance messages. Affected Electron versions prior to 41.0.0, 40.8.1, 39.8.1, and 38.8.6 are vulnerable only if applications explicitly call app.requestSingleInstanceLock(); no public exploit code is currently identified, but the CVSS 5.3 score reflects moderate confidentiality impact combined with local attack complexity requirements.
RemediationAI
Electron developers must upgrade to patched versions immediately: version 41.0.0 or later, version 40.8.1 or later (for 40.x branch), version 39.8.1 or later (for 39.x branch), or version 38.8.6 or later (for 38.x branch). No application-side workarounds are available; patching Electron is the only remediation path. Update the Electron dependency in package.json to the minimum patched version matching your current major version branch, then rebuild and redistribute the application. Consult https://github.com/advisories/GHSA-3c8v-cfp5-9885 for detailed advisory information.
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
Electron is a framework for building cross-platform desktop applications using web technologies (Chromium and Node.js). The vulnerability exists in Electron's single-instance lock feature, which ensures only one instance of an application runs at a time by using inter-process communication to relay arguments to an already-running process via the 'second-instance' event handler. The out-of-bounds read (CWE-125: Out-of-bounds Read) occurs during parsing of second-instance messages on macOS and Linux, where insufficient bounds checking allows reading beyond allocated heap memory. The vulnerability is triggered when a local attacker (same user context) sends a specially crafted second-instance message, bypassing the normal argument validation. This is a heap-based information disclosure vulnerability specific to NPM package 'electron' across multiple major versions (38.x, 39.x, 40.x, 41.x).
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:N/S:U/C:L/I:N/A:N
Primary rating from NVD.
CVSS VectorNVD
Lifecycle Timeline
2DescriptionNVD
Impact
On macOS and Linux, apps that call app.requestSingleInstanceLock() were vulnerable to an out-of-bounds heap read when parsing a crafted second-instance message. Leaked memory could be delivered to the app's second-instance event handler.
This issue is limited to processes running as the same user as the Electron app.
Apps that do not call app.requestSingleInstanceLock() are not affected. Windows is not affected by this issue.
Workarounds
There are no app side workarounds, developers must update to a patched version of Electron.
Fixed Versions
41.0.040.8.139.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)
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.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
GHSA-3c8v-cfp5-9885
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB