Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAwait/induce forge TLS client connection
-
ExploitSend ServerHello plus ServerHelloDone, omit Certificate
-
ExecutionClient reads null serverCertificate.publicKey
-
ImpactUncaught TypeError crashes Node.js process
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A10:2025 - Mishandling of Exceptional Conditions
ASVS 5.0
V16 - Security Logging and Error Handling Null pointer safety, defensive checks
MITRE ATT&CK
1 technique across 1 tactic: Impact The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires the victim application to use node-forge's TLS client specifically - forge.tls.createConnection({server:false}) - on a vulnerable version (<= 1.4.0), and to feed received network bytes into connection.process() from a handler that does not catch the thrown exception (the GHSA workaround is to wrap process() in try/catch and close the connection). The attacker must either be the TLS server the client connects to, or an on-path peer able to modify the still-unauthenticated handshake to drop the server Certificate message; no credentials are needed (PR:N). Limiting factors: applications that use Node.js's native TLS stack are NOT affected; only the forge TLS-client code path is vulnerable; and the attacker needs the client to connect to an attacker-controlled/on-path endpoint. Impact is limited to a crash (availability) - there is no confidentiality or integrity impact and no authentication bypass. |
| Impact | This is a moderate-severity denial-of-service (CWE-476 NULL pointer dereference) in the node-forge TLS *client*, and the signals are internally consistent at a middling priority rather than an emergency. The provided CVSS 3.1 vector (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H, 5.9) confirms network reach, no authentication (PR:N) and availability-only impact (C:N/I:N - the advisory explicitly states there is no confidentiality or integrity impact and no authentication bypass, since without a certificate the client cannot complete the RSA key exchange). The vuln.today Decision label is 'this_month', indicating a planned-remediation priority, not act_now/emergency. No CISA KEV entry is present, so this is 'no public exploit identified as actively exploited'; however the GHSA advisory includes a detailed Proof of concept and committed regression tests, so a public PoC reference exists - it is not supplied as verified standalone weaponized exploit code. No EPSS score was provided, so exploitation-probability cannot be quantified from this data; absence of EPSS is a gap, not a low score. The vendor's own 3.1 AC:H and the informational 4.0 vector (AC:L/AT:P, 8.2) diverge because 4.0 weights availability higher; I assess the trigger itself as low-complexity (a malicious server simply omits the Certificate message), with the real limiter being that a forge TLS client must connect to an attacker-controlled or on-path-modifiable endpoint - see my independent vector below. Net: a genuine, patch-worthy reliability/DoS bug with a narrow prerequisite (use of the forge TLS client), not a high-urgency RCE. |
| Exploit ScenarioDerived | An application uses forge.tls.createConnection({server:false}) and connects to a server that is attacker-controlled, or an on-path attacker strips the Certificate (handshake type 11) message from an unauthenticated server's first flight. The client's missing-certificate check reads the wrong property (c.serverCertificate instead of c.session.serverCertificate), so the handshake proceeds to key exchange, dereferences the null certificate's publicKey, and throws an uncaught TypeError out of connection.process() - crashing the Node.js process. A detailed reproduction PoC 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
Denial of service in node-forge's TLS client (1.4.0 and earlier) lets a malicious TLS server, or an on-path attacker who strips the server Certificate message, crash applications that call forge.tls.createConnection({server:false}). The client's missing-certificate check reads the wrong property, so the handshake proceeds into RSA key exchange and dereferences the absent certificate, throwing a TypeError out of connection.process() that can terminate a Node.js process when uncaught. The flaw is availability-only (assessed CVSS 3.1: 5.9, AV:N/AC:L/PR:N/UI:N, C:N/I:N/A:H), is not in CISA KEV, and has a public PoC reference in the advisory that is not verified as working exploit code; applications using Node.js's native TLS stack are unaffected.
RemediationAI
Upgrade to node-forge 1.4.1 (npm install node-forge@1.4.1); the vendor release is https://github.com/digitalbazaar/forge/releases/tag/v1.4.1 and the fix commit is 7be9fbd40df2e2f15f29fea2846b1c87d58f6888, per advisory GHSA-525v-9gp9-w22h. If upgrading is not immediately possible, the vendor workaround is to wrap calls to connection.process() in try/catch in the socket data handler and close the connection when an exception occurs; this prevents the process crash but does not restore the intended insufficient_security handshake failure, and applications that rely on verify/error callbacks will not receive them on this path. The patch changes handleServerHelloDone to read c.session.serverCertificate and to fail the handshake even when verify accepts, because RSA key exchange requires the certificate.
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
node-forge is a pure-JavaScript implementation of TLS and related cryptographic primitives. In the client handshake, tls.handleServerHelloDone() is intended to reject a server that sent no Certificate message with a fatal insufficient_security alert after consulting the application's verify callback, but the code tested c.serverCertificate, a property that is never set, instead of c.session.serverCertificate. Because the client state machine permits ServerHelloDone directly after ServerHello, the handshake continues to tls.createClientKeyExchange(), which reads c.session.serverCertificate.publicKey and throws a TypeError on the null certificate; the exception propagates out of connection.process() without invoking the verify or error callbacks. This is CWE-476 (NULL pointer dereference) manifesting as a JavaScript TypeError, and the trigger is specifically the omission of the TLS Certificate message (RFC 5246 section 7.4.2) on an RSA key-exchange handshake. There is no authentication bypass: without a server certificate the client cannot complete RSA key exchange. The fix in 1.4.1 reads c.session.serverCertificate and always fails the handshake with insufficient_security, still calling verify so applications can customize the alert.
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:N/A:H
A malicious server trivially omits the Certificate message so AC:L/PR:N/UI:N; crash is same-scope availability only (C:N/I:N/A:H); vendor's AC:H instead reflects the on-path MITM scenario.
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 affected implementation used forge.tls.createConnection(), c.session.serverCertificate, RSA key exchange to process the relevant input or security decision. node-forge's TLS client checked the wrong property when deciding whether a server certificate was missing. A malicious TLS server or on-path peer could omit the Certificate message and reach code that dereferenced the absent certificate, causing an uncaught exception and terminating the connection or process. 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
A null pointer dereference occurs when a program attempts to access memory through a pointer that has been set to NULL (address 0x0).
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
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-113336
GHSA-525v-9gp9-w22h
NVD
CVE.org
EPSS
Exploit-DB