Tomáš Mráz

A NULL pointer dereference can occur in a CMP client application when processing a crafted CMP response. An attacker controlling a CMP server or acting as a man-in-the-middle can send a CRMF CertRepMessage containing an EncryptedValue structure where the `symmAlg` field includes an algorithm OID but lacks a parameters field. This leads to an application crash and a Denial of Service. This issue affects applications that process untrusted CMP/CRMF messages.

The issue arises from the use of the -addreject option with the openssl x509 application, which adds a trusted use instead of a rejected use for a certificate. This means if a user intends to make a trusted certificate rejected for a particular use, it will be instead marked as trusted for that use. The problem was introduced by a copy & paste error during minor refactoring of the code in the OpenSSL 3.5 version. Only users who use the trusted certificate format and the openssl x509 command line application to add rejected uses are affected.

A timing side-channel in ECDSA signature computations could allow recovering the private key by an attacker. However, measuring the timing would require either local access to the signing application or a very fast network connection with low latency. There is a timing signal of around 300 nanoseconds when the top word of the inverted ECDSA nonce value is `inverted ECDSA nonce value` is zero. This can happen with significant probability only for some of the supported elliptic curves, in particular the NIST P-521 curve. The severity of this vulnerability is Low.

The vulnerability relates to improper validation of PBMAC1 parameters within PKCS#12 files. Specifically, the PBKDF2 salt and keylength parameters are used without sufficient validation during MAC verification. If the `keylength` value exceeds the size of a fixed stack buffer (64 bytes), a stack-based buffer overflow can occur. Additionally, if the `salt` parameter is not an OCTET STRING type, it can lead to an invalid or NULL pointer dereference. Exploitation requires processing a maliciously crafted PKCS#12 file. This can result in a denial of service (DoS) due to application crashes, and potentially enable code execution depending on platform mitigations. The FIPS modules in versions 3.6, 3.5, and 3.4 are not affected, as PKCS#12 processing falls outside the FIPS module boundary. The vulnerability is triggered when verifying a PKCS#12 file that uses PBMAC1 for the MAC. Attackers can deliver a malicious .p12/.pfx file to systems that import or validate PKCS#12 files from external sources.

The issue is related to the functions `EVP PKEY param check()` and `EVP PKEY public check()` in the OpenSSL library, which can lead to a Denial of Service (DoS) attack when checking excessively long DSA keys or parameters. These functions perform various checks on DSA parameters, and some computations can take a long time if the modulus (`p` parameter) is too large. An application that calls these functions and supplies a key or parameters obtained from an untrusted source could be vulnerable to a DoS attack. The OpenSSL SSL/TLS implementation is not affected by this issue.

A NULL pointer can be dereferenced when signatures are being verified on PKCS7 signed or signedAndEnveloped data. This occurs when the hash algorithm used for the signature is known to the OpenSSL library, but the implementation of the hash algorithm is not available, causing the digest initialization to fail. The unavailability of an algorithm can be caused by using FIPS enabled configuration of providers or more commonly by not loading the legacy provider. PKCS7 data is processed by the SMIME library calls and also by the time stamp (TS) library calls. The TLS implementation in OpenSSL does not call these functions; however, third-party applications would be affected if they call these functions to verify signatures on untrusted data.

An invalid pointer dereference on read can be triggered when an application tries to load malformed PKCS7 data with the `d2i PKCS7()`, `d2i PKCS7 bio()`, or `d2i PKCS7 fp()` functions. The result of the dereference is an application crash which could lead to a denial of service attack. The TLS implementation in OpenSSL does not call this function; however, third-party applications might call these functions on untrusted data.