Skip to main content

node-forge CVE-2026-119188

| EUVDEUVD-2026-113365 HIGH
Uncaught Exception (CWE-248)
2026-10-29 GitHub_M GHSA-8hrf-8g6f-7xwp
7.5
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Connect to forge TLS endpoint
  2. Delivery
    Send fragmented handshake record
  3. Exploit
    Interleave different content-type record
  4. Execution
    Trigger uncaught TypeError in process()
  5. Impact
    Crash hosting 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 Exception handling completeness
Exploitation Conditions

The application must use node-forge's TLS implementation via forge.tls.createConnection() (including forge.tls.wrapSocket() and the forge.http / forge.xhr TLS connections) and call connection.process() from a socket 'data' handler without wrapping it in try/catch - the documented usage pattern. Under those conditions no further prerequisites apply: a remote peer with network reachability triggers the crash unauthenticated with ~18 bytes before the handshake, in both server mode (any client that can connect) and client mode (any server the forge client connects to). Limiting factors: it only affects deployments that actually use forge's TLS layer (not consumers of its crypto primitives alone), and the documented workaround - wrapping every process() call in try/catch - neutralizes it since the connection is already failed and closed when the exception is thrown.

Impact

This is a genuine, easily-triggered availability issue but not a confidentiality or integrity threat. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5) is internally consistent with the advisory: a remote, unauthenticated peer can crash the process with 18 bytes before the handshake, in either server or client mode, against default behavior. The impact is purely availability (A:H, C:N/I:N) - the vuln.today decision label is 'this_week' rather than act_now/emergency, which fits a high-reliability-impact-but-no-data-exposure DoS. No EPSS score and no KEV status were supplied, so there is no evidence of active exploitation; a detailed working PoC (exact byte sequence plus regression tests) is published in the GitHub Security Advisory, so public exploit material does exist. The main nuance limiting real-world risk is scope: only applications that actually use node-forge's TLS layer (forge.tls.createConnection, forge.tls.wrapSocket, forge.http/forge.xhr) and call process() from a socket data handler without try/catch - the documented usage - are affected; consumers that use node-forge only for its crypto primitives are not. Note the input Tags label this 'Information Disclosure', which contradicts the advisory and the CVSS vector (C:N/I:N, A:H); this is a denial-of-service bug, not information disclosure.

Exploit ScenarioDerived

An attacker who can reach a Node.js service that terminates TLS with node-forge (server mode) - or a service that opens an outbound forge TLS client connection the attacker controls - sends two tiny records: the start of a fragmented handshake message followed by a record of a different content type (alert, change_cipher_spec, application_data or heartbeat). node-forge fails the connection correctly but then throws an uncaught TypeError from process(), terminating the hosting process and dropping all its connections; the attacker can repeat this on every restart. A complete, working 18-byte PoC and regression tests are published in the GHSA advisory.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.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 – Oct 29, 2026

Denial of service in node-forge's JavaScript TLS implementation: a connection created with forge.tls.createConnection() throws an uncaught TypeError from process() when a peer sends a record of a different content type (alert, change_cipher_spec, application_data or heartbeat) in the middle of a handshake message that was fragmented across records. Any peer with network reachability can trigger it unauthenticated with roughly 18 bytes before the handshake completes - in server mode any connecting client, in client mode any server the forge client talks to - and in Node.js deployments that follow the documented pattern of calling process() from a socket 'data' handler, the exception terminates the process, dropping every connection it serves and allowing repetition on each restart. There is no confidentiality or integrity impact, and forged traffic is limited to availability (CVSS 3.1 7.5, A:H); no confirmed active exploitation or KEV listing is reported, though the advisory itself publishes a two-record proof-of-concept byte sequence, which is not verified as working exploit code. Fixed in node-forge 1.4.1.

RemediationAI

Vendor-released patch: upgrade node-forge to 1.4.1 or later (npm install node-forge@1.4.1), which adds an early return in _readRecord() after the fatal unexpected_message path; the fix commit is https://github.com/digitalbazaar/forge/commit/700d977d39f9f8f896c55b0763eebb940a2c087e and the advisory is https://github.com/digitalbazaar/forge/security/advisories/GHSA-8hrf-8g6f-7xwp. Where upgrading is not immediately possible, the vendor-documented workaround is to wrap every call to connection.process() in try/catch: the connection has already been failed and closed by the time the TypeError is thrown, so the exception can be safely swallowed or the socket destroyed at that point. The trade-off is that this must be applied consistently at every call site, including handlers wired by forge.tls.wrapSocket() and the forge.http / forge.xhr TLS connections, and any unwrapped path - such as the documented socket.on('data', ...) usage - remains exposed to full process termination; since an uncaught exception in that pattern is fatal, also ensure a process-level supervisor restarts the service if a crash does occur. Deployments that do not use forge's TLS connection object at all are unaffected and can defer the upgrade to normal dependency maintenance.

Affected VersionsENISA

forge < 1.4.1

Affected Packages

