Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain cert signed by trusted issuer
-
ExploitRelabel outer signatureAlgorithm as RSASSA-PSS
-
Executionnode-forge verifies using issuer's scheme
-
ImpactBypass declared-signature-scheme policy
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A04:2025 - Cryptographic Failures
ASVS 5.0
V11 - Cryptography Signature verification
|
| Exploitation Conditions | Exploitation requires an application running node-forge <=1.4.0 that makes a security decision based on a certificate's DECLARED signature algorithm (for example, a policy that accepts only RSASSA-PSS-signed certificates). The attacker supplies a certificate whose signatureAlgorithm fields are labeled RSASSA-PSS but whose signature is actually PKCS#1 v1.5, which node-forge accepts when the trusted issuer itself was signed with PKCS#1 v1.5 - because verification used the issuer's scheme instead of the child's. The no-private-key variant simply relabels the outer (unsigned) signatureAlgorithm of an existing CA-signed certificate. Strong limiting factors keep real-world risk low: the signature must still have been produced by the trusted issuer's private key, so certificate identity cannot be forged; the impact is confined to applications that treat the declared signature scheme as a trust signal; there is no confidentiality or availability impact; and it is fixed in 1.4.1. |
| Impact | This is a genuinely low-priority issue that the signals agree on. The CVSS 3.1 vector (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:N = 3.7 Low) shows only a Low integrity impact and no confidentiality or availability impact, with high attack complexity. The vuln.today decision label is 'monitor,' the lowest urgency tier, and the issue is NOT in CISA KEV (no confirmed active exploitation). No EPSS score was supplied in the input, so exploitation probability cannot be quantified - treat that as a data gap rather than evidence of low likelihood. SSVC component fields (automatable, technical impact) were not provided beyond the 'monitor' label. A detailed proof-of-concept is published in the GHSA advisory, but PoC availability is a distinct signal from active exploitation and does not raise this to an emergency. Crucially, the flaw does NOT enable certificate identity forgery: the signature must still be produced with the trusted issuer's private key. It only lets a certificate be relabeled with a different RSA signature scheme (RSASSA-PSS vs PKCS#1 v1.5), defeating applications whose security policy keys off the declared signature algorithm. The CVSS 4.0 score in the advisory (6.3 Moderate) is higher purely because 4.0 weights integrity more; the vendor explicitly says the rating follows CVSS 3.1 Low. Net: a real correctness/cryptographic-policy bug worth patching in routine maintenance, not an incident-grade priority. |
| Exploit ScenarioDerived | An application uses node-forge's verifyCertificateChain()/certificate.verify() to enforce a policy that only RSASSA-PSS-signed certificates are accepted. An attacker takes a certificate legitimately signed by the trusted CA with PKCS#1 v1.5 and relabels only its outer (unsigned) signatureAlgorithm field as RSASSA-PSS; on node-forge <=1.4.0 it still verifies and reports signatureOid as RSASSA-PSS, bypassing the policy. A detailed PoC (including a no-private-key relabel variant) is published in the GHSA advisory; attack complexity is high (AC:H) and no identity forgery is possible since the signature must still come from the trusted issuer's key. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 29, 2026
Certificate chain verification in node-forge 1.4.0 and earlier chooses the RSA padding scheme and RSASSA-PSS parameters from the issuer certificate rather than from the child certificate being verified, so a certificate whose signatureAlgorithm fields are labeled RSASSA-PSS is accepted on a PKCS#1 v1.5 signature when the trusted issuer was itself PKCS#1 v1.5-signed. The practical impact is confined to applications that treat a certificate's declared signature scheme as a trust decision - the signature must still be produced with the trusted issuer's private key, so certificate identity cannot be forged, and there is no confidentiality or availability impact. Rated 3.7 (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:N), unauthenticated from the network, with no KEV listing or confirmed working exploit code reported; the vendor advisory does include a public proof-of-concept reproduction procedure, and node-forge 1.4.1 fixes the flaw, so this is a monitor-priority item rather than an emergency.
RemediationAI
Upgrade to node-forge 1.4.1 or later (for example npm install node-forge@1.4.1), which verifies each certificate's signature with the padding scheme and PSS parameters of that certificate's own signature algorithm while using the issuer's public key; the change is in commit c7f42614d5166a77ddf11ce174b2601b14f6956b and the release is tagged at https://github.com/digitalbazaar/forge/releases/tag/v1.4.1, with advisory GHSA-9wg5-mj3p-v49q documenting the issue. Be aware that upgrading changes validation outcomes in both directions: certificates that were wrongly accepted under a mismatched scheme will now be rejected as 'Certificate signature is invalid', and correctly signed chains that mix PKCS#1 v1.5 and RSASSA-PSS between issuer and child, which previously failed, will now verify - test policies and fixtures before rolling out. The vendor's stated workaround for applications that make a security decision on a certificate's declared signature algorithm is to verify that signature independently using the algorithm's own scheme and parameters with the issuer's public key, since that check is not affected by the library's selection logic; this is a per-application code change and does not protect other call sites inside the same process, so it should be treated as temporary until 1.4.1 is deployed. Applications that cannot upgrade should avoid treating signatureOid or PSS parameter fields as an authorization or policy signal for certificates validated by node-forge, and should log and reject chains where the declared scheme differs from what the deployment expects.
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 PKI primitives used both in Node.js and the browser, including X.509 certificate parsing and path validation. The defect is CWE-347 (Improper Verification of Cryptographic Signature): in lib/x509.js, certificate.verify(child) hashed the child's TBSCertificate using the digest taken from the child's signature algorithm but then called _verifySignature() with the issuer certificate object, and _verifySignature() derived the RSA padding scheme and PSS parameters (MGF1 hash, salt length) from that issuer certificate's own signatureOid and signatureParameters. Verification therefore ran with the issuer's scheme instead of the scheme the child declares. This matters because the outer signatureAlgorithm field of an X.509 certificate sits outside the signed TBSCertificate (RFC 5280 §4.1.1.2), so it can be edited without the issuer's private key; because the RSASSA-PSS identifier of RFC 4055 §3 was interpreted using PKCS#1 v1.5 padding parameters, a relabeled PKCS#1 v1.5 certificate still verified. The same root cause also caused false negatives - correctly signed PKCS#1 v1.5 certificates issued under an RSASSA-PSS-signed CA (and the reverse) failed verification. The upstream fix passes certificate: child together with publicKey: cert.publicKey into _verifySignature(), so the padding scheme and parameters come from the child's declared algorithm while the issuer's public key is still used to check the signature.
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:N
PR:N since presenting a certificate needs no authentication; AC:H because it requires an issuer signed with PKCS#1 v1.5 plus an app that trusts the declared scheme; impact is integrity-only (I:L), no C/A.
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 certificate.verify(child), _verifySignature(), lib/x509.js to process the relevant input or security decision. node-forge selected RSA padding and RSASSA-PSS parameters from the issuer certificate rather than the child certificate being verified. A child labeled as RSASSA-PSS could therefore be accepted with a PKCS#1 v1.5 signature when the issuer used PKCS#1 v1.5. The signature still had to be produced with the trusted issuer's private key, so this did not permit certificate identity forgery, but it could bypass policies that require a declared signature scheme. This issue is fixed in 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
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
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-113331
NVD
CVE.org
EPSS
GitHub
Exploit-DB