Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessVictim client connects to malicious server
-
DeliveryServer returns crafted Set-Cookie __proto__/constructor header
-
Exploitforge.http stores cookie key on Object.prototype
-
ExecutionRealm-wide prototype polluted or built-in method deleted
-
ImpactApplication logic corrupted or denial of service
Vulnerability Assessment
| Weakness |
CWE
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. |
| Exploitation Conditions | Exploitation requires that the application actually uses the forge.http client - either directly or through forge.xhr in the forge.all browser bundle with a configured socket pool - AND connects to a server the attacker controls or can influence, since the pollution is driven entirely by the server's Set-Cookie response headers (cookie names __proto__ or constructor, or an empty value to invoke the removal/delete path). Critically, forge.http is NOT loaded by require('node-forge'), so the common Node.js usage of node-forge for TLS/crypto is unaffected - this is the primary limiting factor. The deletion path skips the secure-flag and domain checks, so it works against both http:// and https:// clients. Applications that do not use forge.http/forge.xhr are not exploitable at all, and the impact is limited to Object/Object.prototype modification within the JavaScript realm (no direct code execution or data disclosure indicated by the evidence). |
| Impact | This is a genuinely moderate-severity issue rather than a high-CVSS-but-low-risk inflation case - the vendor-supplied CVSS 3.1 base score is 4.8 (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:L), which already reflects a limited blast radius: no confidentiality impact (C:N) and only low integrity and availability impact (I:L/A:L) from prototype pollution. The signals are largely consistent: AV:N and PR:N reflect that a remote, unauthenticated malicious server triggers the flaw, while AC:H captures the real-world precondition that the victim application must use the forge.http/forge.xhr code path against that untrusted server. EPSS is not provided in the input, and the CVE is not listed in CISA KEV, so there is no confirmed active exploitation. A detailed proof-of-concept and regression test are published in the GitHub Security Advisory itself. The vuln.today decision label is 'this_month' (not act_now/emergency), which aligns with a patch-this-cycle posture rather than an emergency. Net: real but bounded priority - the narrow exploitation surface (forge.http is not loaded by require('node-forge') and is only in the forge.all browser bundle with a socket pool) is the main factor keeping real-world risk lower than the network-reachable vector alone would suggest. |
| Exploit ScenarioDerived | An application that uses the forge.http client (directly or via forge.xhr in the forge.all browser bundle) connects to an attacker-controlled or compromised server. The server returns a response with a crafted header such as 'Set-Cookie: __proto__=evil; path=polluted', causing forge.http's cookie store to write the attacker's value onto Object.prototype for the entire JavaScript realm; alternatively 'Set-Cookie: __proto__=; path=toLocaleString' deletes a built-in Object.prototype method (working for both http:// and https:// clients). A working proof-of-concept and regression tests are published in the GHSA advisory. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 29, 2026
Prototype pollution in the forge.http cookie store in node-forge through 1.4.0 lets a malicious server write attacker-controlled properties onto Object.prototype or the Object constructor, and delete built-in Object.prototype methods, in any application that uses forge.http directly or forge.xhr from the forge.all browser bundle. Only unauthenticated remote interaction is required in the CVSS vector (AV:N/PR:N/UI:N) but the vector also carries AC:H, reflecting that the attacker must control or influence the server the client connects to and the application must actually load forge.http; crucially forge.http is not loaded by require('node-forge'), so ordinary Node.js TLS/crypto consumers are unaffected. Its impact is confined to the JavaScript realm's object model (C:N/I:L/A:L, CVSS 3.1 base 4.8), and no public exploit code or active exploitation is identified in the available data; node-forge 1.4.1 fixes the issue.
RemediationAI
Upgrade node-forge to 1.4.1 or later - the vendor-released patch (https://github.com/digitalbazaar/forge/releases/tag/v1.4.1, commit 797c3f816a22748a96fceebb34eb3a6716853991) resolves GHSA-6wvx-3r32-xmcg by using own-property checks for the cookie store and by ignoring cookies named '__proto__' or with the path '__proto__'. Because the vulnerable code only ships in the forge.http client and the forge.all bundle, inventory whether your application loads forge.http directly or through forge.xhr with a socket pool; if it does not, no code change is required for this CVE, though upgrading remains the simplest confirmation. The vendor-listed workarounds, if upgrading is not immediately possible, are to avoid using forge.http or forge.xhr against servers that are not trusted, or to filter Set-Cookie headers named __proto__, constructor or other Object.prototype property names before they reach the client - the trade-off is that legitimate cookies under such unusual names would also be dropped, and header filtering must be applied on every response path or the prototype can still be polluted. The deletion variant works over plain http:// as well as https:// clients, so transport security alone does not mitigate it. Per the vendor, updating is the complete fix.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 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
The flaw is CWE-1321 (Improperly Controlled Modification of Object Prototype Attributes), a prototype pollution class issue in JavaScript. In lib/http.js, client.setCookie() stored each cookie as client.cookies[cookie.name][cookie.path] = cookie and only initialized the per-name bucket when !(cookie.name in client.cookies). Because the in operator also sees inherited properties, a Set-Cookie whose name was __proto__ resolved the bucket to Object.prototype and wrote the attacker-supplied path as a new Object.prototype property visible to every object in the realm; the name constructor wrote onto the global Object function the same way. A cookie with an empty value routed into client.removeCookie(name, path), which used the same inherited-property in checks before running delete client.cookies[name][path], so '__proto__=; path=toString' removed Object.prototype.toString; that removal path skipped the cookie's secure-flag and domain checks, so it worked for plain http:// clients as well as https://. Both cookie name and path derive from the server's Set-Cookie header via response.getCookies(). The fix in 1.4.1 adds an _hasOwn() helper using Object.prototype.hasOwnProperty.call() for all cookie store lookups in setCookie/getCookie/removeCookie, and explicitly ignores any cookie whose name or path is '__proto__'. A regression test lives in tests/security/ghsa-6wvx-3r32-xmcg.js. The trigger for the individual cookie handling is well described; no memory-safety or code-execution primitive is involved.
Know when Forge 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
No credit card · 7-day full trial
Severity by source
AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:L
A remote malicious server needs no auth (AV:N/PR:N/UI:N), but the victim must use forge.http against an untrusted server (AC:H); no confidentiality impact, only limited integrity/availability from prototype pollution.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Forge (also called node-forge) is a native implementation of Transport Layer Security in JavaScript. Prior to 1.4.1, the forge.http client stored cookie names and paths from Set-Cookie response headers in ordinary JavaScript objects. A malicious server could use the cookie name __proto__ so that the attacker-controlled cookie path was written as a property on Object.prototype, or use inherited names such as constructor to modify Object. An empty cookie value could use the removal path to delete an inherited Object.prototype property. Applications using forge.http directly or through forge.xhr are affected; applications that do not use forge.http are unaffected. This issue is fixed in version 1.4.1.
Blast Radius
ecosystem impact- 6 npm packages depend on node-forge (3 direct, 3 indirect)
Ecosystem-wide dependent count for version 1.4.1.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
An interpretation-conflict (CWE-436) vulnerability in node-forge versions 1.3.1 and earlier enables unauthenticated atta
The package node-forge before 0.10.0 is vulnerable to Prototype Pollution via the util.setPath function. Rated high seve
RSA PKCS#1 v1.5 signature forgery in node-forge through v1.4.0 enables unauthenticated network attackers to craft signat
Forge (also called `node-forge`) is a native implementation of Transport Layer Security in JavaScript. Rated high severi
Regular expression denial of service in node-forge's pem.decode() allows remote, unauthenticated attackers to block the
Denial of service in node-forge (Forge) 1.3.2 through 1.4.0 lets remote, unauthenticated attackers exhaust CPU time and
Denial of service in node-forge's JavaScript TLS implementation: a connection created with forge.tls.createConnection()
Call stack exhaustion in node-forge's TLS record processing (all versions through 1.4.0) allows a remote peer to crash o
PKCS#12 MAC forgery and constant-key password-based decryption in node-forge 1.4.0 and earlier let anyone who does not k
Forge (also called `node-forge`) is a native implementation of Transport Layer Security in JavaScript. Rated high severi
Forge (also called `node-forge`) is a native implementation of Transport Layer Security in JavaScript. Rated high severi
Certificate chain validation in node-forge (Forge) through version 1.4.0 can be bypassed because the parser maps the dep
EUVD-2026-113335
GHSA-6wvx-3r32-xmcg
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB