Skip to content

RSA PKCS#1 v1.5 signature forgery via extra elements in nested DigestAlgorithm

This report was submitted with AI assistance

High
davidlehn published GHSA-2g46-22mc-6gwp Oct 27, 2026

Package

npm node-forge (npm)

Affected versions

<= 1.4.0

Patched versions

1.4.1

Description

Summary

RSASSA-PKCS1-v1_5 signature verification (publicKey.verify() with the default scheme, also used by X.509 certificate and PKCS#7 verification) ignored extra elements inside the nested DigestAlgorithm SEQUENCE of the DigestInfo. For RSA keys with a low public exponent (e=3) this allows signatures to be forged for an arbitrary message without the private key. This is an incomplete fix of CVE-2026-33894. Fixed in node-forge 1.4.1.

Details

In lib/rsa.js, key.verify() with the default RSASSA-PKCS1-V1_5 scheme removes the padding, parses the recovered DigestInfo with asn1.fromDer() and checks it with asn1.validate() against digestInfoValidator. The fix for CVE-2026-33894 (GHSA-ppp5-5v6c-4jwp) added a check on the element count of the outer DigestInfo SEQUENCE only. asn1.validate() ignores extra children of the nested DigestAlgorithm SEQUENCE, so elements placed after the OID and NULL parameters were neither validated nor counted. They give an attacker a block of freely chosen bytes inside an accepted DigestInfo, enough to construct a signature that verifies for an arbitrary message without the private key when the public exponent is small (Bleichenbacher-style forgery).

RFC 8017 section 8.2.2 verifies a signature by encoding the expected EMSA-PKCS1-v1_5 message and comparing it with the recovered one; section 9.2 defines the DigestInfo encoding.

The fix adds _encodeDigestInfo(), which DER-encodes the expected DigestInfo from the digest algorithm OID and the digest (with and without NULL parameters). Verification now requires the recovered DigestInfo to match one of these encodings byte for byte. This also fixes the related non-canonical encoding issue GHSA-6qrw-m8cv-hcxf.

Patches

Fixed in node-forge 1.4.1. Verification now re-encodes the expected DigestInfo and requires a byte-for-byte match (RFC 8017 section 8.2.2).

Workarounds

Do not use RSA keys with a low public exponent (e=3) for signature verification.

References

Severity

CVSS 3.1: CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N (7.5, High)
CVSS 4.0 (informational): CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:H/VA:N/SC:N/SI:N/SA:N (8.2)
Both versions rate this High. The severity rating follows CVSS 3.1.

Proof of concept

The forged signature's EMSA-PKCS1-v1_5 block (signature^e mod n, 2048-bit key, SHA-256) has this shape:

00 01 FF FF FF FF FF FF FF FF 00
30 81 F2                          DigestInfo SEQUENCE
   30 81 CD                       DigestAlgorithm SEQUENCE
      06 09 60 86 48 01 65 03 04 02 01   sha256 OID
      05 00                       NULL parameters
      04 81 BD <189 bytes>        extra element (attacker-chosen bytes)
   04 20 <SHA-256(m)>             digest

Before 1.4.1 the extra element was ignored and publicKey.verify(digest, signature) returned true. For an e=3 key, the 189 free bytes are enough to find a signature whose cube has this form for any message, without the private key. With 1.4.1, verification throws "ASN.1 object does not contain a valid RSASSA-PKCS1-v1_5 DigestInfo value."

Regression tests in tests/unit/rsa.js: "should reject forged nested DigestAlgorithm signature" (a keyless e=3 forgery vector) and, under "canonical DigestInfo checks", "should reject DigestInfo with extra DigestAlgorithm element". Standalone PoC: tests/pocs/GHSA-2g46-22mc-6gwp.js. Both are included in the 1.4.1 release.

Impact

Applications that verify RSASSA-PKCS1-v1_5 signatures with node-forge: publicKey.verify() with the default scheme, and X.509 certificate and PKCS#7 signature verification, which use it. If the verifying RSA public key has a low public exponent (e=3), an attacker can forge a signature for an arbitrary message that verifies as valid, without the private key. Only keys with a small public exponent such as e=3 are practically affected.

Severity

High

CVSS overall score

This score calculates overall vulnerability severity from 0 to 10 and is based on the Common Vulnerability Scoring System (CVSS).
/ 10

CVSS v3 base metrics

Attack vector
Network
Attack complexity
Low
Privileges required
None
User interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
High
Availability
None

CVSS v3 base metrics

Attack vector: More severe the more the remote (logically and physically) an attacker can be in order to exploit the vulnerability.
Attack complexity: More severe for the least complex attacks.
Privileges required: More severe if no privileges are required.
User interaction: More severe when no user interaction is required.
Scope: More severe when a scope change occurs, e.g. one vulnerable component impacts resources in components beyond its security scope.
Confidentiality: More severe when loss of data confidentiality is highest, measuring the level of data access available to an unauthorized user.
Integrity: More severe when loss of data integrity is the highest, measuring the consequence of data modification possible by an unauthorized user.
Availability: More severe when the loss of impacted component availability is highest.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N

CVE ID

CVE-2026-85393

Weaknesses

Improper Verification of Cryptographic Signature

The product does not verify, or incorrectly verifies, the cryptographic signature for data. Learn more on MITRE.

Credits