What is the CVSS score of EUVD-2026-53543?

EUVD-2026-53543 has a CVSS 3.1 base score of 5.4 (Medium). CVSS vector: CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:C/C:L/I:L/A:N. EPSS exploitation probability: 0.4%.

Is there a public PoC exploit available for EUVD-2026-53543?

Yes, a public proof-of-concept exploit is available for EUVD-2026-53543. Prioritise patching immediately. EPSS: 0.4%.

Is there a patch available for EUVD-2026-53543?

Yes, a patch is available for EUVD-2026-53543. Update the affected software to the latest version immediately.

Electron EUVD-2026-53543

| CVE-2026-70610 MEDIUM

Improperly Controlled Modification of Object Prototype Attributes (Prototype Pollution) (CWE-1321)

2026-08-05 GitHub_M

GHSA-ff2p-hmqr-hxm4

Information Disclosure Prototype Pollution Electron

5.4

CVSS 3.1 · Vendor: GitHub_M

View

Attack ChainAIDerived

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

Access

Craft object with enumerable own __proto__ key
Delivery

Send crafted object across contextBridge from renderer
Exploit

Bridge Set() invokes Object.prototype.__proto__ setter in preload context
Execution

Preload-side object prototype mutated to attacker-controlled object
Persist

Preload reads inherited property without own-property check
Impact

Attacker-supplied value used in privileged preload logic

Vulnerability Assessment

Weakness	CWE CWE-1321 ASVS 5.0 V3 - Web Frontend Security Prototype pollution prevention MITRE ATT&CK 2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. Sign in to read
Exploitation Conditions	Two application-level conditions must be simultaneously true. First, the Electron app's preload script must expose a contextBridge API function that accepts a JavaScript object (not a primitive) originating from untrusted renderer content - specifically, the object must be passed by the untrusted page, not constructed by the preload itself. Second, the preload code must read properties from that object using inherited lookup (e.g., `obj.method()` or `obj.prop`) rather than own-property guards (`Object.hasOwn(obj, 'prop')` or `Object.prototype.hasOwnProperty.call(obj, 'prop')`). Apps that enforce a strict allowlist of primitive arguments, that use TypeScript runtime validators, or that shallow-copy received objects onto `Object.create(null)` before any property access are not affected. Exploitation is also constrained by what the specific preload script exposes: an app whose preload only passes a file path string to Node.js cannot be exploited through this vector. Limiting factor: this is a design-pattern vulnerability, not a default-configuration one - the majority of Electron apps built with security guidance are likely unaffected.
Impact	The official CVSS 3.1 vector AV:N/AC:H/PR:N/UI:N/S:C/C:L/I:L/A:N scores 5.4 (Medium), and the AC:H rating accurately reflects the conditional nature of the attack: the preload code must both accept object arguments from untrusted content and read inherited properties without own-property guards. Many production Electron apps will not exhibit both conditions simultaneously. The S:C metric is the most significant signal - it captures the renderer-to-preload boundary crossing, which is architecturally meaningful because preload scripts often hold Node.js IPC channels, file system access, or credential material. No EPSS data was provided, and the vulnerability is absent from CISA KEV, indicating no confirmed mass exploitation. The absence of a public POC further reduces near-term opportunistic risk. The primary risk population is apps with loosely typed preload bridge APIs that proxy untrusted objects directly into privileged code paths. For well-written preload scripts using own-property checks or null-prototype objects, this CVE is a non-event even on unpatched Electron versions.
Exploit ScenarioDerived	A malicious web page loaded in a vulnerable Electron app uses `Object.defineProperty` to craft an object where the key `__proto__` is an enumerable own property pointing to an attacker-controlled object, then passes this object across the contextBridge to the preload script. The bridge's `Set()` call triggers the `Object.prototype.__proto__` setter in the preload context, mutating the prototype of the received object. When the preload script subsequently reads a property it expects to find as a default (e.g., a method name), it instead encounters the attacker-supplied value from the polluted prototype, causing the preload to behave in attacker-influenced ways - potentially redirecting function calls or leaking context. The PR #51083 test cases demonstrate the exact attack payload using `Object.defineProperty({data: 1}, '__proto__', {value: {polluted: true}, enumerable: true})`.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).

Patch available 0.4% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Aug 05, 2026

Prototype pollution via Electron's contextBridge allows untrusted renderer-side web content to smuggle a malicious prototype across the isolation boundary into preload script context, bypassing context isolation in versions prior to 39.8.9, 40.9.2, 41.2.2, and 42.0.0-beta.4. Exploitation is conditional on preload scripts accepting object arguments from untrusted content and reading inherited properties without own-property guards. No public exploit has been identified at time of analysis, and the flaw is not listed in CISA KEV; however, the scope-change (S:C) CVSS metric reflects that a successful attack crosses the renderer-to-preload privilege boundary, which can have amplified consequences in apps that expose sensitive Node.js APIs through the bridge.

RemediationAI

