Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify endpoint parsing attacker-supplied PEM/DER with node-forge
-
DeliveryCraft small DER with deeply nested BIT STRINGs
-
ExploitSubmit to certificate/key/PKCS parsing API
-
Executionasn1.fromDer() recurses past maxDepth, retains quadratic copies
-
ImpactProcess heap exhausted, uncatchable OOM denial of service
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource consumption limits
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 | The target application must call node-forge's asn1.fromDer() with default options (decodeBitStrings defaults to true) on attacker-supplied input - this is the case for the higher-level pki.certificateFromPem(), pki.publicKeyFromPem(), and the PKCS#7/#8/#12 loaders, and for forge's TLS client when it parses a server certificate. No authentication or user interaction is required (PR:N/UI:N), and default configurations are vulnerable; versions 1.3.2 through 1.4.0 are affected (this is an incomplete fix of CVE-2025-66031, so 1.3.2-1.4.0 remain exposed even after that earlier patch). Limiting factor for direct callers: code that calls forge.asn1.fromDer() directly and does not need encapsulated BIT STRING contents can pass {decodeBitStrings: false} as a workaround, but the PKI/PKCS/TLS APIs do not expose this option and rely on the decoded form, so for those the only remedy is upgrading to 1.4.1. |
| Impact | This is a genuine but bounded priority. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5 High) is internally consistent with the evidence: a remote, unauthenticated attacker (PR:N, UI:N) can trigger the flaw with low complexity (AC:L) by supplying a small crafted DER/PEM blob, and impact is availability-only (C:N/I:N/A:H) - denial of service via CPU and quadratic memory exhaustion that can abort the Node.js process with an uncatchable out-of-memory error. The affected API surface is broad and reached by default options (pki.certificateFromPem(), pki.publicKeyFromPem(), PKCS#7/#8/#12 loaders, and forge's TLS client parsing server certificates), which raises real exposure for any service that parses attacker-influenced certificates/keys. Counterbalancing signals: this is NOT in CISA KEV (no confirmed active exploitation), EPSS is not provided in the input (exploitation probability cannot be quantified), and the vuln.today decision label is 'this_week' rather than act_now/emergency. A public PoC reference exists in the GHSA advisory; it is not verified as working exploit code in the input. The GHSA notes this is an incomplete fix of CVE-2025-66031, so environments that only applied the earlier patch (1.3.2-1.4.0) remain exposed. Net: a legitimate high-severity DoS worth prompt patching, not a confidentiality/integrity breach and not evidenced as widely exploited. |
| Exploit ScenarioDerived | An attacker submits a small (~10-200 KB) PEM/DER structure containing nested BIT STRINGs - for example a crafted certificate or public key - to any endpoint whose server-side code parses it with node-forge's default asn1.fromDer() (e.g. pki.certificateFromPem()). Parsing recurses past the maxDepth limit and retains deep copies at each level, consuming hundreds of MB to over 1 GB and aborting the process with an uncatchable heap-out-of-memory error. A public PoC reference exists in the GHSA advisory (nested BIT STRINGs around a NULL); it is not verified as working exploit code in the input. |
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 (Forge) 1.3.2 through 1.4.0 lets remote, unauthenticated attackers exhaust CPU time and heap in any application that parses attacker-supplied DER or PEM through asn1.fromDer() with default options, aborting the Node.js process with a fatal out-of-memory error the application cannot catch. It is an incomplete fix of CVE-2025-66031: ASN.1 decoded from primitive BIT STRING contents bypasses the maxDepth recursion limit, and nested BIT STRINGs are decoded recursively while a deep copy of the decoded contents is retained at every level, so memory grows quadratically with nesting depth. Tens of kilobytes of crafted input reach hundreds of megabytes to gigabytes via pki.certificateFromPem(), pki.publicKeyFromPem(), the PKCS#7/#8/#12 loaders and forge's TLS client certificate parsing; no public exploit tooling is identified at time of analysis, although the upstream advisory documents a proof-of-concept input shape (nested BIT STRINGs) that is not verified as working exploit code, and 1.4.1 fixes the issue by propagating maxDepth into the BIT STRING decode and decoding only one level.
RemediationAI
Vendor-released patch: node-forge 1.4.1 - upgrade to 1.4.1 or later (npm install node-forge@1.4.1 and refresh the lockfile) and confirm no transitive dependency still pins <= 1.4.0; the vendor states that for the higher-level PKI, PKCS and TLS APIs upgrading is the only complete remedy because those interfaces do not expose the parser option needed to disable BIT STRING decoding. For code that calls forge.asn1.fromDer() directly and does not need encapsulated BIT STRING contents decoded, the documented workaround is to pass {decodeBitStrings: false} to fromDer(), with the trade-off that the parsed structure changes - encapsulated contents come back as raw undecoded BIT STRING values, so any consumer that inspects them must be adjusted, and this option is not available through the PKI/PKCS/TLS entry points. Code that previously relied on nested BIT STRING contents being decoded automatically can, after upgrading, call asn1.fromDer() explicitly on the inner value. Note that 1.4.1's behavior is to keep over-limit and nested-BIT-STRING contents undecoded rather than raising an error, so parsing succeeds and toDer() round-trips the original bytes; validate downstream logic that assumed fully decoded structures. Details and the maintainers' guidance are in https://github.com/digitalbazaar/forge/security/advisories/GHSA-rhr8-3pm8-cq29 and https://github.com/digitalbazaar/forge/releases/tag/v1.4.1; this item is tracked at this-week priority, so schedule the dependency bump in the current cycle.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in 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 its supporting ASN.1/DER, PKI and PKCS primitives, distributed as the npm package node-forge (CPE cpe:2.3:a:digitalbazaar:forge). Its lib/asn1.js parser walks DER with a recursion guard, asn1.maxDepth, defaulting to 256 and overridable per call. By default asn1.fromDer() also speculatively decodes the contents of primitive BIT STRINGs as ASN.1 (decodeBitStrings: true), which is how encapsulated structures such as SubjectPublicKeyInfo are surfaced. Two defects in that speculative path produce the resource exhaustion class described by CWE-400 (Uncontrolled Resource Consumption) and CWE-674 (Uncontrolled Recursion). First, _fromDer() restarted the BIT STRING decode with a fresh options object containing only {strict: true, decodeBitStrings: true}, so options.maxDepth was lost and the depth comparison ran against undefined, meaning neither the per-call limit nor the global default applied to anything below a decoded BIT STRING; because errors in this speculative decode (including stack overflows) are caught and the bytes retained, deep nesting was parsed rather than rejected. Second, BIT STRINGs nested inside already-decoded BIT STRING contents were decoded again, and asn1.create() stores a deep copy of decoded contents in obj.original (used by toDer() to detect modification), so retained memory grows quadratically with nesting depth even inside the nominal limit. No specification is violated; the parser simply lacked a resource bound in that path. The 1.4.1 fix passes maxDepth into the BIT STRING decode and sets decodeBitStrings: false there, so only one level is decoded and over-limit contents are preserved as undecoded BIT STRING values whose original bytes toDer() re-emits; callers that genuinely need nested decoding must invoke asn1.fromDer() explicitly on the inner value. Regression coverage was added in tests/unit/asn1.js.
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:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Remote unauthenticated attacker supplies a small crafted blob to default parsing APIs (AV:N/AC:L/PR:N/UI:N); impact is availability-only process exhaustion with no confidentiality or integrity effect.
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 asn1.fromDer(), BIT STRING decoding, maxDepth to process the relevant input or security decision. node-forge decoded ASN.1 stored inside BIT STRING values without consistently applying the configured maxDepth limit and recursively retained copies at each nesting level. Crafted DER containing nested BIT STRINGs could cause excessive recursion, CPU use, and quadratic memory consumption during asn1.fromDer(). This issue is fixed in version 1.4.1.
Technical POC Analysis
CWE-400 (Uncontrolled Resource Consumption), with the advisory also citing CWE-674 (Uncontrolled Recursion).
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
CVE-2026-119191 is a high-severity denial-of-service vulnerability in node-forge (versions 1.3.2-1.4.0), a widely used JavaScript library for ASN.1 and cryptographic parsing. Remote, unauthenticated attackers can crash Node.js applications by sending crafted DER or PEM data that triggers uncontrolled CPU and memory exhaustion, leading to fatal out-of-memory errors. Any service that parses untrusted certificates, keys, or PKCS messages (e.g., TLS termination, API gateways, file upload processors) is at risk of full process termination, disrupting availability and potentially causing financial and reputational harm. Leadership should prioritize mitigation because node-forge is embedded in many critical authentication and communication flows.
No vendor-released patch identified at time of analysis. Interim mitigations: enforce input size limits (e.g., maximum 10 KB) on all DER/PEM data before passing to node-forge, implement recursion depth limits via custom ASN.1 parsing wrappers, apply rate limiting and anomaly detection to block abusive payloads, and consider segmenting or isolating services that heavily rely on node-forge until a patch is available.
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
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'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
Forge (also called `node-forge`) is a native implementation of Transport Layer Security in JavaScript. Rated medium seve
EUVD-2026-113348
NVD
CVE.org
EPSS
GitHub
Exploit-DB