npm node-forge fix: 1.4.1
euvd forge fix: 1.4.1

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 cryptography, and its TLS layer is driven by an application-supplied byte stream fed into connection.process(); protocol errors are surfaced through the error callback rather than thrown exceptions, so applications are not expected to wrap process() in try/catch. RFC 5246 section 6.2.1 permits a handshake message to be fragmented across multiple records, while RFC 8446 section 5.1 forbids interleaving handshake messages with records of other content types. In lib/tls.js, _readRecord() correctly detects the interleaved record, reports 'Invalid fragmented record.' via c.error() and emits a fatal unexpected_message alert; the fatal error closes and resets the connection, setting c.record to null, but the function then continues and executes c.record.ready = true, producing 'TypeError: Cannot set properties of null (setting \'ready\')' that escapes process(). The root cause class is CWE-248 (uncaught exception) manifesting as CWE-476 (null pointer dereference) - a missing early return after the fatal-error branch, not a memory-safety or cryptographic weakness. The code was unchanged since the first release; the 1.4.1 fix simply returns from _readRecord() immediately after the fatal error, so the connection still fails with the alert and error callback but process() no longer throws, with regression tests covering all four interleaved record types in both server and client mode plus legitimate same-type continuation records.

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

Vendor (GitHub_M) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 7.5 HIGH

Remote unauthenticated peer crashes the process with a few bytes before the handshake, so AV:N/AC:L/PR:N/UI:N; impact is availability-only (A:H), no confidentiality or integrity.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

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

Lifecycle Timeline

2
Patch available
Oct 29, 2026 - 20:18 EUVD
CVE Published
Oct 29, 2026 - 19:21 cve.org
HIGH 7.5

DescriptionCVE.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(), fragmented handshake message, interleaved record to process the relevant input or security decision. node-forge continued processing after a TLS record of another content type interrupted a fragmented handshake message. A remote peer could trigger an uncaught TypeError in process(), causing the connection or hosting process to fail. This issue is fixed in version 1.4.1.

Blast Radius

ecosystem impact
† from your stack dependencies † transitive graph · vuln.today resolves 4-path depth
  • 6 npm packages depend on node-forge (3 direct, 3 indirect)

Ecosystem-wide dependent count for version 1.4.1.

Technical POC Analysis

CVE-2026-119188 is an uncaught-exception denial of service, CWE-248 (the advisory also maps CWE-476).

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

CVE-2026-119188 is a high-severity denial-of-service vulnerability in node-forge's JavaScript TLS implementation, affecting any Node.js service using forge.tls.createConnection() - including internal tooling, API gateways, and client-side TLS connections. An unauthenticated attacker with network reachability can crash the Node.js process with a single crafted TLS record (~18 bytes), dropping all connections and enabling repeated restarts. Leadership should care because this can cause service outages, SLA breaches, and operational disruption across any product relying on this library for TLS.

Business Impact: High
Compensating Controls

Wrap all forge.tls process() calls in try/catch to catch and log the TypeError, preventing uncaught exceptions from terminating the process; deploy process isolation (e.g., Node.js cluster with worker restart, or container orchestration with restart policies) to limit denial-of-service impact; restrict network access to TLS endpoints via firewall or rate limiting to reduce attack surface; monitor for abnormal connection patterns that could indicate exploitation attempts.

Threat Intelligence Overview

EPSS Score
0.4%
Top 65% exploitable
Prevalence
High
node-forge is a very widely deployed npm dependency; TLS feature less universal
Threat Intel
1
1 source
Data Quality
5 sources
Confidence: Medium
EUVD 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.4%
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
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

38
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +38
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

More in Forge

View all
CVE-2025-12816 HIGH POC
8.6 Nov 25

An interpretation-conflict (CWE-436) vulnerability in node-forge versions 1.3.1 and earlier enables unauthenticated atta

CVE-2020-7720 HIGH POC
7.3 Sep 01

The package node-forge before 0.10.0 is vulnerable to Prototype Pollution via the util.setPath function. Rated high seve

CVE-2026-85393 HIGH
8.7 Sep 03

RSA PKCS#1 v1.5 signature forgery in node-forge through v1.4.0 enables unauthenticated network attackers to craft signat

CVE-2025-66031 HIGH
8.7 Nov 26

Forge (also called `node-forge`) is a native implementation of Transport Layer Security in JavaScript. Rated high severi

CVE-2026-118779 HIGH
7.5 Oct 29

Regular expression denial of service in node-forge's pem.decode() allows remote, unauthenticated attackers to block the

CVE-2026-119191 HIGH
7.5 Oct 29

Denial of service in node-forge (Forge) 1.3.2 through 1.4.0 lets remote, unauthenticated attackers exhaust CPU time and

CVE-2026-119187 HIGH
7.5 Oct 29

Call stack exhaustion in node-forge's TLS record processing (all versions through 1.4.0) allows a remote peer to crash o

CVE-2026-118782 HIGH
7.5 Oct 29

PKCS#12 MAC forgery and constant-key password-based decryption in node-forge 1.4.0 and earlier let anyone who does not k

CVE-2022-24772 HIGH
7.5 Mar 18

Forge (also called `node-forge`) is a native implementation of Transport Layer Security in JavaScript. Rated high severi

CVE-2022-24771 HIGH
7.5 Mar 18

Forge (also called `node-forge`) is a native implementation of Transport Layer Security in JavaScript. Rated high severi

CVE-2026-119190 HIGH
7.4 Oct 29

Certificate chain validation in node-forge (Forge) through version 1.4.0 can be bypassed because the parser maps the dep

CVE-2025-66030 MEDIUM
6.3 Nov 26

Forge (also called `node-forge`) is a native implementation of Transport Layer Security in JavaScript. Rated medium seve

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