Upgrade to a patched Electron release: v39.8.9 (https://github.com/electron/electron/releases/tag/v39.8.9), v40.9.2 (https://github.com/electron/electron/releases/tag/v40.9.2), v41.2.2 (https://github.com/electron/electron/releases/tag/v41.2.2), or v42.0.0-beta.4 (https://github.com/electron/electron/releases/tag/v42.0.0-beta.4). The patch is available in published GitHub releases and confirmed by the GHSA advisory. If an immediate framework upgrade is not feasible, the vendor-recommended interim workaround is to audit all preload bridge APIs that accept object arguments and replace bare property reads (e.g., obj.prop) with own-property checks using Object.hasOwn(obj, key) - this prevents access to prototype-injected values. Alternatively, copy inbound objects onto a null-prototype container before use: const safe = Object.assign(Object.create(null), untrustedObj), which strips the entire prototype chain. Both workarounds require preload code changes and add developer burden; they should not substitute for the framework patch long-term.

Affected VersionsENISA

electron 40.0.0-alpha.1, < 40.9.2

electron 41.0.0-alpha.1, < 41.2.2

electron 42.0.0-alpha.1, < 42.0.0-beta.4

electron < 39.8.9

Affected Packages

npm electron fix: 39.8.9, 40.9.2, 41.2.2, 42.0.0-beta.4

euvd electron_40_0_0_alpha_1 fix: 40.9.2

euvd electron_41_0_0_alpha_1 fix: 41.2.2

euvd electron_42_0_0_alpha_1 fix: 42.0.0-beta.4

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's contextBridge is the sanctioned V8-level mechanism for sharing JavaScript values between the sandboxed renderer context (untrusted web content) and the privileged preload context (which has access to Node.js APIs). The root cause is CWE-1321 (Prototype Pollution): the C++ bridge implementation in electron_api_context_bridge.cc used V8's generic Set() API to copy object properties from one context to the other. When an object with an own property literally named __proto__ was passed across the bridge, the Set() call invoked the inherited Object.prototype.__proto__ setter in the destination context, mutating the destination object's prototype chain rather than writing a plain own data property. The fix (PR #51083) substitutes CreateDataProperty(), which unconditionally writes an own data property regardless of the key name, eliminating setter invocation. The affected package is npm/electron (cpe:2.3:a:electron:electron:*:*:*:*:*:*:*:*) across all major release lines below the fixed versions.

Know when Electron gets its next vulnerability

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

Continue with Google Continue with GitHub

No credit card · 7-day full trial

Severity by source

Vendor (GitHub_M) PRIMARY 5.4 MEDIUM

AV:N/AC:H/PR:N/UI:N/S:C/C:L/I:L/A:N

vuln.today AI 5.4 MEDIUM

Network vector because untrusted web content is the attack source; AC:H because exploitation requires non-default preload coding patterns; S:C reflects the renderer-to-preload context boundary crossing; C:L/I:L because impact is bounded by what the preload exposes.

3.1 AV:N/AC:H/PR:N/UI:N/S:C/C:L/I:L/A:N

4.0 AV:N/AC:H/AT:N/PR:N/UI:N/VC:L/VI:L/VA:N/SC:N/SI:N/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector

Network

Attack Complexity

High

Privileges Required

None

User Interaction

None

Scope

Changed

Confidentiality

Low

Integrity

Low

Availability

None

Lifecycle Timeline

Patch available

Aug 05, 2026 - 19:18 EUVD

CVE Published

Aug 05, 2026 - 17:41 cve.org

MEDIUM 5.4

DescriptionCVE.org

Electron is a framework for writing cross-platform desktop applications using JavaScript, HTML and CSS. Prior to 39.8.9, 40.9.2, 41.2.2, and 42.0.0-beta.4, objects copied across the contextBridge boundary from untrusted content could carry an attacker-influenced prototype, enabling prototype-pollution-style attacks against preload code despite context isolation being enabled. Apps are only affected if their preload code accepts object arguments from untrusted content and reads properties from them without own-property checks, while apps that only accept primitive arguments or validate object arguments are not affected. This issue is fixed in 39.8.9, 40.9.2, 41.2.2, and 42.0.0-beta.4.

Threat Intelligence Overview

EPSS Score

0.4%

Top 69% exploitable

Prevalence

High

Electron powers VS Code, Slack, Discord, and thousands of enterprise desktop apps.

Threat Intel

1 sources

Exploit

POC

Public exploit code exists

Data Quality

7 sources

Confidence: High

EUVD 🇯🇵JVN

NVD

CVE.org

EPSS

Vulnrichment GHSA

GitHub

VulDB

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 MEDIUM

CISA KEV No

Public POC Yes

EPSS 0.4%

Patch available Yes

Active threat No

Deciding rule

MEDIUM severity (CVSS 4.0-6.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· derived

Scheduled

Exploitation

None

System Exposure· derived

Open

Automatable

Human Impact· derived

High

Technical Impact

Partial

Priority Score

Low Medium High Critical

KEV: 0

EPSS: 0

CVSS: +27

PoC: +20

Weaponized: 0

Threat intel: 0

Gov advisory: 0

Attack Technique

Information Disclosure MEDIUM

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.