Vulnerabilities

If you think you have found a security bug in OpenSSL, please report it to us.

Show issues fixed only in OpenSSL 3.3, 3.2, 3.1, 3.0, 1.1.1, 1.1.0, 1.0.2, 1.0.1, 1.0.0, 0.9.8, 0.9.7, 0.9.6.

Note: All OpenSSL versions before 1.1.1 are out of support and no longer receiving updates. Extended support is available for 1.0.2 from OpenSSL Software Services for premium support customers.

Jump to year: 2024, 2023, 2022, 2021, 2020, 2019, 2018, 2017, 2016, 2015, 2014, 2013, 2012, 2011, 2010, 2009, 2008, 2007, 2006, 2005, 2004, 2003, 2002.

2024

CVE-2024-9143

Severity

Low

Published at

16 October 2024

Title

Low-level invalid GF(2^m) parameters lead to OOB memory access

Found by

Google OSS-Fuzz-Gen

Fix developed by

Viktor Dukhovni

Affected

from 3.3.0 before 3.3.3
from 3.2.0 before 3.2.4
from 3.1.0 before 3.1.8
from 3.0.0 before 3.0.16
from 1.1.1 before 1.1.1zb
from 1.0.2 before 1.0.2zl

References

Issue summary: Use of the low-level GF(2^m) elliptic curve APIs with untrusted explicit values for the field polynomial can lead to out-of-bounds memory reads or writes.

Impact summary: Out of bound memory writes can lead to an application crash or even a possibility of a remote code execution, however, in all the protocols involving Elliptic Curve Cryptography that we’re aware of, either only “named curves” are supported, or, if explicit curve parameters are supported, they specify an X9.62 encoding of binary (GF(2^m)) curves that can’t represent problematic input values. Thus the likelihood of existence of a vulnerable application is low.

In particular, the X9.62 encoding is used for ECC keys in X.509 certificates, so problematic inputs cannot occur in the context of processing X.509 certificates. Any problematic use-cases would have to be using an “exotic” curve encoding.

The affected APIs include: EC_GROUP_new_curve_GF2m(), EC_GROUP_new_from_params(), and various supporting BN_GF2m_*() functions.

Applications working with “exotic” explicit binary (GF(2^m)) curve parameters, that make it possible to represent invalid field polynomials with a zero constant term, via the above or similar APIs, may terminate abruptly as a result of reading or writing outside of array bounds. Remote code execution cannot easily be ruled out.

The FIPS modules in 3.3, 3.2, 3.1 and 3.0 are not affected by this issue.

CVE-2024-6119

Severity

Moderate

Published at

3 September 2024

Title

Possible denial of service in X.509 name checks

Found by

David Benjamin (Google)

Fix developed by

Viktor Dukhovni

Affected

from 3.3.0 before 3.3.2
from 3.2.0 before 3.2.3
from 3.1.0 before 3.1.7
from 3.0.0 before 3.0.15

References

Issue summary: Applications performing certificate name checks (e.g., TLS clients checking server certificates) may attempt to read an invalid memory address resulting in abnormal termination of the application process.

Impact summary: Abnormal termination of an application can a cause a denial of service.

Applications performing certificate name checks (e.g., TLS clients checking server certificates) may attempt to read an invalid memory address when comparing the expected name with an otherName subject alternative name of an X.509 certificate. This may result in an exception that terminates the application program.

Note that basic certificate chain validation (signatures, dates, …) is not affected, the denial of service can occur only when the application also specifies an expected DNS name, Email address or IP address.

TLS servers rarely solicit client certificates, and even when they do, they generally don’t perform a name check against a reference identifier (expected identity), but rather extract the presented identity after checking the certificate chain. So TLS servers are generally not affected and the severity of the issue is Moderate.

The FIPS modules in 3.3, 3.2, 3.1 and 3.0 are not affected by this issue.

CVE-2024-5535

Severity

Low

Published at

26 June 2024

Title

SSL_select_next_proto buffer overread

Found by

Joseph Birr-Pixton

Fix developed by

Matt Caswell

Affected

from 3.3.0 before 3.3.2
from 3.2.0 before 3.2.3
from 3.1.0 before 3.1.7
from 3.0.0 before 3.0.15
from 1.1.1 before 1.1.1za
from 1.0.2 before 1.0.2zk

References

Issue summary: Calling the OpenSSL API function SSL_select_next_proto with an empty supported client protocols buffer may cause a crash or memory contents to be sent to the peer.

Impact summary: A buffer overread can have a range of potential consequences such as unexpected application beahviour or a crash. In particular this issue could result in up to 255 bytes of arbitrary private data from memory being sent to the peer leading to a loss of confidentiality. However, only applications that directly call the SSL_select_next_proto function with a 0 length list of supported client protocols are affected by this issue. This would normally never be a valid scenario and is typically not under attacker control but may occur by accident in the case of a configuration or programming error in the calling application.

The OpenSSL API function SSL_select_next_proto is typically used by TLS applications that support ALPN (Application Layer Protocol Negotiation) or NPN (Next Protocol Negotiation). NPN is older, was never standardised and is deprecated in favour of ALPN. We believe that ALPN is significantly more widely deployed than NPN. The SSL_select_next_proto function accepts a list of protocols from the server and a list of protocols from the client and returns the first protocol that appears in the server list that also appears in the client list. In the case of no overlap between the two lists it returns the first item in the client list. In either case it will signal whether an overlap between the two lists was found. In the case where SSL_select_next_proto is called with a zero length client list it fails to notice this condition and returns the memory immediately following the client list pointer (and reports that there was no overlap in the lists).

This function is typically called from a server side application callback for ALPN or a client side application callback for NPN. In the case of ALPN the list of protocols supplied by the client is guaranteed by libssl to never be zero in length. The list of server protocols comes from the application and should never normally be expected to be of zero length. In this case if the SSL_select_next_proto function has been called as expected (with the list supplied by the client passed in the client/client_len parameters), then the application will not be vulnerable to this issue. If the application has accidentally been configured with a zero length server list, and has accidentally passed that zero length server list in the client/client_len parameters, and has additionally failed to correctly handle a “no overlap” response (which would normally result in a handshake failure in ALPN) then it will be vulnerable to this problem.

In the case of NPN, the protocol permits the client to opportunistically select a protocol when there is no overlap. OpenSSL returns the first client protocol in the no overlap case in support of this. The list of client protocols comes from the application and should never normally be expected to be of zero length. However if the SSL_select_next_proto function is accidentally called with a client_len of 0 then an invalid memory pointer will be returned instead. If the application uses this output as the opportunistic protocol then the loss of confidentiality will occur.

This issue has been assessed as Low severity because applications are most likely to be vulnerable if they are using NPN instead of ALPN - but NPN is not widely used. It also requires an application configuration or programming error. Finally, this issue would not typically be under attacker control making active exploitation unlikely.

The FIPS modules in 3.3, 3.2, 3.1 and 3.0 are not affected by this issue.

Due to the low severity of this issue we are not issuing new releases of OpenSSL at this time. The fix will be included in the next releases when they become available.

CVE-2024-4741

Severity

Low

Published at

27 May 2024

Title

Use After Free with SSL_free_buffers

Found by

William Ahern (Akamai)

Fix developed by

Matt Caswell

Affected

from 3.3.0 before 3.3.1
from 3.2.0 before 3.2.2
from 3.1.0 before 3.1.6
from 3.0.0 before 3.0.14
from 1.1.1 before 1.1.1y

References

Issue summary: Calling the OpenSSL API function SSL_free_buffers may cause memory to be accessed that was previously freed in some situations

Impact summary: A use after free can have a range of potential consequences such as the corruption of valid data, crashes or execution of arbitrary code. However, only applications that directly call the SSL_free_buffers function are affected by this issue. Applications that do not call this function are not vulnerable. Our investigations indicate that this function is rarely used by applications.

The SSL_free_buffers function is used to free the internal OpenSSL buffer used when processing an incoming record from the network. The call is only expected to succeed if the buffer is not currently in use. However, two scenarios have been identified where the buffer is freed even when still in use.

The first scenario occurs where a record header has been received from the network and processed by OpenSSL, but the full record body has not yet arrived. In this case calling SSL_free_buffers will succeed even though a record has only been partially processed and the buffer is still in use.

The second scenario occurs where a full record containing application data has been received and processed by OpenSSL but the application has only read part of this data. Again a call to SSL_free_buffers will succeed even though the buffer is still in use.

While these scenarios could occur accidentally during normal operation a malicious attacker could attempt to engineer a stituation where this occurs. We are not aware of this issue being actively exploited.

The FIPS modules in 3.3, 3.2, 3.1 and 3.0 are not affected by this issue.

CVE-2024-4603

Severity

Low

Published at

16 May 2024

Title

Excessive time spent checking DSA keys and parameters

Found by

OSS-Fuzz

Fix developed by

Tomas Mraz

Affected

from 3.0.0 before 3.0.14
from 3.1.0 before 3.1.6
from 3.2.0 before 3.2.2
from 3.3.0 before 3.3.1

References

Issue summary: Checking excessively long DSA keys or parameters may be very slow.

Impact summary: Applications that use the functions EVP_PKEY_param_check() or EVP_PKEY_public_check() to check a DSA public key or DSA parameters may experience long delays. Where the key or parameters that are being checked have been obtained from an untrusted source this may lead to a Denial of Service.

The functions EVP_PKEY_param_check() or EVP_PKEY_public_check() perform various checks on DSA parameters. Some of those computations take a long time if the modulus (p parameter) is too large.

Trying to use a very large modulus is slow and OpenSSL will not allow using public keys with a modulus which is over 10,000 bits in length for signature verification. However the key and parameter check functions do not limit the modulus size when performing the checks.

An application that calls EVP_PKEY_param_check() or EVP_PKEY_public_check() and supplies a key or parameters obtained from an untrusted source could be vulnerable to a Denial of Service attack.

These functions are not called by OpenSSL itself on untrusted DSA keys so only applications that directly call these functions may be vulnerable.

Also vulnerable are the OpenSSL pkey and pkeyparam command line applications when using the -check option.

The OpenSSL SSL/TLS implementation is not affected by this issue.

The OpenSSL 3.0 and 3.1 FIPS providers are affected by this issue.

CVE-2024-2511

Severity

Low

Published at

8 April 2024

Title

Unbounded memory growth with session handling in TLSv1.3

Found by

Manish Patidar (Hewlett Packard Enterprise)

Fix developed by

Matt Caswell

Affected

from 3.2.0 before 3.2.2
from 3.1.0 before 3.1.6
from 3.0.0 before 3.0.14
from 1.1.1 before 1.1.1y

References

Issue summary: Some non-default TLS server configurations can cause unbounded memory growth when processing TLSv1.3 sessions

Impact summary: An attacker may exploit certain server configurations to trigger unbounded memory growth that would lead to a Denial of Service

This problem can occur in TLSv1.3 if the non-default SSL_OP_NO_TICKET option is being used (but not if early_data support is also configured and the default anti-replay protection is in use). In this case, under certain conditions, the session cache can get into an incorrect state and it will fail to flush properly as it fills. The session cache will continue to grow in an unbounded manner. A malicious client could deliberately create the scenario for this failure to force a Denial of Service. It may also happen by accident in normal operation.

This issue only affects TLS servers supporting TLSv1.3. It does not affect TLS clients.

The FIPS modules in 3.2, 3.1 and 3.0 are not affected by this issue. OpenSSL 1.0.2 is also not affected by this issue.

CVE-2024-0727

Severity

Low

Published at

25 January 2024

Title

PKCS12 Decoding crashes

Found by

Bahaa Naamneh (Crosspoint Labs)

Fix developed by

Matt Caswell

Affected

from 3.2.0 before 3.2.1
from 3.1.0 before 3.1.5
from 3.0.0 before 3.0.13
from 1.1.1 before 1.1.1x
from 1.0.2 before 1.0.2zj

References

Issue summary: Processing a maliciously formatted PKCS12 file may lead OpenSSL to crash leading to a potential Denial of Service attack

Impact summary: Applications loading files in the PKCS12 format from untrusted sources might terminate abruptly.

A file in PKCS12 format can contain certificates and keys and may come from an untrusted source. The PKCS12 specification allows certain fields to be NULL, but OpenSSL does not correctly check for this case. This can lead to a NULL pointer dereference that results in OpenSSL crashing. If an application processes PKCS12 files from an untrusted source using the OpenSSL APIs then that application will be vulnerable to this issue.

OpenSSL APIs that are vulnerable to this are: PKCS12_parse(), PKCS12_unpack_p7data(), PKCS12_unpack_p7encdata(), PKCS12_unpack_authsafes() and PKCS12_newpass().

We have also fixed a similar issue in SMIME_write_PKCS7(). However since this function is related to writing data we do not consider it security significant.

The FIPS modules in 3.2, 3.1 and 3.0 are not affected by this issue.

CVE-2023-6237

Severity

Low

Published at

15 January 2024

Title

Excessive time spent checking invalid RSA public keys

Found by

OSS-Fuzz

Fix developed by

Tomas Mraz

Affected

from 3.0.0 before 3.0.13
from 3.1.0 before 3.1.5
from 3.2.0 before 3.2.1

References

Issue summary: Checking excessively long invalid RSA public keys may take a long time.

Impact summary: Applications that use the function EVP_PKEY_public_check() to check RSA public keys may experience long delays. Where the key that is being checked has been obtained from an untrusted source this may lead to a Denial of Service.

When function EVP_PKEY_public_check() is called on RSA public keys, a computation is done to confirm that the RSA modulus, n, is composite. For valid RSA keys, n is a product of two or more large primes and this computation completes quickly. However, if n is an overly large prime, then this computation would take a long time.

An application that calls EVP_PKEY_public_check() and supplies an RSA key obtained from an untrusted source could be vulnerable to a Denial of Service attack.

The function EVP_PKEY_public_check() is not called from other OpenSSL functions however it is called from the OpenSSL pkey command line application. For that reason that application is also vulnerable if used with the ‘-pubin’ and ‘-check’ options on untrusted data.

The OpenSSL SSL/TLS implementation is not affected by this issue.

The OpenSSL 3.0 and 3.1 FIPS providers are affected by this issue.

CVE-2023-6129

Severity

Low

Published at

9 January 2024

Title

POLY1305 MAC implementation corrupts vector registers on PowerPC

Found by

Sverker Eriksson

Fix developed by

Rohan McLure

Affected

from 3.2.0 before 3.2.1
from 3.1.0 before 3.1.5
from 3.0.0 before 3.0.13

References

Issue summary: The POLY1305 MAC (message authentication code) implementation contains a bug that might corrupt the internal state of applications running on PowerPC CPU based platforms if the CPU provides vector instructions.

Impact summary: If an attacker can influence whether the POLY1305 MAC algorithm is used, the application state might be corrupted with various application dependent consequences.

The POLY1305 MAC (message authentication code) implementation in OpenSSL for PowerPC CPUs restores the contents of vector registers in a different order than they are saved. Thus the contents of some of these vector registers are corrupted when returning to the caller. The vulnerable code is used only on newer PowerPC processors supporting the PowerISA 2.07 instructions.

The consequences of this kind of internal application state corruption can be various - from no consequences, if the calling application does not depend on the contents of non-volatile XMM registers at all, to the worst consequences, where the attacker could get complete control of the application process. However unless the compiler uses the vector registers for storing pointers, the most likely consequence, if any, would be an incorrect result of some application dependent calculations or a crash leading to a denial of service.

The POLY1305 MAC algorithm is most frequently used as part of the CHACHA20-POLY1305 AEAD (authenticated encryption with associated data) algorithm. The most common usage of this AEAD cipher is with TLS protocol versions 1.2 and 1.3. If this cipher is enabled on the server a malicious client can influence whether this AEAD cipher is used. This implies that TLS server applications using OpenSSL can be potentially impacted. However we are currently not aware of any concrete application that would be affected by this issue therefore we consider this a Low severity security issue.

2023

CVE-2023-5678

Severity

LOW

Published at

6 November 2023

Title

Excessive time spent in DH check / generation with large Q parameter value

Found by

David Benjamin (Google)

Fix developed by

Richard Levitte

Affected

from 1.0.2 before 1.0.2zj
from 1.1.1 before 1.1.1x
from 3.0.0 before 3.0.13
from 3.1.0 before 3.1.5

References

Issue summary: Generating excessively long X9.42 DH keys or checking excessively long X9.42 DH keys or parameters may be very slow.

Impact summary: Applications that use the functions DH_generate_key() to generate an X9.42 DH key may experience long delays. Likewise, applications that use DH_check_pub_key(), DH_check_pub_key_ex() or EVP_PKEY_public_check() to check an X9.42 DH key or X9.42 DH parameters may experience long delays. Where the key or parameters that are being checked have been obtained from an untrusted source this may lead to a Denial of Service.

While DH_check() performs all the necessary checks (as of CVE-2023-3817), DH_check_pub_key() doesn’t make any of these checks, and is therefore vulnerable for excessively large P and Q parameters.

Likewise, while DH_generate_key() performs a check for an excessively large P, it doesn’t check for an excessively large Q.

An application that calls DH_generate_key() or DH_check_pub_key() and supplies a key or parameters obtained from an untrusted source could be vulnerable to a Denial of Service attack.

DH_generate_key() and DH_check_pub_key() are also called by a number of other OpenSSL functions. An application calling any of those other functions may similarly be affected. The other functions affected by this are DH_check_pub_key_ex(), EVP_PKEY_public_check(), and EVP_PKEY_generate().

Also vulnerable are the OpenSSL pkey command line application when using the “-pubcheck” option, as well as the OpenSSL genpkey command line application.

The OpenSSL SSL/TLS implementation is not affected by this issue.

The OpenSSL 3.0 and 3.1 FIPS providers are not affected by this issue.

CVE-2023-5363

Severity

MODERATE

Published at

24 October 2023

Title

Incorrect cipher key & IV length processing

Found by

Tony Battersby (Cybernetics)

Fix developed by

Dr Paul Dale

Affected

from 3.0.0 before 3.0.12
from 3.1.0 before 3.1.4

References

Issue summary: A bug has been identified in the processing of key and initialisation vector (IV) lengths. This can lead to potential truncation or overruns during the initialisation of some symmetric ciphers.

Impact summary: A truncation in the IV can result in non-uniqueness, which could result in loss of confidentiality for some cipher modes.

When calling EVP_EncryptInit_ex2(), EVP_DecryptInit_ex2() or EVP_CipherInit_ex2() the provided OSSL_PARAM array is processed after the key and IV have been established. Any alterations to the key length, via the “keylen” parameter or the IV length, via the “ivlen” parameter, within the OSSL_PARAM array will not take effect as intended, potentially causing truncation or overreading of these values. The following ciphers and cipher modes are impacted: RC2, RC4, RC5, CCM, GCM and OCB.

For the CCM, GCM and OCB cipher modes, truncation of the IV can result in loss of confidentiality. For example, when following NIST’s SP 800-38D section 8.2.1 guidance for constructing a deterministic IV for AES in GCM mode, truncation of the counter portion could lead to IV reuse.

Both truncations and overruns of the key and overruns of the IV will produce incorrect results and could, in some cases, trigger a memory exception. However, these issues are not currently assessed as security critical.

Changing the key and/or IV lengths is not considered to be a common operation and the vulnerable API was recently introduced. Furthermore it is likely that application developers will have spotted this problem during testing since decryption would fail unless both peers in the communication were similarly vulnerable. For these reasons we expect the probability of an application being vulnerable to this to be quite low. However if an application is vulnerable then this issue is considered very serious. For these reasons we have assessed this issue as Moderate severity overall.

The OpenSSL SSL/TLS implementation is not affected by this issue.

The OpenSSL 3.0 and 3.1 FIPS providers are not affected by this because the issue lies outside of the FIPS provider boundary.

OpenSSL 3.1 and 3.0 are vulnerable to this issue.

CVE-2023-4807

Severity

Low

Published at

8 September 2023

Title

POLY1305 MAC implementation corrupts XMM registers on Windows

Found by

Zach Wilson

Fix developed by

Bernd Edlinger

Affected

from 3.1.0 before 3.1.3
from 3.0.0 before 3.0.11
from 1.1.1 before 1.1.1w

References

Issue summary: The POLY1305 MAC (message authentication code) implementation contains a bug that might corrupt the internal state of applications on the Windows 64 platform when running on newer X86_64 processors supporting the AVX512-IFMA instructions.

Impact summary: If in an application that uses the OpenSSL library an attacker can influence whether the POLY1305 MAC algorithm is used, the application state might be corrupted with various application dependent consequences.

The POLY1305 MAC (message authentication code) implementation in OpenSSL does not save the contents of non-volatile XMM registers on Windows 64 platform when calculating the MAC of data larger than 64 bytes. Before returning to the caller all the XMM registers are set to zero rather than restoring their previous content. The vulnerable code is used only on newer x86_64 processors supporting the AVX512-IFMA instructions.

The consequences of this kind of internal application state corruption can be various - from no consequences, if the calling application does not depend on the contents of non-volatile XMM registers at all, to the worst consequences, where the attacker could get complete control of the application process. However given the contents of the registers are just zeroized so the attacker cannot put arbitrary values inside, the most likely consequence, if any, would be an incorrect result of some application dependent calculations or a crash leading to a denial of service.

The POLY1305 MAC algorithm is most frequently used as part of the CHACHA20-POLY1305 AEAD (authenticated encryption with associated data) algorithm. The most common usage of this AEAD cipher is with TLS protocol versions 1.2 and 1.3 and a malicious client can influence whether this AEAD cipher is used by the server. This implies that server applications using OpenSSL can be potentially impacted. However we are currently not aware of any concrete application that would be affected by this issue therefore we consider this a Low severity security issue.

As a workaround the AVX512-IFMA instructions support can be disabled at runtime by setting the environment variable OPENSSL_ia32cap:

OPENSSL_ia32cap=:~0x200000

The FIPS provider is not affected by this issue.

CVE-2023-3817

Severity

Low

Published at

31 July 2023

Title

Excessive time spent checking DH q parameter value

Found by

Bernd Edlinger

Fix developed by

Tomas Mraz

Affected

from 3.1.0 before 3.1.2
from 3.0.0 before 3.0.10
from 1.1.1 before 1.1.1v
from 1.0.2 before 1.0.2zi

References

Issue summary: Checking excessively long DH keys or parameters may be very slow.

Impact summary: Applications that use the functions DH_check(), DH_check_ex() or EVP_PKEY_param_check() to check a DH key or DH parameters may experience long delays. Where the key or parameters that are being checked have been obtained from an untrusted source this may lead to a Denial of Service.

The function DH_check() performs various checks on DH parameters. After fixing CVE-2023-3446 it was discovered that a large q parameter value can also trigger an overly long computation during some of these checks. A correct q value, if present, cannot be larger than the modulus p parameter, thus it is unnecessary to perform these checks if q is larger than p.

An application that calls DH_check() and supplies a key or parameters obtained from an untrusted source could be vulnerable to a Denial of Service attack.

The function DH_check() is itself called by a number of other OpenSSL functions. An application calling any of those other functions may similarly be affected. The other functions affected by this are DH_check_ex() and EVP_PKEY_param_check().

Also vulnerable are the OpenSSL dhparam and pkeyparam command line applications when using the “-check” option.

The OpenSSL SSL/TLS implementation is not affected by this issue.

The OpenSSL 3.0 and 3.1 FIPS providers are not affected by this issue.

CVE-2023-3446

Severity

Low

Published at

13 July 2023

Title

Excessive time spent checking DH keys and parameters

Fix developed by

Matt Caswell

Affected

from 3.1.0 before 3.1.2
from 3.0.0 before 3.0.10
from 1.1.1 before 1.1.1v
from 1.0.2 before 1.0.2zi

References

Issue summary: Checking excessively long DH keys or parameters may be very slow.

The function DH_check() performs various checks on DH parameters. One of those checks confirms that the modulus (‘p’ parameter) is not too large. Trying to use a very large modulus is slow and OpenSSL will not normally use a modulus which is over 10,000 bits in length.

However the DH_check() function checks numerous aspects of the key or parameters that have been supplied. Some of those checks use the supplied modulus value even if it has already been found to be too large.

An application that calls DH_check() and supplies a key or parameters obtained from an untrusted source could be vulernable to a Denial of Service attack.

Also vulnerable are the OpenSSL dhparam and pkeyparam command line applications when using the ‘-check’ option.

The OpenSSL SSL/TLS implementation is not affected by this issue. The OpenSSL 3.0 and 3.1 FIPS providers are not affected by this issue.

CVE-2023-2975

Severity

Low

Published at

7 July 2023

Title

AES-SIV implementation ignores empty associated data entries

Fix developed by

Tomas Mraz

Affected

from 3.1.0 before 3.1.2
from 3.0.0 before 3.0.10

References

Issue summary: The AES-SIV cipher implementation contains a bug that causes it to ignore empty associated data entries which are unauthenticated as a consequence.

Impact summary: Applications that use the AES-SIV algorithm and want to authenticate empty data entries as associated data can be misled by removing, adding or reordering such empty entries as these are ignored by the OpenSSL implementation. We are currently unaware of any such applications.

The AES-SIV algorithm allows for authentication of multiple associated data entries along with the encryption. To authenticate empty data the application has to call EVP_EncryptUpdate() (or EVP_CipherUpdate()) with NULL pointer as the output buffer and 0 as the input buffer length. The AES-SIV implementation in OpenSSL just returns success for such a call instead of performing the associated data authentication operation. The empty data thus will not be authenticated.

As this issue does not affect non-empty associated data authentication and we expect it to be rare for an application to use empty associated data entries this is qualified as Low severity issue.

CVE-2023-2650

Severity

Moderate

Published at

30 May 2023

Title

Possible DoS translating ASN.1 object identifiers

Fix developed by

Richard Levitte

Affected

from 3.1.1 before 3.1.1
from 3.0.0 before 3.0.9
from 1.1.1 before 1.1.1u
from 1.0.2 before 1.0.2zh

References

Issue summary: Processing some specially crafted ASN.1 object identifiers or data containing them may be very slow.

Impact summary: Applications that use OBJ_obj2txt() directly, or use any of the OpenSSL subsystems OCSP, PKCS7/SMIME, CMS, CMP/CRMF or TS with no message size limit may experience notable to very long delays when processing those messages, which may lead to a Denial of Service.

An OBJECT IDENTIFIER is composed of a series of numbers - sub-identifiers - most of which have no size limit. OBJ_obj2txt() may be used to translate an ASN.1 OBJECT IDENTIFIER given in DER encoding form (using the OpenSSL type ASN1_OBJECT) to its canonical numeric text form, which are the sub-identifiers of the OBJECT IDENTIFIER in decimal form, separated by periods.

When one of the sub-identifiers in the OBJECT IDENTIFIER is very large (these are sizes that are seen as absurdly large, taking up tens or hundreds of KiBs), the translation to a decimal number in text may take a very long time. The time complexity is O(n^2) with ’n’ being the size of the sub-identifiers in bytes (*).

With OpenSSL 3.0, support to fetch cryptographic algorithms using names / identifiers in string form was introduced. This includes using OBJECT IDENTIFIERs in canonical numeric text form as identifiers for fetching algorithms.

Such OBJECT IDENTIFIERs may be received through the ASN.1 structure AlgorithmIdentifier, which is commonly used in multiple protocols to specify what cryptographic algorithm should be used to sign or verify, encrypt or decrypt, or digest passed data.

Applications that call OBJ_obj2txt() directly with untrusted data are affected, with any version of OpenSSL. If the use is for the mere purpose of display, the severity is considered low.

In OpenSSL 3.0 and newer, this affects the subsystems OCSP, PKCS7/SMIME, CMS, CMP/CRMF or TS. It also impacts anything that processes X.509 certificates, including simple things like verifying its signature.

The impact on TLS is relatively low, because all versions of OpenSSL have a 100KiB limit on the peer’s certificate chain. Additionally, this only impacts clients, or servers that have explicitly enabled client authentication.

In OpenSSL 1.1.1 and 1.0.2, this only affects displaying diverse objects, such as X.509 certificates. This is assumed to not happen in such a way that it would cause a Denial of Service, so these versions are considered not affected by this issue in such a way that it would be cause for concern, and the severity is therefore considered low.

CVE-2023-1255

Severity

Low

Published at

21 March 2023

Title

Input buffer over-read in AES-XTS implementation on 64 bit ARM

Fix developed by

Nevine Ebeid (Amazon)

Affected

from 3.1.0 before 3.1.1
from 3.0.0 before 3.0.9

References

Issue summary: The AES-XTS cipher decryption implementation for 64 bit ARM platform contains a bug that could cause it to read past the input buffer, leading to a crash.

Impact summary: Applications that use the AES-XTS algorithm on the 64 bit ARM platform can crash in rare circumstances. The AES-XTS algorithm is usually used for disk encryption.

The AES-XTS cipher decryption implementation for 64 bit ARM platform will read past the end of the ciphertext buffer if the ciphertext size is 4 mod 5 in 16 byte blocks, e.g. 144 bytes or 1024 bytes. If the memory after the ciphertext buffer is unmapped, this will trigger a crash which results in a denial of service.

If an attacker can control the size and location of the ciphertext buffer being decrypted by an application using AES-XTS on 64 bit ARM, the application is affected. This is fairly unlikely making this issue a Low severity one.

CVE-2023-0466

Severity

Low

Published at

21 March 2023

Title

Certificate policy check not enabled

Fix developed by

Tomas Mraz

Affected

from 3.1.0 before 3.1.1
from 3.0.0 before 3.0.9
from 1.1.1 before 1.1.1u
from 1.0.2 before 1.0.2zh

References

The function X509_VERIFY_PARAM_add0_policy() is documented to implicitly enable the certificate policy check when doing certificate verification. However the implementation of the function does not enable the check which allows certificates with invalid or incorrect policies to pass the certificate verification.

As suddenly enabling the policy check could break existing deployments it was decided to keep the existing behavior of the X509_VERIFY_PARAM_add0_policy() function.

Instead the applications that require OpenSSL to perform certificate policy check need to use X509_VERIFY_PARAM_set1_policies() or explicitly enable the policy check by calling X509_VERIFY_PARAM_set_flags() with the X509_V_FLAG_POLICY_CHECK flag argument.

Certificate policy checks are disabled by default in OpenSSL and are not commonly used by applications.

CVE-2023-0465

Severity

Low

Published at

23 March 2023

Title

Invalid certificate policies in leaf certificates are silently ignored

Fix developed by

Matt Caswell

Affected

from 3.1.0 before 3.1.1
from 3.0.0 before 3.0.9
from 1.1.1 before 1.1.1u
from 1.0.2 before 1.0.2zh

References

Applications that use a non-default option when verifying certificates may be vulnerable to an attack from a malicious CA to circumvent certain checks.

Invalid certificate policies in leaf certificates are silently ignored by OpenSSL and other certificate policy checks are skipped for that certificate. A malicious CA could use this to deliberately assert invalid certificate policies in order to circumvent policy checking on the certificate altogether.

Policy processing is disabled by default but can be enabled by passing the -policy argument to the command line utilities or by calling the X509_VERIFY_PARAM_set1_policies() function.

CVE-2023-0464

Severity

Low

Published at

21 March 2023

Title

Excessive Resource Usage Verifying X.509 Policy Constraints

Fix developed by

Dr Paul Dale

Affected

from 3.1.0 before 3.1.1
from 3.0.0 before 3.0.9
from 1.1.1 before 1.1.1u
from 1.0.2 before 1.0.2zh

References

A security vulnerability has been identified in all supported versions

of OpenSSL related to the verification of X.509 certificate chains that include policy constraints. Attackers may be able to exploit this vulnerability by creating a malicious certificate chain that triggers exponential use of computational resources, leading to a denial-of-service (DoS) attack on affected systems.

Policy processing is disabled by default but can be enabled by passing the -policy argument to the command line utilities or by calling the X509_VERIFY_PARAM_set1_policies() function.

CVE-2023-0401

Severity

Moderate

Published at

7 February 2023

Title

NULL dereference during PKCS7 data verification

Fix developed by

Tomáš Mráz

Affected

from 3.0.0 before 3.0.8

References

A NULL pointer can be dereferenced when signatures are being verified on PKCS7 signed or signedAndEnveloped data. In case the hash algorithm used for the signature is known to the OpenSSL library but the implementation of the hash algorithm is not available the digest initialization will fail. There is a missing check for the return value from the initialization function which later leads to invalid usage of the digest API most likely leading to a crash.

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.

CVE-2023-0286

Severity

High

Published at

7 February 2023

Title

X.400 address type confusion in X.509 GeneralName

Fix developed by

Hugo Landau

Affected

from 3.0.0 before 3.0.8
from 1.1.1 before 1.1.1t
from 1.0.2 before 1.0.2zg

References

There is a type confusion vulnerability relating to X.400 address processing inside an X.509 GeneralName. X.400 addresses were parsed as an ASN1_STRING but the public structure definition for GENERAL_NAME incorrectly specified the type of the x400Address field as ASN1_TYPE. This field is subsequently interpreted by the OpenSSL function GENERAL_NAME_cmp as an ASN1_TYPE rather than an ASN1_STRING.

When CRL checking is enabled (i.e. the application sets the X509_V_FLAG_CRL_CHECK flag), this vulnerability may allow an attacker to pass arbitrary pointers to a memcmp call, enabling them to read memory contents or enact a denial of service. In most cases, the attack requires the attacker to provide both the certificate chain and CRL, neither of which need to have a valid signature. If the attacker only controls one of these inputs, the other input must already contain an X.400 address as a CRL distribution point, which is uncommon. As such, this vulnerability is most likely to only affect applications which have implemented their own functionality for retrieving CRLs over a network.

CVE-2023-0217

Severity

Moderate

Published at

7 February 2023

Title

NULL dereference validating DSA public key

Fix developed by

Shane Lontis from Oracle

Affected

from 3.0.0 before 3.0.8

References

An invalid pointer dereference on read can be triggered when an application tries to check a malformed DSA public key by the EVP_PKEY_public_check() function. This will most likely lead to an application crash. This function can be called on public keys supplied from untrusted sources which could allow an attacker to cause a denial of service attack.

The TLS implementation in OpenSSL does not call this function but applications might call the function if there are additional security requirements imposed by standards such as FIPS 140-3.

CVE-2023-0216

Severity

Moderate

Published at

7 February 2023

Title

Invalid pointer dereference in d2i_PKCS7 functions

Fix developed by

Tomáš Mráz

Affected

from 3.0.0 before 3.0.8

References

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.

CVE-2023-0215

Severity

Moderate

Published at

7 February 2023

Title

Use-after-free following BIO_new_NDEF

Fix developed by

Viktor Dukhovni

Affected

from 3.0.0 before 3.0.8
from 1.1.1 before 1.1.1t
from 1.0.2 before 1.0.2zg

References

The public API function BIO_new_NDEF is a helper function used for streaming ASN.1 data via a BIO. It is primarily used internally to OpenSSL to support the SMIME, CMS and PKCS7 streaming capabilities, but may also be called directly by end user applications.

The function receives a BIO from the caller, prepends a new BIO_f_asn1 filter BIO onto the front of it to form a BIO chain, and then returns the new head of the BIO chain to the caller. Under certain conditions, for example if a CMS recipient public key is invalid, the new filter BIO is freed and the function returns a NULL result indicating a failure. However, in this case, the BIO chain is not properly cleaned up and the BIO passed by the caller still retains internal pointers to the previously freed filter BIO. If the caller then goes on to call BIO_pop() on the BIO then a use-after-free will occur. This will most likely result in a crash.

This scenario occurs directly in the internal function B64_write_ASN1() which may cause BIO_new_NDEF() to be called and will subsequently call BIO_pop() on the BIO. This internal function is in turn called by the public API functions PEM_write_bio_ASN1_stream, PEM_write_bio_CMS_stream, PEM_write_bio_PKCS7_stream, SMIME_write_ASN1, SMIME_write_CMS and SMIME_write_PKCS7.

Other public API functions that may be impacted by this include i2d_ASN1_bio_stream, BIO_new_CMS, BIO_new_PKCS7, i2d_CMS_bio_stream and i2d_PKCS7_bio_stream.

The OpenSSL cms and smime command line applications are similarly affected.

CVE-2022-4450

Severity

Moderate

Published at

7 February 2023

Title

Double free after calling PEM_read_bio_ex

Found by

CarpetFuzz

Fix developed by

Kurt Roeckx

Affected

from 3.0.0 before 3.0.8
from 1.1.1 before 1.1.1t

References

The function PEM_read_bio_ex() reads a PEM file from a BIO and parses and decodes the “name” (e.g. “CERTIFICATE”), any header data and the payload data. If the function succeeds then the “name_out”, “header” and “data” arguments are populated with pointers to buffers containing the relevant decoded data. The caller is responsible for freeing those buffers. It is possible to construct a PEM file that results in 0 bytes of payload data. In this case PEM_read_bio_ex() will return a failure code but will populate the header argument with a pointer to a buffer that has already been freed. If the caller also frees this buffer then a double free will occur. This will most likely lead to a crash. This could be exploited by an attacker who has the ability to supply malicious PEM files for parsing to achieve a denial of service attack.

The functions PEM_read_bio() and PEM_read() are simple wrappers around PEM_read_bio_ex() and therefore these functions are also directly affected.

These functions are also called indirectly by a number of other OpenSSL functions including PEM_X509_INFO_read_bio_ex() and SSL_CTX_use_serverinfo_file() which are also vulnerable. Some OpenSSL internal uses of these functions are not vulnerable because the caller does not free the header argument if PEM_read_bio_ex() returns a failure code. These locations include the PEM_read_bio_TYPE() functions as well as the decoders introduced in OpenSSL 3.0.

The OpenSSL asn1parse command line application is also impacted by this issue.

CVE-2022-4304

Severity

Moderate

Published at

7 February 2023

Title

Timing Oracle in RSA Decryption

Found by

Hubert Kario from Red Hat

Fix developed by

Dmitry Belyavsky from Red Hat

Affected

from 3.0.0 before 3.0.8
from 1.1.1 before 1.1.1t
from 1.0.2 before 1.0.2zg

References

A timing based side channel exists in the OpenSSL RSA Decryption implementation which could be sufficient to recover a plaintext across a network in a Bleichenbacher style attack. To achieve a successful decryption an attacker would have to be able to send a very large number of trial messages for decryption. The vulnerability affects all RSA padding modes: PKCS#1 v1.5, RSA-OEAP and RSASVE.

For example, in a TLS connection, RSA is commonly used by a client to send an encrypted pre-master secret to the server. An attacker that had observed a genuine connection between a client and a server could use this flaw to send trial messages to the server and record the time taken to process them. After a sufficiently large number of messages the attacker could recover the pre-master secret used for the original connection and thus be able to decrypt the application data sent over that connection.

CVE-2022-4203

Severity

Moderate

Published at

7 February 2023

Title

X.509 Name Constraints Read Buffer Overflow

Found by

Corey Bonnell from Digicert

Fix developed by

Viktor Dukhovni

Affected

from 3.0.0 before 3.0.8

References

A read buffer overrun can be triggered in X.509 certificate verification, specifically in name constraint checking. Note that this occurs after certificate chain signature verification and requires either a CA to have signed the malicious certificate or for the application to continue certificate verification despite failure to construct a path to a trusted issuer.

The read buffer overrun might result in a crash which could lead to a denial of service attack. In theory it could also result in the disclosure of private memory contents (such as private keys, or sensitive plaintext) although we are not aware of any working exploit leading to memory contents disclosure as of the time of release of this advisory.

In a TLS client, this can be triggered by connecting to a malicious server. In a TLS server, this can be triggered if the server requests client authentication and a malicious client connects.

2022

CVE-2022-3996

Severity

Low

Published at

13 December 2022

Title

X.509 Policy Constraints Double Locking

Found by

Polar Bear

Fix developed by

Paul Dale

Affected

from 3.0.0 before

References

If an X.509 certificate contains a malformed policy constraint and policy processing is enabled, then a write lock will be taken twice recursively. On some operating systems (most widely: Windows) this results in a denial of service when the affected process hangs. Policy processing being enabled on a publicly facing server is not considered to be a common setup.

Policy processing is enabled by passing the -policy argument to the command line utilities or by calling the X509_VERIFY_PARAM_set1_policies() function.

Update (31 March 2023): The description of the policy processing enablement was corrected based on CVE-2023-0466.

CVE-2022-3786

Severity

High

Published at

1 November 2022

Title

X.509 Email Address Variable Length Buffer Overflow

Found by

Viktor Dukhovni

Affected

from 3.0.0 before 3.0.7

References

CVE-2022-3602

Severity

High

Published at

1 November 2022

Title

X.509 Email Address 4-byte Buffer Overflow

Found by

Polar Bear

Affected

from 3.0.0 before 3.0.7

References

A buffer overrun can be triggered in X.509 certificate verification, specifically in name constraint checking. Note that this occurs after certificate chain signature verification and requires either a CA to have signed the malicious certificate or for the application to continue certificate verification despite failure to construct a path to a trusted issuer. An attacker can craft a malicious email address to overflow four attacker-controlled bytes on the stack. This buffer overflow could result in a crash (causing a denial of service) or potentially remote code execution. Many platforms implement stack overflow protections which would mitigate against the risk of remote code execution. The risk may be further mitigated based on stack layout for any given platform/compiler. Pre-announcements of CVE-2022-3602 described this issue as CRITICAL. Further analysis based on some of the mitigating factors described above have led this to be downgraded to HIGH. Users are still encouraged to upgrade to a new version as soon as possible. In a TLS client, this can be triggered by connecting to a malicious server. In a TLS server, this can be triggered if the server requests client authentication and a malicious client connects.

CVE-2022-3358

Severity

Low

Published at

29 September 2022

Title

Using a Custom Cipher with NID_undef may lead to NULL encryption

Found by

Chris Rapier (Pittsburgh Supercomputing Center)

Affected

from 3.0.0 before 3.0.6

References

OpenSSL supports creating a custom cipher via the legacy EVP_CIPHER_meth_new() function and associated function calls. This function was deprecated in OpenSSL 3.0 and application authors are instead encouraged to use the new provider mechanism in order to implement custom ciphers. OpenSSL versions 3.0.0 to 3.0.5 incorrectly handle legacy custom ciphers passed to the EVP_EncryptInit_ex2(), EVP_DecryptInit_ex2() and EVP_CipherInit_ex2() functions (as well as other similarly named encryption and decryption initialisation functions). Instead of using the custom cipher directly it incorrectly tries to fetch an equivalent cipher from the available providers. An equivalent cipher is found based on the NID passed to EVP_CIPHER_meth_new(). This NID is supposed to represent the unique NID for a given cipher. However it is possible for an application to incorrectly pass NID_undef as this value in the call to EVP_CIPHER_meth_new(). When NID_undef is used in this way the OpenSSL encryption/decryption initialisation function will match the NULL cipher as being equivalent and will fetch this from the available providers. This will succeed if the default provider has been loaded (or if a third party provider has been loaded that offers this cipher). Using the NULL cipher means that the plaintext is emitted as the ciphertext. Applications are only affected by this issue if they call EVP_CIPHER_meth_new() using NID_undef and subsequently use it in a call to an encryption/decryption initialisation function. Applications that only use SSL/TLS are not impacted by this issue.

CVE-2022-2274

Severity

High

Published at

5 July 2022

Title

Bug in RSA implementation for AVX512IFMA capable CPUs

Found by

Xi Ruoyao

Affected

from 3.0.4 before 3.0.5

References

The OpenSSL 3.0.4 release introduced a serious bug in the RSA implementation for X86_64 CPUs supporting the AVX512IFMA instructions. This issue makes the RSA implementation with 2048 bit private keys incorrect on such machines and memory corruption will happen during the computation. As a consequence of the memory corruption an attacker may be able to trigger a remote code execution on the machine performing the computation. SSL/TLS servers or other servers using 2048 bit RSA private keys running on machines supporting AVX512IFMA instructions of the X86_64 architecture are affected by this issue.

CVE-2022-2097

Severity

Moderate

Published at

5 July 2022

Title

AES OCB fails to encrypt some bytes

Found by

Alex Chernyakhovsky

Affected

from 3.0.0 before 3.0.5
from 1.1.1 before 1.1.1q

References

AES OCB mode for 32-bit x86 platforms using the AES-NI assembly optimised implementation will not encrypt the entirety of the data under some circumstances. This could reveal sixteen bytes of data that was preexisting in the memory that wasn’t written. In the special case of “in place” encryption, sixteen bytes of the plaintext would be revealed. Since OpenSSL does not support OCB based cipher suites for TLS and DTLS, they are both unaffected.

CVE-2022-2068

Severity

Moderate

Published at

21 June 2022

Title

The c_rehash script allows command injection

Found by

Chancen (Qingteng 73lab)

Affected

from 3.0.0 before 3.0.4
from 1.1.1 before 1.1.1p
from 1.0.2 before 1.0.2zf

References

In addition to the c_rehash shell command injection identified in CVE-2022-1292, further circumstances where the c_rehash script does not properly sanitise shell metacharacters to prevent command injection were found by code review. When the CVE-2022-1292 was fixed it was not discovered that there are other places in the script where the file names of certificates being hashed were possibly passed to a command executed through the shell. This script is distributed by some operating systems in a manner where it is automatically executed. On such operating systems, an attacker could execute arbitrary commands with the privileges of the script. Use of the c_rehash script is considered obsolete and should be replaced by the OpenSSL rehash command line tool.

CVE-2022-1473

Severity

Low

Published at

3 May 2022

Title

Resource leakage when decoding certificates and keys

Found by

Aliaksei Levin

Affected

from 3.0.0 before 3.0.3

References

The OPENSSL_LH_flush() function, which empties a hash table, contains a bug that breaks reuse of the memory occuppied by the removed hash table entries. This function is used when decoding certificates or keys. If a long lived process periodically decodes certificates or keys its memory usage will expand without bounds and the process might be terminated by the operating system causing a denial of service. Also traversing the empty hash table entries will take increasingly more time. Typically such long lived processes might be TLS clients or TLS servers configured to accept client certificate authentication. The function was added in the OpenSSL 3.0 version thus older releases are not affected by the issue.

CVE-2022-1434

Severity

Low

Published at

3 May 2022

Title

Incorrect MAC key used in the RC4-MD5 ciphersuite

Found by

Tom Colley (Broadcom)

Affected

from 3.0.0 before 3.0.3

References

The OpenSSL 3.0 implementation of the RC4-MD5 ciphersuite incorrectly uses the AAD data as the MAC key. This makes the MAC key trivially predictable. An attacker could exploit this issue by performing a man-in-the-middle attack to modify data being sent from one endpoint to an OpenSSL 3.0 recipient such that the modified data would still pass the MAC integrity check. Note that data sent from an OpenSSL 3.0 endpoint to a non-OpenSSL 3.0 endpoint will always be rejected by the recipient and the connection will fail at that point. Many application protocols require data to be sent from the client to the server first. Therefore, in such a case, only an OpenSSL 3.0 server would be impacted when talking to a non-OpenSSL 3.0 client. If both endpoints are OpenSSL 3.0 then the attacker could modify data being sent in both directions. In this case both clients and servers could be affected, regardless of the application protocol. Note that in the absence of an attacker this bug means that an OpenSSL 3.0 endpoint communicating with a non-OpenSSL 3.0 endpoint will fail to complete the handshake when using this ciphersuite. The confidentiality of data is not impacted by this issue, i.e. an attacker cannot decrypt data that has been encrypted using this ciphersuite - they can only modify it. In order for this attack to work both endpoints must legitimately negotiate the RC4-MD5 ciphersuite. This ciphersuite is not compiled by default in OpenSSL 3.0, and is not available within the default provider or the default ciphersuite list. This ciphersuite will never be used if TLSv1.3 has been negotiated. In order for an OpenSSL 3.0 endpoint to use this ciphersuite the following must have occurred: 1) OpenSSL must have been compiled with the (non-default) compile time option enable-weak-ssl-ciphers 2) OpenSSL must have had the legacy provider explicitly loaded (either through application code or via configuration) 3) The ciphersuite must have been explicitly added to the ciphersuite list 4) The libssl security level must have been set to 0 (default is 1) 5) A version of SSL/TLS below TLSv1.3 must have been negotiated 6) Both endpoints must negotiate the RC4-MD5 ciphersuite in preference to any others that both endpoints have in common.

CVE-2022-1343

Severity

Moderate

Published at

3 May 2022

Title

OCSP_basic_verify may incorrectly verify the response signing certificate

Found by

Raul Metsma

Affected

from 3.0.0 before 3.0.3

References

The function OCSP_basic_verify verifies the signer certificate on an OCSP response. In the case where the (non-default) flag OCSP_NOCHECKS is used then the response will be positive (meaning a successful verification) even in the case where the response signing certificate fails to verify. It is anticipated that most users of OCSP_basic_verify will not use the OCSP_NOCHECKS flag. In this case the OCSP_basic_verify function will return a negative value (indicating a fatal error) in the case of a certificate verification failure. The normal expected return value in this case would be 0. This issue also impacts the command line OpenSSL “ocsp” application. When verifying an ocsp response with the “-no_cert_checks” option the command line application will report that the verification is successful even though it has in fact failed. In this case the incorrect successful response will also be accompanied by error messages showing the failure and contradicting the apparently successful result.

CVE-2022-1292

Severity

Moderate

Published at

3 May 2022

Title

The c_rehash script allows command injection

Found by

Elison Niven (Sophos)

Affected

from 3.0.0 before 3.0.3
from 1.1.1 before 1.1.1o
from 1.0.2 before 1.0.2ze

References

The c_rehash script does not properly sanitise shell metacharacters to prevent command injection. This script is distributed by some operating systems in a manner where it is automatically executed. On such operating systems, an attacker could execute arbitrary commands with the privileges of the script. Use of the c_rehash script is considered obsolete and should be replaced by the OpenSSL rehash command line tool.

CVE-2022-0778

Severity

High

Published at

15 March 2022

Title

Infinite loop in BN_mod_sqrt() reachable when parsing certificates

Found by

Tavis Ormandy (Google)

Affected

from 3.0.0 before 3.0.2
from 1.1.1 before 1.1.1n
from 1.0.2 before 1.0.2zd

References

The BN_mod_sqrt() function, which computes a modular square root, contains a bug that can cause it to loop forever for non-prime moduli. Internally this function is used when parsing certificates that contain elliptic curve public keys in compressed form or explicit elliptic curve parameters with a base point encoded in compressed form. It is possible to trigger the infinite loop by crafting a certificate that has invalid explicit curve parameters. Since certificate parsing happens prior to verification of the certificate signature, any process that parses an externally supplied certificate may thus be subject to a denial of service attack. The infinite loop can also be reached when parsing crafted private keys as they can contain explicit elliptic curve parameters. Thus vulnerable situations include: - TLS clients consuming server certificates - TLS servers consuming client certificates - Hosting providers taking certificates or private keys from customers - Certificate authorities parsing certification requests from subscribers - Anything else which parses ASN.1 elliptic curve parameters Also any other applications that use the BN_mod_sqrt() where the attacker can control the parameter values are vulnerable to this DoS issue. In the OpenSSL 1.0.2 version the public key is not parsed during initial parsing of the certificate which makes it slightly harder to trigger the infinite loop. However any operation which requires the public key from the certificate will trigger the infinite loop. In particular the attacker can use a self-signed certificate to trigger the loop during verification of the certificate signature. This issue affects OpenSSL versions 1.0.2, 1.1.1 and 3.0. It was addressed in the releases of 1.1.1n and 3.0.2 on the 15th March 2022.

CVE-2021-4160

Severity

Moderate

Published at

28 January 2022

Title

BN_mod_exp may produce incorrect results on MIPS

Found by

Bernd Edlinger

Affected

from 3.0.0 before 3.0.1
from 1.1.1 before 1.1.1m
from 1.0.2 before 1.0.2zc

References

There is a carry propagation bug in the MIPS32 and MIPS64 squaring procedure. Many EC algorithms are affected, including some of the TLS 1.3 default curves. Impact was not analyzed in detail, because the pre-requisites for attack are considered unlikely and include reusing private keys. Analysis suggests that attacks against RSA and DSA as a result of this defect would be very difficult to perform and are not believed likely. Attacks against DH are considered just feasible (although very difficult) because most of the work necessary to deduce information about a private key may be performed offline. The amount of resources required for such an attack would be significant. However, for an attack on TLS to be meaningful, the server would have to share the DH private key among multiple clients, which is no longer an option since CVE-2016-0701. This issue affects OpenSSL versions 1.0.2, 1.1.1 and 3.0.0. It was addressed in the releases of 1.1.1m and 3.0.1 on the 15th of December 2021, and the release of 1.0.2zc on the 22nd of February 2022. The issue only affects OpenSSL on MIPS platforms.

2021

CVE-2021-4044

Severity

Moderate

Published at

14 December 2021

Title

Invalid handling of X509_verify_cert() internal errors in libssl

Found by

Tobias Nießen

Affected

from 3.0.0 before 3.0.1

References

Internally libssl in OpenSSL calls X509_verify_cert() on the client side to verify a certificate supplied by a server. That function may return a negative return value to indicate an internal error (for example out of memory). Such a negative return value is mishandled by OpenSSL and will cause an IO function (such as SSL_connect() or SSL_do_handshake()) to not indicate success and a subsequent call to SSL_get_error() to return the value SSL_ERROR_WANT_RETRY_VERIFY. This return value is only supposed to be returned by OpenSSL if the application has previously called SSL_CTX_set_cert_verify_callback(). Since most applications do not do this the SSL_ERROR_WANT_RETRY_VERIFY return value from SSL_get_error() will be totally unexpected and applications may not behave correctly as a result. The exact behaviour will depend on the application but it could result in crashes, infinite loops or other similar incorrect responses. This issue is made more serious in combination with a separate bug in OpenSSL 3.0 that will cause X509_verify_cert() to indicate an internal error when processing a certificate chain. This will occur where a certificate does not include the Subject Alternative Name extension but where a Certificate Authority has enforced name constraints. This issue can occur even with valid chains. By combining the two issues an attacker could induce incorrect, application dependent behaviour.

CVE-2021-3712

Severity

Moderate

Published at

24 August 2021

Title

Read buffer overruns processing ASN.1 strings

Found by

Ingo Schwarze

Affected

from 1.1.1 before 1.1.1l
from 1.0.2 before 1.0.2za

References

ASN.1 strings are represented internally within OpenSSL as an ASN1_STRING structure which contains a buffer holding the string data and a field holding the buffer length. This contrasts with normal C strings which are repesented as a buffer for the string data which is terminated with a NUL (0) byte. Although not a strict requirement, ASN.1 strings that are parsed using OpenSSL’s own “d2i” functions (and other similar parsing functions) as well as any string whose value has been set with the ASN1_STRING_set() function will additionally NUL terminate the byte array in the ASN1_STRING structure. However, it is possible for applications to directly construct valid ASN1_STRING structures which do not NUL terminate the byte array by directly setting the “data” and “length” fields in the ASN1_STRING array. This can also happen by using the ASN1_STRING_set0() function. Numerous OpenSSL functions that print ASN.1 data have been found to assume that the ASN1_STRING byte array will be NUL terminated, even though this is not guaranteed for strings that have been directly constructed. Where an application requests an ASN.1 structure to be printed, and where that ASN.1 structure contains ASN1_STRINGs that have been directly constructed by the application without NUL terminating the “data” field, then a read buffer overrun can occur. The same thing can also occur during name constraints processing of certificates (for example if a certificate has been directly constructed by the application instead of loading it via the OpenSSL parsing functions, and the certificate contains non NUL terminated ASN1_STRING structures). It can also occur in the X509_get1_email(), X509_REQ_get1_email() and X509_get1_ocsp() functions. If a malicious actor can cause an application to directly construct an ASN1_STRING and then process it through one of the affected OpenSSL functions then this issue could be hit. This might result in a crash (causing a Denial of Service attack). It could also result in the disclosure of private memory contents (such as private keys, or sensitive plaintext).

CVE-2021-3711

Severity

High

Published at

24 August 2021

Title

SM2 Decryption Buffer Overflow

Found by

John Ouyang

Affected

from 1.1.1 before 1.1.1l

References

In order to decrypt SM2 encrypted data an application is expected to call the API function EVP_PKEY_decrypt(). Typically an application will call this function twice. The first time, on entry, the “out” parameter can be NULL and, on exit, the “outlen” parameter is populated with the buffer size required to hold the decrypted plaintext. The application can then allocate a sufficiently sized buffer and call EVP_PKEY_decrypt() again, but this time passing a non-NULL value for the “out” parameter. A bug in the implementation of the SM2 decryption code means that the calculation of the buffer size required to hold the plaintext returned by the first call to EVP_PKEY_decrypt() can be smaller than the actual size required by the second call. This can lead to a buffer overflow when EVP_PKEY_decrypt() is called by the application a second time with a buffer that is too small. A malicious attacker who is able present SM2 content for decryption to an application could cause attacker chosen data to overflow the buffer by up to a maximum of 62 bytes altering the contents of other data held after the buffer, possibly changing application behaviour or causing the application to crash. The location of the buffer is application dependent but is typically heap allocated.

CVE-2021-3450

Severity

High

Published at

25 March 2021

Title

CA certificate check bypass with X509_V_FLAG_X509_STRICT

Found by

Benjamin Kaduk (Akamai), Xiang Ding (Akamai), others at Akamai

Affected

from 1.1.1h before 1.1.1k

References

The X509_V_FLAG_X509_STRICT flag enables additional security checks of the certificates present in a certificate chain. It is not set by default. Starting from OpenSSL version 1.1.1h a check to disallow certificates in the chain that have explicitly encoded elliptic curve parameters was added as an additional strict check. An error in the implementation of this check meant that the result of a previous check to confirm that certificates in the chain are valid CA certificates was overwritten. This effectively bypasses the check that non-CA certificates must not be able to issue other certificates. If a “purpose” has been configured then there is a subsequent opportunity for checks that the certificate is a valid CA. All of the named “purpose” values implemented in libcrypto perform this check. Therefore, where a purpose is set the certificate chain will still be rejected even when the strict flag has been used. A purpose is set by default in libssl client and server certificate verification routines, but it can be overridden or removed by an application. In order to be affected, an application must explicitly set the X509_V_FLAG_X509_STRICT verification flag and either not set a purpose for the certificate verification or, in the case of TLS client or server applications, override the default purpose. OpenSSL versions 1.1.1h and newer are affected by this issue. Users of these versions should upgrade to OpenSSL 1.1.1k. OpenSSL 1.0.2 is not impacted by this issue.

CVE-2021-3449

Severity

High

Published at

25 March 2021

Title

NULL pointer deref in signature_algorithms processing

Found by

Peter Kästle (Nokia) and Samuel Sapalski (Nokia)

Affected

from 1.1.1 before 1.1.1k

References

An OpenSSL TLS server may crash if sent a maliciously crafted renegotiation ClientHello message from a client. If a TLSv1.2 renegotiation ClientHello omits the signature_algorithms extension (where it was present in the initial ClientHello), but includes a signature_algorithms_cert extension then a NULL pointer dereference will result, leading to a crash and a denial of service attack. A server is only vulnerable if it has TLSv1.2 and renegotiation enabled (which is the default configuration). OpenSSL TLS clients are not impacted by this issue. All OpenSSL 1.1.1 versions are affected by this issue. Users of these versions should upgrade to OpenSSL 1.1.1k. OpenSSL 1.0.2 is not impacted by this issue.

CVE-2021-23841

Severity

Moderate

Published at

16 February 2021

Title

Null pointer deref in X509_issuer_and_serial_hash()

Found by

Tavis Ormandy (Google)

Affected

from 1.1.1 before 1.1.1j
from 1.0.2 before 1.0.2y

References

The OpenSSL public API function X509_issuer_and_serial_hash() attempts to create a unique hash value based on the issuer and serial number data contained within an X509 certificate. However it fails to correctly handle any errors that may occur while parsing the issuer field (which might occur if the issuer field is maliciously constructed). This may subsequently result in a NULL pointer deref and a crash leading to a potential denial of service attack. The function X509_issuer_and_serial_hash() is never directly called by OpenSSL itself so applications are only vulnerable if they use this function directly and they use it on certificates that may have been obtained from untrusted sources. OpenSSL versions 1.1.1i and below are affected by this issue. Users of these versions should upgrade to OpenSSL 1.1.1j. OpenSSL versions 1.0.2x and below are affected by this issue. However OpenSSL 1.0.2 is out of support and no longer receiving public updates. Premium support customers of OpenSSL 1.0.2 should upgrade to 1.0.2y. Other users should upgrade to 1.1.1j.

CVE-2021-23840

Severity

Low

Published at

16 February 2021

Title

Integer overflow in CipherUpdate

Found by

Paul Kehrer

Affected

from 1.1.1 before 1.1.1j
from 1.0.2 before 1.0.2y

References

Calls to EVP_CipherUpdate, EVP_EncryptUpdate and EVP_DecryptUpdate may overflow the output length argument in some cases where the input length is close to the maximum permissable length for an integer on the platform. In such cases the return value from the function call will be 1 (indicating success), but the output length value will be negative. This could cause applications to behave incorrectly or crash. OpenSSL versions 1.1.1i and below are affected by this issue. Users of these versions should upgrade to OpenSSL 1.1.1j. OpenSSL versions 1.0.2x and below are affected by this issue. However OpenSSL 1.0.2 is out of support and no longer receiving public updates. Premium support customers of OpenSSL 1.0.2 should upgrade to 1.0.2y. Other users should upgrade to 1.1.1j.

CVE-2021-23839

Severity

Low

Published at

16 February 2021

Title

Incorrect SSLv2 rollback protection

Found by

D. Katz and Joel Luellwitz (Trustwave)

Affected

from 1.0.2s before 1.0.2y

References

OpenSSL 1.0.2 supports SSLv2. If a client attempts to negotiate SSLv2 with a server that is configured to support both SSLv2 and more recent SSL and TLS versions then a check is made for a version rollback attack when unpadding an RSA signature. Clients that support SSL or TLS versions greater than SSLv2 are supposed to use a special form of padding. A server that supports greater than SSLv2 is supposed to reject connection attempts from a client where this special form of padding is present, because this indicates that a version rollback has occurred (i.e. both client and server support greater than SSLv2, and yet this is the version that is being requested). The implementation of this padding check inverted the logic so that the connection attempt is accepted if the padding is present, and rejected if it is absent. This means that such as server will accept a connection if a version rollback attack has occurred. Further the server will erroneously reject a connection if a normal SSLv2 connection attempt is made. Only OpenSSL 1.0.2 servers from version 1.0.2s to 1.0.2x are affected by this issue. In order to be vulnerable a 1.0.2 server must: 1) have configured SSLv2 support at compile time (this is off by default), 2) have configured SSLv2 support at runtime (this is off by default), 3) have configured SSLv2 ciphersuites (these are not in the default ciphersuite list) OpenSSL 1.1.1 does not have SSLv2 support and therefore is not vulnerable to this issue. The underlying error is in the implementation of the RSA_padding_check_SSLv23() function. This also affects the RSA_SSLV23_PADDING padding mode used by various other functions. Although 1.1.1 does not support SSLv2 the RSA_padding_check_SSLv23() function still exists, as does the RSA_SSLV23_PADDING padding mode. Applications that directly call that function or use that padding mode will encounter this issue. However since there is no support for the SSLv2 protocol in 1.1.1 this is considered a bug and not a security issue in that version. OpenSSL 1.0.2 is out of support and no longer receiving public updates. Premium support customers of OpenSSL 1.0.2 should upgrade to 1.0.2y. Other users should upgrade to 1.1.1j.

2020

CVE-2020-1971

Severity

High

Published at

8 December 2020

Title

EDIPARTYNAME NULL pointer dereference

Found by

David Benjamin (Google)

Affected

from 1.1.1 before 1.1.1i
from 1.0.2 before 1.0.2x

References

The X.509 GeneralName type is a generic type for representing different types of names. One of those name types is known as EDIPartyName. OpenSSL provides a function GENERAL_NAME_cmp which compares different instances of a GENERAL_NAME to see if they are equal or not. This function behaves incorrectly when both GENERAL_NAMEs contain an EDIPARTYNAME. A NULL pointer dereference and a crash may occur leading to a possible denial of service attack. OpenSSL itself uses the GENERAL_NAME_cmp function for two purposes: 1) Comparing CRL distribution point names between an available CRL and a CRL distribution point embedded in an X509 certificate 2) When verifying that a timestamp response token signer matches the timestamp authority name (exposed via the API functions TS_RESP_verify_response and TS_RESP_verify_token) If an attacker can control both items being compared then that attacker could trigger a crash. For example if the attacker can trick a client or server into checking a malicious certificate against a malicious CRL then this may occur. Note that some applications automatically download CRLs based on a URL embedded in a certificate. This checking happens prior to the signatures on the certificate and CRL being verified. OpenSSL’s s_server, s_client and verify tools have support for the “-crl_download” option which implements automatic CRL downloading and this attack has been demonstrated to work against those tools. Note that an unrelated bug means that affected versions of OpenSSL cannot parse or construct correct encodings of EDIPARTYNAME. However it is possible to construct a malformed EDIPARTYNAME that OpenSSL’s parser will accept and hence trigger this attack. All OpenSSL 1.1.1 and 1.0.2 versions are affected by this issue. Other OpenSSL releases are out of support and have not been checked.

CVE-2020-1968

Severity

Low

Published at

9 September 2020

Title

Raccoon attack

Found by

Robert Merget, Marcus Brinkmann, Nimrod Aviram, and Juraj Somorovsky

Affected

from 1.0.2 before 1.0.2w

References

The Raccoon attack exploits a flaw in the TLS specification which can lead to an attacker being able to compute the pre-master secret in connections which have used a Diffie-Hellman (DH) based ciphersuite. In such a case this would result in the attacker being able to eavesdrop on all encrypted communications sent over that TLS connection. The attack can only be exploited if an implementation re-uses a DH secret across multiple TLS connections. Note that this issue only impacts DH ciphersuites and not ECDH ciphersuites. This issue affects OpenSSL 1.0.2 which is out of support and no longer receiving public updates. OpenSSL 1.1.1 is not vulnerable to this issue.

CVE-2020-1967

Severity

High

Published at

21 April 2020

Title

Segmentation fault in SSL_check_chain

Found by

Bernd Edlinger

Affected

from 1.1.1d before 1.1.1g

References

Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the “signature_algorithms_cert” TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from the peer. This could be exploited by a malicious peer in a Denial of Service attack. OpenSSL version 1.1.1d, 1.1.1e, and 1.1.1f are affected by this issue. This issue did not affect OpenSSL versions prior to 1.1.1d.

2019

CVE-2019-1563

Severity

Low

Published at

10 September 2019

Title

Padding Oracle in PKCS7_dataDecode and CMS_decrypt_set1_pkey

Found by

Bernd Edlinger

Affected

from 1.1.1 before 1.1.1d
from 1.1.0 before 1.1.0l
from 1.0.2 before 1.0.2t

References

In situations where an attacker receives automated notification of the success or failure of a decryption attempt an attacker, after sending a very large number of messages to be decrypted, can recover a CMS/PKCS7 transported encryption key or decrypt any RSA encrypted message that was encrypted with the public RSA key, using a Bleichenbacher padding oracle attack. Applications are not affected if they use a certificate together with the private RSA key to the CMS_decrypt or PKCS7_decrypt functions to select the correct recipient info to decrypt.

CVE-2019-1559

Severity

Moderate

Published at

26 February 2019

Title

0-byte record padding oracle

Found by

Juraj Somorovsky, Robert Merget and Nimrod Aviram, with additional investigation by Steven Collison and Andrew Hourselt

Affected

from 1.0.2 before 1.0.2r

References

If an application encounters a fatal protocol error and then calls SSL_shutdown() twice (once to send a close_notify, and once to receive one) then OpenSSL can respond differently to the calling application if a 0 byte record is received with invalid padding compared to if a 0 byte record is received with an invalid MAC. If the application then behaves differently based on that in a way that is detectable to the remote peer, then this amounts to a padding oracle that could be used to decrypt data. In order for this to be exploitable “non-stitched” ciphersuites must be in use. Stitched ciphersuites are optimised implementations of certain commonly used ciphersuites. Also the application must call SSL_shutdown() twice even if a protocol error has occurred (applications should not do this but some do anyway). AEAD ciphersuites are not impacted.

CVE-2019-1552

Severity

Low

Published at

30 July 2019

Title

Windows builds with insecure path defaults

Found by

Rich Mirch

Affected

from 1.1.1 before 1.1.1d
from 1.1.0 before 1.1.0l
from 1.0.2 before 1.0.2t

References

OpenSSL has internal defaults for a directory tree where it can find a configuration file as well as certificates used for verification in TLS. This directory is most commonly referred to as OPENSSLDIR, and is configurable with the –prefix / –openssldir configuration options. For OpenSSL versions 1.1.0 and 1.1.1, the mingw configuration targets assume that resulting programs and libraries are installed in a Unix-like environment and the default prefix for program installation as well as for OPENSSLDIR should be ‘/usr/local’. However, mingw programs are Windows programs, and as such, find themselves looking at sub-directories of ‘C:/usr/local’, which may be world writable, which enables untrusted users to modify OpenSSL’s default configuration, insert CA certificates, modify (or even replace) existing engine modules, etc. For OpenSSL 1.0.2, ‘/usr/local/ssl’ is used as default for OPENSSLDIR on all Unix and Windows targets, including Visual C builds. However, some build instructions for the diverse Windows targets on 1.0.2 encourage you to specify your own –prefix. OpenSSL versions 1.1.1, 1.1.0 and 1.0.2 are affected by this issue. Due to the limited scope of affected deployments this has been assessed as low severity and therefore we are not creating new releases at this time.

CVE-2019-1551

Severity

Low

Published at

6 December 2019

Title

rsaz_512_sqr overflow bug on x86_64

Found by

OSS-Fuzz and Guido Vranken

Affected

from 1.1.1 before 1.1.1e
from 1.0.2 before 1.0.2u

References

There is an overflow bug in the x86_64 Montgomery squaring procedure used in exponentiation with 512-bit moduli. No EC algorithms are affected. Analysis suggests that attacks against 2-prime RSA1024, 3-prime RSA1536, and DSA1024 as a result of this defect would be very difficult to perform and are not believed likely. Attacks against DH512 are considered just feasible. However, for an attack the target would have to re-use the DH512 private key, which is not recommended anyway. Also applications directly using the low level API BN_mod_exp may be affected if they use BN_FLG_CONSTTIME.

CVE-2019-1549

Severity

Low

Published at

10 September 2019

Title

Fork Protection

Found by

Matt Caswell

Affected

from 1.1.1 before 1.1.1d

References

OpenSSL 1.1.1 introduced a rewritten random number generator (RNG). This was intended to include protection in the event of a fork() system call in order to ensure that the parent and child processes did not share the same RNG state. However this protection was not being used in the default case. A partial mitigation for this issue is that the output from a high precision timer is mixed into the RNG state so the likelihood of a parent and child process sharing state is significantly reduced. If an application already calls OPENSSL_init_crypto() explicitly using OPENSSL_INIT_ATFORK then this problem does not occur at all.

CVE-2019-1547

Severity

Low

Published at

10 September 2019

Title

ECDSA remote timing attack

Found by

Cesar Pereida García, Sohaib ul Hassan, Nicola Tuveri, Iaroslav Gridin, Alejandro Cabrera Aldaya, and Billy Brumley

Affected

from 1.1.1 before 1.1.1d
from 1.1.0 before 1.1.0l
from 1.0.2 before 1.0.2t

References

Normally in OpenSSL EC groups always have a co-factor present and this is used in side channel resistant code paths. However, in some cases, it is possible to construct a group using explicit parameters (instead of using a named curve). In those cases it is possible that such a group does not have the cofactor present. This can occur even where all the parameters match a known named curve. If such a curve is used then OpenSSL falls back to non-side channel resistant code paths which may result in full key recovery during an ECDSA signature operation. In order to be vulnerable an attacker would have to have the ability to time the creation of a large number of signatures where explicit parameters with no co-factor present are in use by an application using libcrypto. For the avoidance of doubt libssl is not vulnerable because explicit parameters are never used.

CVE-2019-1543

Severity

Low

Published at

6 March 2019

Title

ChaCha20-Poly1305 with long nonces

Found by

Joran Dirk Greef of Ronomon

Affected

from 1.1.1 before 1.1.1c
from 1.1.0 before 1.1.0k

References

ChaCha20-Poly1305 is an AEAD cipher, and requires a unique nonce input for every encryption operation. RFC 7539 specifies that the nonce value (IV) should be 96 bits (12 bytes). OpenSSL allows a variable nonce length and front pads the nonce with 0 bytes if it is less than 12 bytes. However it also incorrectly allows a nonce to be set of up to 16 bytes. In this case only the last 12 bytes are significant and any additional leading bytes are ignored. It is a requirement of using this cipher that nonce values are unique. Messages encrypted using a reused nonce value are susceptible to serious confidentiality and integrity attacks. If an application changes the default nonce length to be longer than 12 bytes and then makes a change to the leading bytes of the nonce expecting the new value to be a new unique nonce then such an application could inadvertently encrypt messages with a reused nonce. Additionally the ignored bytes in a long nonce are not covered by the integrity guarantee of this cipher. Any application that relies on the integrity of these ignored leading bytes of a long nonce may be further affected. Any OpenSSL internal use of this cipher, including in SSL/TLS, is safe because no such use sets such a long nonce value. However user applications that use this cipher directly and set a non-default nonce length to be longer than 12 bytes may be vulnerable. OpenSSL versions 1.1.1 and 1.1.0 are affected by this issue. Due to the limited scope of affected deployments this has been assessed as low severity and therefore we are not creating new releases at this time.

2018

CVE-2018-5407

Severity

Low

Published at

2 November 2018

Title

Microarchitecture timing vulnerability in ECC scalar multiplication

Found by

Alejandro Cabrera Aldaya, Billy Brumley, Sohaib ul Hassan, Cesar Pereida Garcia and Nicola Tuveri

Affected

from 1.1.0 before 1.1.0i
from 1.0.2 before 1.0.2q

References

OpenSSL ECC scalar multiplication, used in e.g. ECDSA and ECDH, has been shown to be vulnerable to a microarchitecture timing side channel attack. An attacker with sufficient access to mount local timing attacks during ECDSA signature generation could recover the private key.

CVE-2018-0739

Severity

Moderate

Published at

27 March 2018

Title

Constructed ASN.1 types with a recursive definition could exceed the stack

Found by

OSS-fuzz

Affected

from 1.1.0 before 1.1.0h
from 1.0.2b before 1.0.2o

References

Constructed ASN.1 types with a recursive definition (such as can be found in PKCS7) could eventually exceed the stack given malicious input with excessive recursion. This could result in a Denial Of Service attack. There are no such structures used within SSL/TLS that come from untrusted sources so this is considered safe.

CVE-2018-0737

Severity

Low

Published at

16 April 2018

Title

Cache timing vulnerability in RSA Key Generation

Found by

Alejandro Cabrera Aldaya, Billy Brumley, Cesar Pereida Garcia and Luis Manuel Alvarez Tapia

Affected

from 1.1.0 before 1.1.0i
from 1.0.2 before 1.0.2p

References

The OpenSSL RSA Key generation algorithm has been shown to be vulnerable to a cache timing side channel attack. An attacker with sufficient access to mount cache timing attacks during the RSA key generation process could recover the private key.

CVE-2018-0735

Severity

Low

Published at

29 October 2018

Title

Timing attack against ECDSA signature generation

Found by

Samuel Weiser

Affected

from 1.1.0 before 1.1.0j
from 1.1.1 before 1.1.1a

References

The OpenSSL ECDSA signature algorithm has been shown to be vulnerable to a timing side channel attack. An attacker could use variations in the signing algorithm to recover the private key.

CVE-2018-0734

Severity

Low

Published at

30 October 2018

Title

Timing attack against DSA

Found by

Samuel Weiser

Affected

from 1.1.1 before 1.1.1a
from 1.1.0 before 1.1.0j
from 1.0.2 before 1.0.2q

References

The OpenSSL DSA signature algorithm has been shown to be vulnerable to a timing side channel attack. An attacker could use variations in the signing algorithm to recover the private key.

CVE-2018-0733

Severity

Moderate

Published at

27 March 2018

Title

Incorrect CRYPTO_memcmp on HP-UX PA-RISC

Found by

Peter Waltenberg (IBM)

Affected

from 1.1.0 before 1.1.0h

References

Because of an implementation bug the PA-RISC CRYPTO_memcmp function is effectively reduced to only comparing the least significant bit of each byte. This allows an attacker to forge messages that would be considered as authenticated in an amount of tries lower than that guaranteed by the security claims of the scheme. The module can only be compiled by the HP-UX assembler, so that only HP-UX PA-RISC targets are affected.

CVE-2018-0732

Severity

Low

Published at

12 June 2018

Title

Client DoS due to large DH parameter

Found by

Guido Vranken

Affected

from 1.1.0 before 1.1.0i
from 1.0.2 before 1.0.2p

References

During key agreement in a TLS handshake using a DH(E) based ciphersuite a malicious server can send a very large prime value to the client. This will cause the client to spend an unreasonably long period of time generating a key for this prime resulting in a hang until the client has finished. This could be exploited in a Denial Of Service attack.

2017

CVE-2017-3738

Severity

Low

Published at

7 December 2017

Title

bn_sqrx8x_internal carry bug on x86_64

Found by

David Benjamin (Google)/Google OSS-Fuzz

Affected

from 1.0.2 before 1.0.2n
from 1.1.0 before 1.1.0h

References

There is an overflow bug in the AVX2 Montgomery multiplication procedure used in exponentiation with 1024-bit moduli. No EC algorithms are affected. Analysis suggests that attacks against RSA and DSA as a result of this defect would be very difficult to perform and are not believed likely. Attacks against DH1024 are considered just feasible, because most of the work necessary to deduce information about a private key may be performed offline. The amount of resources required for such an attack would be significant. However, for an attack on TLS to be meaningful, the server would have to share the DH1024 private key among multiple clients, which is no longer an option since CVE-2016-0701. This only affects processors that support the AVX2 but not ADX extensions like Intel Haswell (4th generation). Note: The impact from this issue is similar to CVE-2017-3736, CVE-2017-3732 and CVE-2015-3193. Due to the low severity of this issue we are not issuing a new release of OpenSSL 1.1.0 at this time. The fix will be included in OpenSSL 1.1.0h when it becomes available. The fix is also available in commit e502cc86d in the OpenSSL git repository.

CVE-2017-3737

Severity

Moderate

Published at

7 December 2017

Title

Read/write after SSL object in error state

Found by

David Benjamin (Google)

Affected

from 1.0.2b before 1.0.2n

References

OpenSSL 1.0.2 (starting from version 1.0.2b) introduced an “error state” mechanism. The intent was that if a fatal error occurred during a handshake then OpenSSL would move into the error state and would immediately fail if you attempted to continue the handshake. This works as designed for the explicit handshake functions (SSL_do_handshake(), SSL_accept() and SSL_connect()), however due to a bug it does not work correctly if SSL_read() or SSL_write() is called directly. In that scenario, if the handshake fails then a fatal error will be returned in the initial function call. If SSL_read()/SSL_write() is subsequently called by the application for the same SSL object then it will succeed and the data is passed without being decrypted/encrypted directly from the SSL/TLS record layer. In order to exploit this issue an application bug would have to be present that resulted in a call to SSL_read()/SSL_write() being issued after having already received a fatal error.

CVE-2017-3736

Severity

Moderate

Published at

2 November 2017

Title

bn_sqrx8x_internal carry bug on x86_64

Found by

Google OSS-Fuzz

Affected

from 1.0.2 before 1.0.2m
from 1.1.0 before 1.1.0g

References

There is a carry propagating bug in the x86_64 Montgomery squaring procedure. No EC algorithms are affected. Analysis suggests that attacks against RSA and DSA as a result of this defect would be very difficult to perform and are not believed likely. Attacks against DH are considered just feasible (although very difficult) because most of the work necessary to deduce information about a private key may be performed offline. The amount of resources required for such an attack would be very significant and likely only accessible to a limited number of attackers. An attacker would additionally need online access to an unpatched system using the target private key in a scenario with persistent DH parameters and a private key that is shared between multiple clients. This only affects processors that support the BMI1, BMI2 and ADX extensions like Intel Broadwell (5th generation) and later or AMD Ryzen.

CVE-2017-3735

Severity

Low

Published at

28 August 2017

Title

Possible Overread in parsing X.509 IPAdressFamily

Found by

Google OSS-Fuzz

Affected

from 1.0.2 before 1.0.2m
from 1.1.0 before 1.1.0g

References

While parsing an IPAdressFamily extension in an X.509 certificate, it is possible to do a one-byte overread. This would result in an incorrect text display of the certificate.

CVE-2017-3733

Severity

High

Published at

16 February 2017

Title

Encrypt-Then-Mac renegotiation crash

Found by

Joe Orton (Red Hat)

Affected

from 1.1.0 before 1.1.0e

References

During a renegotiation handshake if the Encrypt-Then-Mac extension is negotiated where it was not in the original handshake (or vice-versa) then this can cause OpenSSL to crash (dependent on ciphersuite). Both clients and servers are affected.

CVE-2017-3732

Severity

Moderate

Published at

26 January 2017

Title

BN_mod_exp may produce incorrect results on x86_64

Found by

OSS-Fuzz project

Affected

from 1.1.0 before 1.1.0d
from 1.0.2 before 1.0.2k

References

There is a carry propagating bug in the x86_64 Montgomery squaring procedure. No EC algorithms are affected. Analysis suggests that attacks against RSA and DSA as a result of this defect would be very difficult to perform and are not believed likely. Attacks against DH are considered just feasible (although very difficult) because most of the work necessary to deduce information about a private key may be performed offline. The amount of resources required for such an attack would be very significant and likely only accessible to a limited number of attackers. An attacker would additionally need online access to an unpatched system using the target private key in a scenario with persistent DH parameters and a private key that is shared between multiple clients. For example this can occur by default in OpenSSL DHE based SSL/TLS ciphersuites. Note: This issue is very similar to CVE-2015-3193 but must be treated as a separate problem.

CVE-2017-3731

Severity

Moderate

Published at

26 January 2017

Title

Truncated packet could crash via OOB read

Found by

Robert Święcki of Google

Affected

from 1.1.0 before 1.1.0d
from 1.0.2 before 1.0.2k

References

If an SSL/TLS server or client is running on a 32-bit host, and a specific cipher is being used, then a truncated packet can cause that server or client to perform an out-of-bounds read, usually resulting in a crash. For OpenSSL 1.1.0, the crash can be triggered when using CHACHA20/POLY1305; users should upgrade to 1.1.0d. For Openssl 1.0.2, the crash can be triggered when using RC4-MD5; users who have not disabled that algorithm should update to 1.0.2k.

CVE-2017-3730

Severity

Moderate

Published at

26 January 2017

Title

Bad (EC)DHE parameters cause a client crash

Found by

Guido Vranken

Affected

from 1.1.0 before 1.1.0d

References

If a malicious server supplies bad parameters for a DHE or ECDHE key exchange then this can result in the client attempting to dereference a NULL pointer leading to a client crash. This could be exploited in a Denial of Service attack.

2016

CVE-2016-7055

Severity

Low

Published at

10 November 2016

Title

Montgomery multiplication may produce incorrect results

Found by

Publicly reported

Affected

from 1.1.0 before 1.1.0c
from 1.0.2 before 1.0.2k

References

There is a carry propagating bug in the Broadwell-specific Montgomery multiplication procedure that handles input lengths divisible by, but longer than 256 bits. Analysis suggests that attacks against RSA, DSA and DH private keys are impossible. This is because the subroutine in question is not used in operations with the private key itself and an input of the attacker’s direct choice. Otherwise the bug can manifest itself as transient authentication and key negotiation failures or reproducible erroneous outcome of public-key operations with specially crafted input. Among EC algorithms only Brainpool P-512 curves are affected and one presumably can attack ECDH key negotiation. Impact was not analyzed in detail, because pre-requisites for attack are considered unlikely. Namely multiple clients have to choose the curve in question and the server has to share the private key among them, neither of which is default behaviour. Even then only clients that chose the curve will be affected.

CVE-2016-7054

Severity

High

Published at

10 November 2016

Title

ChaCha20/Poly1305 heap-buffer-overflow

Found by

Robert Święcki (Google Security Team)

Affected

from 1.1.0 before 1.1.0c

References

TLS connections using *-CHACHA20-POLY1305 ciphersuites are susceptible to a DoS attack by corrupting larger payloads. This can result in an OpenSSL crash. This issue is not considered to be exploitable beyond a DoS.

CVE-2016-7053

Severity

Moderate

Published at

10 November 2016

Title

CMS Null dereference

Found by

Tyler Nighswander (ForAllSecure)

Affected

from 1.1.0 before 1.1.0c

References

Applications parsing invalid CMS structures can crash with a NULL pointer dereference. This is caused by a bug in the handling of the ASN.1 CHOICE type in OpenSSL 1.1.0 which can result in a NULL value being passed to the structure callback if an attempt is made to free certain invalid encodings. Only CHOICE structures using a callback which do not handle NULL value are affected.

CVE-2016-7052

Severity

Moderate

Published at

26 September 2016

Title

Missing CRL sanity check

Found by

Bruce Stephens and Thomas Jakobi

Affected

from 1.0.2i before 1.0.2j

References

This issue only affects OpenSSL 1.0.2i, released on 22nd September 2016. A bug fix which included a CRL sanity check was added to OpenSSL 1.1.0 but was omitted from OpenSSL 1.0.2i. As a result any attempt to use CRLs in OpenSSL 1.0.2i will crash with a null pointer exception.

CVE-2016-6309

Severity

Critical

Published at

26 September 2016

Found by

Robert Święcki (Google Security Team)

Affected

from 1.1.0a before 1.1.0b

References

This issue only affects OpenSSL 1.1.0a, released on 22nd September 2016. The patch applied to address CVE-2016-6307 resulted in an issue where if a message larger than approx 16k is received then the underlying buffer to store the incoming message is reallocated and moved. Unfortunately a dangling pointer to the old location is left which results in an attempt to write to the previously freed location. This is likely to result in a crash, however it could potentially lead to execution of arbitrary code.

CVE-2016-6308

Severity

Low

Published at

21 September 2016

Found by

Shi Lei (Gear Team, Qihoo 360 Inc.)

Affected

from 1.1.0 before 1.1.0a

References

A DTLS message includes 3 bytes for its length in the header for the message. This would allow for messages up to 16Mb in length. Messages of this length are excessive and OpenSSL includes a check to ensure that a peer is sending reasonably sized messages in order to avoid too much memory being consumed to service a connection. A flaw in the logic of version 1.1.0 means that memory for the message is allocated too early, prior to the excessive message length check. Due to way memory is allocated in OpenSSL this could mean an attacker could force up to 21Mb to be allocated to service a connection. This could lead to a Denial of Service through memory exhaustion. However, the excessive message length check still takes place, and this would cause the connection to immediately fail. Assuming that the application calls SSL_free() on the failed conneciton in a timely manner then the 21Mb of allocated memory will then be immediately freed again. Therefore the excessive memory allocation will be transitory in nature. This then means that there is only a security impact if: 1) The application does not call SSL_free() in a timely manner in the event that the connection fails or 2) The application is working in a constrained environment where there is very little free memory or 3) The attacker initiates multiple connection attempts such that there are multiple connections in a state where memory has been allocated for the connection; SSL_free() has not yet been called; and there is insufficient memory to service the multiple requests. Except in the instance of (1) above any Denial Of Service is likely to be transitory because as soon as the connection fails the memory is subsequently freed again in the SSL_free() call. However there is an increased risk during this period of application crashes due to the lack of memory - which would then mean a more serious Denial of Service.

CVE-2016-6307

Severity

Low

Published at

21 September 2016

Found by

Shi Lei (Gear Team, Qihoo 360 Inc.)

Affected

from 1.1.0 before 1.1.0a

References

A TLS message includes 3 bytes for its length in the header for the message. This would allow for messages up to 16Mb in length. Messages of this length are excessive and OpenSSL includes a check to ensure that a peer is sending reasonably sized messages in order to avoid too much memory being consumed to service a connection. A flaw in the logic of version 1.1.0 means that memory for the message is allocated too early, prior to the excessive message length check. Due to way memory is allocated in OpenSSL this could mean an attacker could force up to 21Mb to be allocated to service a connection. This could lead to a Denial of Service through memory exhaustion. However, the excessive message length check still takes place, and this would cause the connection to immediately fail. Assuming that the application calls SSL_free() on the failed conneciton in a timely manner then the 21Mb of allocated memory will then be immediately freed again. Therefore the excessive memory allocation will be transitory in nature. This then means that there is only a security impact if: 1) The application does not call SSL_free() in a timely manner in the event that the connection fails or 2) The application is working in a constrained environment where there is very little free memory or 3) The attacker initiates multiple connection attempts such that there are multiple connections in a state where memory has been allocated for the connection; SSL_free() has not yet been called; and there is insufficient memory to service the multiple requests. Except in the instance of (1) above any Denial Of Service is likely to be transitory because as soon as the connection fails the memory is subsequently freed again in the SSL_free() call. However there is an increased risk during this period of application crashes due to the lack of memory - which would then mean a more serious Denial of Service.

CVE-2016-6306

Severity

Low

Published at

21 September 2016

Found by

Shi Lei (Gear Team, Qihoo 360 Inc.)

Affected

from 1.0.1 before 1.0.1u
from 1.0.2 before 1.0.2i

References

In OpenSSL 1.0.2 and earlier some missing message length checks can result in OOB reads of up to 2 bytes beyond an allocated buffer. There is a theoretical DoS risk but this has not been observed in practice on common platforms. The messages affected are client certificate, client certificate request and server certificate. As a result the attack can only be performed against a client or a server which enables client authentication.

CVE-2016-6305

Severity

Moderate

Published at

22 September 2016

Found by

Alex Gaynor

Affected

from 1.1.0 before 1.1.0a

References

OpenSSL 1.1.0 SSL/TLS will hang during a call to SSL_peek() if the peer sends an empty record. This could be exploited by a malicious peer in a Denial Of Service attack.

CVE-2016-6304

Severity

High

Published at

22 September 2016

Found by

Shi Lei (Gear Team, Qihoo 360 Inc.)

Affected

from 1.0.1 before 1.0.1u
from 1.0.2 before 1.0.2i
from 1.1.0 before 1.1.0a

References

A malicious client can send an excessively large OCSP Status Request extension. If that client continually requests renegotiation, sending a large OCSP Status Request extension each time, then there will be unbounded memory growth on the server. This will eventually lead to a Denial Of Service attack through memory exhaustion. Servers with a default configuration are vulnerable even if they do not support OCSP. Builds using the “no-ocsp” build time option are not affected. Servers using OpenSSL versions prior to 1.0.1g are not vulnerable in a default configuration, instead only if an application explicitly enables OCSP stapling support.

CVE-2016-6303

Severity

Low

Published at

24 August 2016

Found by

Shi Lei (Gear Team, Qihoo 360 Inc.)

Affected

from 1.0.1 before 1.0.1u
from 1.0.2 before 1.0.2i

References

An overflow can occur in MDC2_Update() either if called directly or through the EVP_DigestUpdate() function using MDC2. If an attacker is able to supply very large amounts of input data after a previous call to EVP_EncryptUpdate() with a partial block then a length check can overflow resulting in a heap corruption. The amount of data needed is comparable to SIZE_MAX which is impractical on most platforms.

CVE-2016-6302

Severity

Low

Published at

23 August 2016

Found by

Shi Lei (Gear Team, Qihoo 360 Inc.)

Affected

from 1.0.1 before 1.0.1u
from 1.0.2 before 1.0.2i

References

If a server uses SHA512 for TLS session ticket HMAC it is vulnerable to a DoS attack where a malformed ticket will result in an OOB read which will ultimately crash. The use of SHA512 in TLS session tickets is comparatively rare as it requires a custom server callback and ticket lookup mechanism.

CVE-2016-2183

Severity

Low

Published at

24 August 2016

Title

SWEET32 attack on Triple-DES

Found by

Karthik Bhargavan and Gaetan Leurent from Inria

Affected

from 1.0.2 before 1.0.2i

References

Because DES (and triple-DES) has only a 64-bit block size, birthday attacks are a real concern. For example, with the ability to run Javascript in a browser, it is possible to send enough traffic to cause a collision, and then use that information to recover something like a session Cookie. Triple-DES, which shows up as “DES-CBC3” in an OpenSSL cipher string, is still used on the Web, and major browsers are not yet willing to completely disable it. If you run a server, you should disable triple-DES. This is generally a configuration issue. If you run an old server that doesn’t support any better ciphers than DES or RC4, you should upgrade. For 1.0.2 and 1.0.1, we removed the triple-DES ciphers from the “HIGH” keyword and put them into “MEDIUM.” Note that we did not remove them from the “DEFAULT” keyword. For the 1.1.0 release, we treat triple-DES just like we are treating RC4. It is not compiled by default; you have to use “enable-weak-ssl-ciphers” as a config option. Even when those ciphers are compiled, triple-DES is only in the “MEDIUM” keyword. In addition we also removed it from the “DEFAULT” keyword.

CVE-2016-2182

Severity

Low

Published at

16 August 2016

Found by

Shi Lei (Gear Team, Qihoo 360 Inc.)

Affected

from 1.0.1 before 1.0.1u
from 1.0.2 before 1.0.2i

References

The function BN_bn2dec() does not check the return value of BN_div_word(). This can cause an OOB write if an application uses this function with an overly large BIGNUM. This could be a problem if an overly large certificate or CRL is printed out from an untrusted source. TLS is not affected because record limits will reject an oversized certificate before it is parsed.

CVE-2016-2181

Severity

Low

Published at

19 August 2016

Found by

OCAP audit team

Affected

from 1.0.1 before 1.0.1u
from 1.0.2 before 1.0.2i

References

A flaw in the DTLS replay attack protection mechanism means that records that arrive for future epochs update the replay protection “window” before the MAC for the record has been validated. This could be exploited by an attacker by sending a record for the next epoch (which does not have to decrypt or have a valid MAC), with a very large sequence number. This means that all subsequent legitimate packets are dropped causing a denial of service for a specific DTLS connection.

CVE-2016-2180

Severity

Low

Published at

22 July 2016

Found by

Shi Lei (Gear Team, Qihoo 360 Inc.)

Affected

from 1.0.1 before 1.0.1u
from 1.0.2 before 1.0.2i

References

The function TS_OBJ_print_bio() misuses OBJ_obj2txt(): the return value is the total length the OID text representation would use and not the amount of data written. This will result in OOB reads when large OIDs are presented.

CVE-2016-2179

Severity

Low

Published at

22 August 2016

Found by

Quan Luo

Affected

from 1.0.1 before 1.0.1u
from 1.0.2 before 1.0.2i

References

In a DTLS connection where handshake messages are delivered out-of-order those messages that OpenSSL is not yet ready to process will be buffered for later use. Under certain circumstances, a flaw in the logic means that those messages do not get removed from the buffer even though the handshake has been completed. An attacker could force up to approx. 15 messages to remain in the buffer when they are no longer required. These messages will be cleared when the DTLS connection is closed. The default maximum size for a message is 100k. Therefore the attacker could force an additional 1500k to be consumed per connection. By opening many simulataneous connections an attacker could cause a DoS attack through memory exhaustion.

CVE-2016-2178

Severity

Low

Published at

7 June 2016

Found by

César Pereida (Aalto University), Billy Brumley (Tampere University of Technology), and Yuval Yarom (The University of Adelaide and NICTA)

Affected

from 1.0.1 before 1.0.1u
from 1.0.2 before 1.0.2i

References

Operations in the DSA signing algorithm should run in constant time in order to avoid side channel attacks. A flaw in the OpenSSL DSA implementation means that a non-constant time codepath is followed for certain operations. This has been demonstrated through a cache-timing attack to be sufficient for an attacker to recover the private DSA key.

CVE-2016-2177

Severity

Low

Published at

1 June 2016

Found by

Guido Vranken

Affected

from 1.0.1 before 1.0.1u
from 1.0.2 before 1.0.2i

References

Avoid some undefined pointer arithmetic A common idiom in the codebase is to check limits in the following manner: “p + len > limit” Where “p” points to some malloc’d data of SIZE bytes and limit == p + SIZE “len” here could be from some externally supplied data (e.g. from a TLS message). The rules of C pointer arithmetic are such that “p + len” is only well defined where len <= SIZE. Therefore the above idiom is actually undefined behaviour. For example this could cause problems if some malloc implementation provides an address for “p” such that “p + len” actually overflows for values of len that are too big and therefore p + len < limit.

CVE-2016-2176

Severity

Low

Published at

3 May 2016

Found by

Guido Vranken

Affected

from 1.0.1 before 1.0.1t
from 1.0.2 before 1.0.2h

References

ASN1 Strings that are over 1024 bytes can cause an overread in applications using the X509_NAME_oneline() function on EBCDIC systems. This could result in arbitrary stack data being returned in the buffer.

CVE-2016-2109

Severity

Low

Published at

3 May 2016

Found by

Brian Carpenter

Affected

from 1.0.1 before 1.0.1t
from 1.0.2 before 1.0.2h

References

When ASN.1 data is read from a BIO using functions such as d2i_CMS_bio() a short invalid encoding can casuse allocation of large amounts of memory potentially consuming excessive resources or exhausting memory. Any application parsing untrusted data through d2i BIO functions is affected. The memory based functions such as d2i_X509() are not affected. Since the memory based functions are used by the TLS library, TLS applications are not affected.

CVE-2016-2108

Severity

High

Published at

3 May 2016

Found by

Huzaifa Sidhpurwala (Red Hat), Hanno Böck, David Benjamin (Google)

Affected

from 1.0.1 before 1.0.1o
from 1.0.2 before 1.0.2c

References

This issue affected versions of OpenSSL prior to April 2015. The bug causing the vulnerability was fixed on April 18th 2015, and released as part of the June 11th 2015 security releases. The security impact of the bug was not known at the time. In previous versions of OpenSSL, ASN.1 encoding the value zero represented as a negative integer can cause a buffer underflow with an out-of-bounds write in i2c_ASN1_INTEGER. The ASN.1 parser does not normally create “negative zeroes” when parsing ASN.1 input, and therefore, an attacker cannot trigger this bug. However, a second, independent bug revealed that the ASN.1 parser (specifically, d2i_ASN1_TYPE) can misinterpret a large universal tag as a negative zero value. Large universal tags are not present in any common ASN.1 structures (such as X509) but are accepted as part of ANY structures. Therefore, if an application deserializes untrusted ASN.1 structures containing an ANY field, and later reserializes them, an attacker may be able to trigger an out-of-bounds write. This has been shown to cause memory corruption that is potentially exploitable with some malloc implementations. Applications that parse and re-encode X509 certificates are known to be vulnerable. Applications that verify RSA signatures on X509 certificates may also be vulnerable; however, only certificates with valid signatures trigger ASN.1 re-encoding and hence the bug. Specifically, since OpenSSL’s default TLS X509 chain verification code verifies the certificate chain from root to leaf, TLS handshakes could only be targeted with valid certificates issued by trusted Certification Authorities.

CVE-2016-2107

Severity

High

Published at

3 May 2016

Found by

Juraj Somorovsky

Affected

from 1.0.1 before 1.0.1t
from 1.0.2 before 1.0.2h

References

A MITM attacker can use a padding oracle attack to decrypt traffic when the connection uses an AES CBC cipher and the server support AES-NI. This issue was introduced as part of the fix for Lucky 13 padding attack (CVE-2013-0169). The padding check was rewritten to be in constant time by making sure that always the same bytes are read and compared against either the MAC or padding bytes. But it no longer checked that there was enough data to have both the MAC and padding bytes.

CVE-2016-2106

Severity

Low

Published at

3 May 2016

Found by

Guido Vranken

Affected

from 1.0.1 before 1.0.1t
from 1.0.2 before 1.0.2h

References

An overflow can occur in the EVP_EncryptUpdate() function. If an attacker is able to supply very large amounts of input data after a previous call to EVP_EncryptUpdate() with a partial block then a length check can overflow resulting in a heap corruption. Following an analysis of all OpenSSL internal usage of the EVP_EncryptUpdate() function all usage is one of two forms. The first form is where the EVP_EncryptUpdate() call is known to be the first called function after an EVP_EncryptInit(), and therefore that specific call must be safe. The second form is where the length passed to EVP_EncryptUpdate() can be seen from the code to be some small value and therefore there is no possibility of an overflow. Since all instances are one of these two forms, it is believed that there can be no overflows in internal code due to this problem. It should be noted that EVP_DecryptUpdate() can call EVP_EncryptUpdate() in certain code paths. Also EVP_CipherUpdate() is a synonym for EVP_EncryptUpdate(). All instances of these calls have also been analysed too and it is believed there are no instances in internal usage where an overflow could occur. This could still represent a security issue for end user code that calls this function directly.

CVE-2016-2105

Severity

Low

Published at

3 May 2016

Found by

Guido Vranken

Affected

from 1.0.1 before 1.0.1t
from 1.0.2 before 1.0.2h

References

An overflow can occur in the EVP_EncodeUpdate() function which is used for Base64 encoding of binary data. If an attacker is able to supply very large amounts of input data then a length check can overflow resulting in a heap corruption. Internally to OpenSSL the EVP_EncodeUpdate() function is primarly used by the PEM_write_bio* family of functions. These are mainly used within the OpenSSL command line applications. These internal uses are not considered vulnerable because all calls are bounded with length checks so no overflow is possible. User applications that call these APIs directly with large amounts of untrusted data may be vulnerable. (Note: Initial analysis suggested that the PEM_write_bio* were vulnerable, and this is reflected in the patch commit message. This is no longer believed to be the case).

CVE-2016-0800

Severity

High

Published at

1 March 2016

Found by

Nimrod Aviram and Sebastian Schinzel

Affected

from 1.0.1 before 1.0.1s
from 1.0.2 before 1.0.2g

References

A cross-protocol attack was discovered that could lead to decryption of TLS sessions by using a server supporting SSLv2 and EXPORT cipher suites as a Bleichenbacher RSA padding oracle. Note that traffic between clients and non-vulnerable servers can be decrypted provided another server supporting SSLv2 and EXPORT ciphers (even with a different protocol such as SMTP, IMAP or POP) shares the RSA keys of the non-vulnerable server. This vulnerability is known as DROWN (CVE-2016-0800). Recovering one session key requires the attacker to perform approximately 2^50 computation, as well as thousands of connections to the affected server. A more efficient variant of the DROWN attack exists against unpatched OpenSSL servers using versions that predate 1.0.2a, 1.0.1m, 1.0.0r and 0.9.8zf released on 19/Mar/2015 (see CVE-2016-0703 below). Users can avoid this issue by disabling the SSLv2 protocol in all their SSL/TLS servers, if they’ve not done so already. Disabling all SSLv2 ciphers is also sufficient, provided the patches for CVE-2015-3197 (fixed in OpenSSL 1.0.1r and 1.0.2f) have been deployed. Servers that have not disabled the SSLv2 protocol, and are not patched for CVE-2015-3197 are vulnerable to DROWN even if all SSLv2 ciphers are nominally disabled, because malicious clients can force the use of SSLv2 with EXPORT ciphers. OpenSSL 1.0.2g and 1.0.1s deploy the following mitigation against DROWN: SSLv2 is now by default disabled at build-time. Builds that are not configured with “enable-ssl2” will not support SSLv2. Even if “enable-ssl2” is used, users who want to negotiate SSLv2 via the version-flexible SSLv23_method() will need to explicitly call either of: SSL_CTX_clear_options(ctx, SSL_OP_NO_SSLv2); or SSL_clear_options(ssl, SSL_OP_NO_SSLv2); as appropriate. Even if either of those is used, or the application explicitly uses the version-specific SSLv2_method() or its client or server variants, SSLv2 ciphers vulnerable to exhaustive search key recovery have been removed. Specifically, the SSLv2 40-bit EXPORT ciphers, and SSLv2 56-bit DES are no longer available. In addition, weak ciphers in SSLv3 and up are now disabled in default builds of OpenSSL. Builds that are not configured with “enable-weak-ssl-ciphers” will not provide any “EXPORT” or “LOW” strength ciphers.

CVE-2016-0799

Severity

Low

Published at

1 March 2016

Found by

Guido Vranken

Affected

from 1.0.1 before 1.0.1s
from 1.0.2 before 1.0.2g

References

The internal |fmtstr| function used in processing a “%s” format string in the BIO_*printf functions could overflow while calculating the length of a string and cause an OOB read when printing very long strings. Additionally the internal |doapr_outch| function can attempt to write to an OOB memory location (at an offset from the NULL pointer) in the event of a memory allocation failure. In 1.0.2 and below this could be caused where the size of a buffer to be allocated is greater than INT_MAX. E.g. this could be in processing a very long “%s” format string. Memory leaks can also occur. The first issue may mask the second issue dependent on compiler behaviour. These problems could enable attacks where large amounts of untrusted data is passed to the BIO_*printf functions. If applications use these functions in this way then they could be vulnerable. OpenSSL itself uses these functions when printing out human-readable dumps of ASN.1 data. Therefore applications that print this data could be vulnerable if the data is from untrusted sources. OpenSSL command line applications could also be vulnerable where they print out ASN.1 data, or if untrusted data is passed as command line arguments. Libssl is not considered directly vulnerable. Additionally certificates etc received via remote connections via libssl are also unlikely to be able to trigger these issues because of message size limits enforced within libssl.

CVE-2016-0798

Severity

Low

Published at

1 March 2016

Found by

Emilia Käsper (OpenSSL)

Affected

from 1.0.1 before 1.0.1s
from 1.0.2 before 1.0.2g

References

The SRP user database lookup method SRP_VBASE_get_by_user had confusing memory management semantics; the returned pointer was sometimes newly allocated, and sometimes owned by the callee. The calling code has no way of distinguishing these two cases. Specifically, SRP servers that configure a secret seed to hide valid login information are vulnerable to a memory leak: an attacker connecting with an invalid username can cause a memory leak of around 300 bytes per connection. Servers that do not configure SRP, or configure SRP but do not configure a seed are not vulnerable. In Apache, the seed directive is known as SSLSRPUnknownUserSeed. To mitigate the memory leak, the seed handling in SRP_VBASE_get_by_user is now disabled even if the user has configured a seed. Applications are advised to migrate to SRP_VBASE_get1_by_user. However, note that OpenSSL makes no strong guarantees about the indistinguishability of valid and invalid logins. In particular, computations are currently not carried out in constant time.

CVE-2016-0797

Severity

Low

Published at

1 March 2016

Found by

Guido Vranken

Affected

from 1.0.1 before 1.0.1s
from 1.0.2 before 1.0.2g

References

In the BN_hex2bn function the number of hex digits is calculated using an int value |i|. Later |bn_expand| is called with a value of |i * 4|. For large values of |i| this can result in |bn_expand| not allocating any memory because |i * 4| is negative. This can leave the internal BIGNUM data field as NULL leading to a subsequent NULL ptr deref. For very large values of |i|, the calculation |i * 4| could be a positive value smaller than |i|. In this case memory is allocated to the internal BIGNUM data field, but it is insufficiently sized leading to heap corruption. A similar issue exists in BN_dec2bn. This could have security consequences if BN_hex2bn/BN_dec2bn is ever called by user applications with very large untrusted hex/dec data. This is anticipated to be a rare occurrence. All OpenSSL internal usage of these functions use data that is not expected to be untrusted, e.g. config file data or application command line arguments. If user developed applications generate config file data based on untrusted data then it is possible that this could also lead to security consequences. This is also anticipated to be rare.

CVE-2016-0705

Severity

Low

Published at

1 March 2016

Found by

Adam Langley (Google/BoringSSL)

Affected

from 1.0.1 before 1.0.1s
from 1.0.2 before 1.0.2g

References

A double free bug was discovered when OpenSSL parses malformed DSA private keys and could lead to a DoS attack or memory corruption for applications that receive DSA private keys from untrusted sources. This scenario is considered rare.

CVE-2016-0704

Severity

Moderate

Published at

1 March 2016

Found by

David Adrian and J.Alex Halderman (University of Michigan)

Affected

from 0.9.8 before 0.9.8zf
from 1.0.0 before 1.0.0r
from 1.0.1 before 1.0.1m
from 1.0.2 before 1.0.2a

References

This issue only affected versions of OpenSSL prior to March 19th 2015 at which time the code was refactored to address the vulnerability CVE-2015-0293. s2_srvr.c overwrite the wrong bytes in the master-key when applying Bleichenbacher protection for export cipher suites. This provides a Bleichenbacher oracle, and could potentially allow more efficient variants of the DROWN attack.

CVE-2016-0703

Severity

High

Published at

1 March 2016

Found by

David Adrian and J.Alex Halderman (University of Michigan)

Affected

from 0.9.8 before 0.9.8zf
from 1.0.0 before 1.0.0r
from 1.0.1 before 1.0.1m
from 1.0.2 before 1.0.2a

References

This issue only affected versions of OpenSSL prior to March 19th 2015 at which time the code was refactored to address vulnerability CVE-2015-0293. s2_srvr.c did not enforce that clear-key-length is 0 for non-export ciphers. If clear-key bytes are present for these ciphers, they displace encrypted-key bytes. This leads to an efficient divide-and-conquer key recovery attack: if an eavesdropper has intercepted an SSLv2 handshake, they can use the server as an oracle to determine the SSLv2 master-key, using only 16 connections to the server and negligible computation. More importantly, this leads to a more efficient version of DROWN that is effective against non-export ciphersuites, and requires no significant computation.

CVE-2016-0702

Severity

Low

Published at

1 March 2016

Found by

Yuval Yarom, The University of Adelaide and NICTA, Daniel Genkin, Technion and Tel Aviv University, and Nadia Heninger, University of Pennsylvania

Affected

from 1.0.1 before 1.0.1s
from 1.0.2 before 1.0.2g

References

A side-channel attack was found which makes use of cache-bank conflicts on the Intel Sandy-Bridge microarchitecture which could lead to the recovery of RSA keys. The ability to exploit this issue is limited as it relies on an attacker who has control of code in a thread running on the same hyper-threaded core as the victim thread which is performing decryptions.

CVE-2016-0701

Severity

High

Published at

28 January 2016

Found by

Antonio Sanso (Adobe)

Affected

from 1.0.2 before 1.0.2f

References

Historically OpenSSL usually only ever generated DH parameters based on “safe” primes. More recently (in version 1.0.2) support was provided for generating X9.42 style parameter files such as those required for RFC 5114 support. The primes used in such files may not be “safe”. Where an application is using DH configured with parameters based on primes that are not “safe” then an attacker could use this fact to find a peer’s private DH exponent. This attack requires that the attacker complete multiple handshakes in which the peer uses the same private DH exponent. For example this could be used to discover a TLS server’s private DH exponent if it’s reusing the private DH exponent or it’s using a static DH ciphersuite. OpenSSL provides the option SSL_OP_SINGLE_DH_USE for ephemeral DH (DHE) in TLS. It is not on by default. If the option is not set then the server reuses the same private DH exponent for the life of the server process and would be vulnerable to this attack. It is believed that many popular applications do set this option and would therefore not be at risk. OpenSSL before 1.0.2f will reuse the key if: - SSL_CTX_set_tmp_dh()/SSL_set_tmp_dh() is used and SSL_OP_SINGLE_DH_USE is not set. - SSL_CTX_set_tmp_dh_callback()/SSL_set_tmp_dh_callback() is used, and both the parameters and the key are set and SSL_OP_SINGLE_DH_USE is not used. This is an undocumted feature and parameter files don’t contain the key. - Static DH ciphersuites are used. The key is part of the certificate and so it will always reuse it. This is only supported in 1.0.2. It will not reuse the key for DHE ciphers suites if: - SSL_OP_SINGLE_DH_USE is set - SSL_CTX_set_tmp_dh_callback()/SSL_set_tmp_dh_callback() is used and the callback does not provide the key, only the parameters. The callback is almost always used like this. Non-safe primes are generated by OpenSSL when using: - genpkey with the dh_rfc5114 option. This will write an X9.42 style file including the prime-order subgroup size “q”. This is supported since the 1.0.2 version. Older versions can’t read files generated in this way. - dhparam with the -dsaparam option. This has always been documented as requiring the single use. The fix for this issue adds an additional check where a “q” parameter is available (as is the case in X9.42 based parameters). This detects the only known attack, and is the only possible defense for static DH ciphersuites. This could have some performance impact. Additionally the SSL_OP_SINGLE_DH_USE option has been switched on by default and cannot be disabled. This could have some performance impact.

CVE-2015-3197

Severity

Low

Published at

28 January 2016

Found by

Nimrod Aviram and Sebastian Schinzel

Affected

from 1.0.1 before 1.0.1r
from 1.0.2 before 1.0.2f

References

A malicious client can negotiate SSLv2 ciphers that have been disabled on the server and complete SSLv2 handshakes even if all SSLv2 ciphers have been disabled, provided that the SSLv2 protocol was not also disabled via SSL_OP_NO_SSLv2.

2015

CVE-2015-3196

Severity

Low

Published at

3 December 2015

Found by

Stephen Henson (OpenSSL)

Affected

from 1.0.2 before 1.0.2d
from 1.0.1 before 1.0.1p
from 1.0.0 before 1.0.0t

References

If PSK identity hints are received by a multi-threaded client then the values are wrongly updated in the parent SSL_CTX structure. This can result in a race condition potentially leading to a double free of the identify hint data.

CVE-2015-3195

Severity

Moderate

Published at

3 December 2015

Found by

Adam Langley (Google/BoringSSL) using libFuzzer

Affected

from 1.0.2 before 1.0.2e
from 1.0.1 before 1.0.1q
from 1.0.0 before 1.0.0t
from 0.9.8 before 0.9.8zh

References

When presented with a malformed X509_ATTRIBUTE structure OpenSSL will leak memory. This structure is used by the PKCS#7 and CMS routines so any application which reads PKCS#7 or CMS data from untrusted sources is affected. SSL/TLS is not affected.

CVE-2015-3194

Severity

Moderate

Published at

3 December 2015

Found by

Loïc Jonas Etienne (Qnective AG)

Affected

from 1.0.2 before 1.0.2e
from 1.0.1 before 1.0.1q

References

The signature verification routines will crash with a NULL pointer dereference if presented with an ASN.1 signature using the RSA PSS algorithm and absent mask generation function parameter. Since these routines are used to verify certificate signature algorithms this can be used to crash any certificate verification operation and exploited in a DoS attack. Any application which performs certificate verification is vulnerable including OpenSSL clients and servers which enable client authentication.

CVE-2015-3193

Severity

Moderate

Published at

3 December 2015

Found by

Hanno Böck

Affected

from 1.0.2 before 1.0.2e

References

There is a carry propagating bug in the x86_64 Montgomery squaring procedure. No EC algorithms are affected. Analysis suggests that attacks against RSA and DSA as a result of this defect would be very difficult to perform and are not believed likely. Attacks against DH are considered just feasible (although very difficult) because most of the work necessary to deduce information about a private key may be performed offline. The amount of resources required for such an attack would be very significant and likely only accessible to a limited number of attackers. An attacker would additionally need online access to an unpatched system using the target private key in a scenario with persistent DH parameters and a private key that is shared between multiple clients. For example this can occur by default in OpenSSL DHE based SSL/TLS ciphersuites.

CVE-2015-1794

Severity

Low

Published at

11 August 2015

Found by

Guy Leaver (Cisco)

Affected

from 1.0.2 before 1.0.2e

References

If a client receives a ServerKeyExchange for an anonymous DH ciphersuite with the value of p set to 0 then a seg fault can occur leading to a possible denial of service attack.

CVE-2015-1793

Severity

High

Published at

9 July 2015

Found by

Adam Langley and David Benjamin (Google/BoringSSL)

Affected

from 1.0.2b before 1.0.2d
from 1.0.1n before 1.0.1p

References

An error in the implementation of the alternative certificate chain logic could allow an attacker to cause certain checks on untrusted certificates to be bypassed, such as the CA flag, enabling them to use a valid leaf certificate to act as a CA and “issue” an invalid certificate.

CVE-2015-1792

Severity

Moderate

Published at

11 June 2015

Found by

Johannes Bauer

Affected

from 1.0.2 before 1.0.2b
from 1.0.1 before 1.0.1n
from 1.0.0 before 1.0.0s
from 0.9.8 before 0.9.8zg

References

When verifying a signedData message the CMS code can enter an infinite loop if presented with an unknown hash function OID. This can be used to perform denial of service against any system which verifies signedData messages using the CMS code.

CVE-2015-1791

Severity

Low

Published at

2 June 2015

Found by

Emilia Käsper (OpenSSL)

Affected

from 1.0.2 before 1.0.2b
from 1.0.1 before 1.0.1n
from 1.0.0 before 1.0.0s
from 0.9.8 before 0.9.8zg

References

If a NewSessionTicket is received by a multi-threaded client when attempting to reuse a previous ticket then a race condition can occur potentially leading to a double free of the ticket data.

CVE-2015-1790

Severity

Moderate

Published at

11 June 2015

Found by

Michal Zalewski (Google)

Affected

from 1.0.2 before 1.0.2b
from 1.0.1 before 1.0.1n
from 1.0.0 before 1.0.0s
from 0.9.8 before 0.9.8zg

References

The PKCS#7 parsing code does not handle missing inner EncryptedContent correctly. An attacker can craft malformed ASN.1-encoded PKCS#7 blobs with missing content and trigger a NULL pointer dereference on parsing. Applications that decrypt PKCS#7 data or otherwise parse PKCS#7 structures from untrusted sources are affected. OpenSSL clients and servers are not affected.

CVE-2015-1789

Severity

Moderate

Published at

11 June 2015

Found by

Robert Święcki (Google Security Team)

Affected

from 1.0.2 before 1.0.2b
from 1.0.1 before 1.0.1n
from 1.0.0 before 1.0.0s
from 0.9.8 before 0.9.8zg

References

X509_cmp_time does not properly check the length of the ASN1_TIME string and can read a few bytes out of bounds. In addition, X509_cmp_time accepts an arbitrary number of fractional seconds in the time string. An attacker can use this to craft malformed certificates and CRLs of various sizes and potentially cause a segmentation fault, resulting in a DoS on applications that verify certificates or CRLs. TLS clients that verify CRLs are affected. TLS clients and servers with client authentication enabled may be affected if they use custom verification callbacks.

CVE-2015-1788

Severity

Moderate

Published at

11 June 2015

Found by

Joseph Birr-Pixton

Affected

from 1.0.2 before 1.0.2b
from 1.0.1 before 1.0.1n
from 1.0.0 before 1.0.0e
from 0.9.8 before 0.9.8s

References

When processing an ECParameters structure OpenSSL enters an infinite loop if the curve specified is over a specially malformed binary polynomial field. This can be used to perform denial of service against any system which processes public keys, certificate requests or certificates. This includes TLS clients and TLS servers with client authentication enabled.

CVE-2015-1787

Severity

Moderate

Published at

19 March 2015

Found by

Matt Caswell (OpenSSL development team)

Affected

from 1.0.2 before 1.0.2a

References

Empty CKE with client auth and DHE. If client auth is used then a server can seg fault in the event of a DHE ciphersuite being selected and a zero length ClientKeyExchange message being sent by the client. This could be exploited in a DoS attack.

CVE-2015-0293

Severity

Moderate

Published at

19 March 2015

Found by

Sean Burford (Google) and Emilia Käsper (OpenSSL development team)

Affected

from 1.0.2 before 1.0.2a
from 1.0.1 before 1.0.1m
from 1.0.0 before 1.0.0r
from 0.9.8 before 0.9.8zf

References

DoS via reachable assert in SSLv2 servers. A malicious client can trigger an OPENSSL_assert in servers that both support SSLv2 and enable export cipher suites by sending a specially crafted SSLv2 CLIENT-MASTER-KEY message.

CVE-2015-0292

Severity

Moderate

Published at

19 March 2015

Found by

Robert Dugal, also David Ramos, also Huzaifa Sidhpurwala (Red Hat)

Affected

from 1.0.1 before 1.0.1h
from 1.0.0 before 1.0.0m
from 0.9.8 before 0.9.8za

References

A vulnerability existed in previous versions of OpenSSL related to the processing of base64 encoded data. Any code path that reads base64 data from an untrusted source could be affected (such as the PEM processing routines). Maliciously crafted base 64 data could trigger a segmenation fault or memory corruption.

CVE-2015-0291

Severity

High

Published at

19 March 2015

Found by

David Ramos (Stanford University)

Affected

from 1.0.2 before 1.0.2a

References

ClientHello sigalgs DoS. If a client connects to an OpenSSL 1.0.2 server and renegotiates with an invalid signature algorithms extension a NULL pointer dereference will occur. This can be exploited in a DoS attack against the server.

CVE-2015-0290

Severity

Moderate

Published at

19 March 2015

Found by

Daniel Danner and Rainer Mueller

Affected

from 1.0.2 before 1.0.2a

References

Multiblock corrupted pointer. OpenSSL 1.0.2 introduced the “multiblock” performance improvement. This feature only applies on 64 bit x86 architecture platforms that support AES NI instructions. A defect in the implementation of “multiblock” can cause OpenSSL’s internal write buffer to become incorrectly set to NULL when using non-blocking IO. Typically, when the user application is using a socket BIO for writing, this will only result in a failed connection. However if some other BIO is used then it is likely that a segmentation fault will be triggered, thus enabling a potential DoS attack.

CVE-2015-0289

Severity

Moderate

Published at

19 March 2015

Found by

Michal Zalewski (Google)

Affected

from 1.0.2 before 1.0.2a
from 1.0.1 before 1.0.1m
from 1.0.0 before 1.0.0r
from 0.9.8 before 0.9.8zf

References

PKCS#7 NULL pointer dereference. The PKCS#7 parsing code does not handle missing outer ContentInfo correctly. An attacker can craft malformed ASN.1-encoded PKCS#7 blobs with missing content and trigger a NULL pointer dereference on parsing. Applications that verify PKCS#7 signatures, decrypt PKCS#7 data or otherwise parse PKCS#7 structures from untrusted sources are affected. OpenSSL clients and servers are not affected.

CVE-2015-0288

Severity

Low

Published at

2 March 2015

Found by

Brian Carpenter

Affected

from 1.0.2 before 1.0.2a
from 1.0.1 before 1.0.1m
from 1.0.0 before 1.0.0r
from 0.9.8 before 0.9.8zf

References

X509_to_X509_REQ NULL pointer deref. The function X509_to_X509_REQ will crash with a NULL pointer dereference if the certificate key is invalid. This function is rarely used in practice.

CVE-2015-0287

Severity

Moderate

Published at

19 March 2015

Found by

Emilia Käsper (OpenSSL development team)

Affected

from 1.0.2 before 1.0.2a
from 1.0.1 before 1.0.1m
from 1.0.0 before 1.0.0r
from 0.9.8 before 0.9.8zf

References

ASN.1 structure reuse memory corruption. Reusing a structure in ASN.1 parsing may allow an attacker to cause memory corruption via an invalid write. Such reuse is and has been strongly discouraged and is believed to be rare.

CVE-2015-0286

Severity

Moderate

Published at

19 March 2015

Found by

Stephen Henson (OpenSSL development team)

Affected

from 1.0.2 before 1.0.2a
from 1.0.1 before 1.0.1m
from 1.0.0 before 1.0.0r
from 0.9.8zd before 0.9.8zf

References

Segmentation fault in ASN1_TYPE_cmp. The function ASN1_TYPE_cmp will crash with an invalid read if an attempt is made to compare ASN.1 boolean types. Since ASN1_TYPE_cmp is used to check certificate signature algorithm consistency this can be used to crash any certificate verification operation and exploited in a DoS attack. Any application which performs certificate verification is vulnerable including OpenSSL clients and servers which enable client authentication.

CVE-2015-0285

Severity

Low

Published at

10 March 2015

Found by

Matt Caswell (OpenSSL development team)

Affected

from 1.0.2 before 1.0.2a

References

Under certain conditions an OpenSSL 1.0.2 client can complete a handshake with an unseeded PRNG. If the handshake succeeds then the client random that has been used will have been generated from a PRNG with insufficient entropy and therefore the output may be predictable.

CVE-2015-0209

Severity

Low

Published at

19 March 2015

Found by

The BoringSSL project

Affected

from 1.0.2 before 1.0.2a
from 1.0.1 before 1.0.1m
from 1.0.0 before 1.0.0r
from 0.9.8 before 0.9.8zf

References

Use After Free following d2i_ECPrivatekey error. A malformed EC private key file consumed via the d2i_ECPrivateKey function could cause a use after free condition. This, in turn, could cause a double free in several private key parsing functions (such as d2i_PrivateKey or EVP_PKCS82PKEY) and could lead to a DoS attack or memory corruption for applications that receive EC private keys from untrusted sources. This scenario is considered rare.

CVE-2015-0208

Severity

Moderate

Published at

19 March 2015

Found by

Brian Carpenter

Affected

from 1.0.2 before 1.0.2a

References

Segmentation fault for invalid PSS parameters. The signature verification routines will crash with a NULL pointer dereference if presented with an ASN.1 signature using the RSA PSS algorithm and invalid parameters. Since these routines are used to verify certificate signature algorithms this can be used to crash any certificate verification operation and exploited in a DoS attack. Any application which performs certificate verification is vulnerable including OpenSSL clients and servers which enable client authentication.

CVE-2015-0207

Severity

Moderate

Published at

19 March 2015

Found by

Per Allansson

Affected

from 1.0.2 before 1.0.2a

References

Segmentation fault in DTLSv1_listen. A defect in the implementation of DTLSv1_listen means that state is preserved in the SSL object from one invocation to the next that can lead to a segmentation fault. Errors processing the initial ClientHello can trigger this scenario. An example of such an error could be that a DTLS1.0 only client is attempting to connect to a DTLS1.2 only server.

CVE-2015-0206

Severity

Moderate

Published at

8 January 2015

Found by

Chris Mueller

Affected

from 1.0.1 before 1.0.1k
from 1.0.0 before 1.0.0p

References

A memory leak can occur in the dtls1_buffer_record function under certain conditions. In particular this could occur if an attacker sent repeated DTLS records with the same sequence number but for the next epoch. The memory leak could be exploited by an attacker in a Denial of Service attack through memory exhaustion.

CVE-2015-0205

Severity

Low

Published at

8 January 2015

Found by

Karthikeyan Bhargavan of the PROSECCO team at INRIA

Affected

from 1.0.1 before 1.0.1k
from 1.0.0 before 1.0.0p

References

An OpenSSL server will accept a DH certificate for client authentication without the certificate verify message. This effectively allows a client to authenticate without the use of a private key. This only affects servers which trust a client certificate authority which issues certificates containing DH keys: these are extremely rare and hardly ever encountered.

CVE-2015-0204

Severity

Low

Published at

6 January 2015

Found by

Karthikeyan Bhargavan of the PROSECCO team at INRIA

Affected

from 1.0.1 before 1.0.1k
from 1.0.0 before 1.0.0p
from 0.9.8 before 0.9.8zd

References

An OpenSSL client will accept the use of an RSA temporary key in a non-export RSA key exchange ciphersuite. A server could present a weak temporary key and downgrade the security of the session.

CVE-2014-8275

Severity

Low

Published at

5 January 2015

Found by

Antti Karjalainen and Tuomo Untinen from the Codenomicon CROSS program/Konrad Kraszewski from Google

Affected

from 1.0.1 before 1.0.1k
from 1.0.0 before 1.0.0p
from 0.9.8 before 0.9.8zd

References

OpenSSL accepts several non-DER-variations of certificate signature algorithm and signature encodings. OpenSSL also does not enforce a match between the signature algorithm between the signed and unsigned portions of the certificate. By modifying the contents of the signature algorithm or the encoding of the signature, it is possible to change the certificate’s fingerprint. This does not allow an attacker to forge certificates, and does not affect certificate verification or OpenSSL servers/clients in any other way. It also does not affect common revocation mechanisms. Only custom applications that rely on the uniqueness of the fingerprint (e.g. certificate blacklists) may be affected.

CVE-2014-8176

Severity

Moderate

Published at

11 June 2015

Found by

Praveen Kariyanahalli, and subsequently by Ivan Fratric and Felix Groebert (Google)

Affected

from 1.0.1 before 1.0.1h
from 1.0.0 before 1.0.0m
from 0.9.8 before 0.9.8za

References

This vulnerability does not affect current versions of OpenSSL. It existed in previous OpenSSL versions and was fixed in June 2014. If a DTLS peer receives application data between the ChangeCipherSpec and Finished messages, buffering of such data may cause an invalid free, resulting in a segmentation fault or potentially, memory corruption.

CVE-2014-3572

Severity

Low

Published at

5 January 2015

Found by

Karthikeyan Bhargavan of the PROSECCO team at INRIA

Affected

from 1.0.1 before 1.0.1k
from 1.0.0 before 1.0.0p
from 0.9.8 before 0.9.8zd

References

An OpenSSL client will accept a handshake using an ephemeral ECDH ciphersuite using an ECDSA certificate if the server key exchange message is omitted. This effectively removes forward secrecy from the ciphersuite.

CVE-2014-3571

Severity

Moderate

Published at

5 January 2015

Found by

Markus Stenberg of Cisco Systems, Inc

Affected

from 1.0.1 before 1.0.1k
from 1.0.0 before 1.0.0p
from 0.9.8 before 0.9.8zd

References

A carefully crafted DTLS message can cause a segmentation fault in OpenSSL due to a NULL pointer dereference. This could lead to a Denial Of Service attack.

CVE-2014-3570

Severity

Low

Published at

8 January 2015

Found by

Pieter Wuille (Blockstream)

Affected

from 1.0.1 before 1.0.1k
from 1.0.0 before 1.0.0p
from 0.9.8 before 0.9.8zd

References

Bignum squaring (BN_sqr) may produce incorrect results on some platforms, including x86_64. This bug occurs at random with a very low probability, and is not known to be exploitable in any way, though its exact impact is difficult to determine. The following has been determined: *) The probability of BN_sqr producing an incorrect result at random is very low: 1/2^64 on the single affected 32-bit platform (MIPS) and 1/2^128 on affected 64-bit platforms. *) On most platforms, RSA follows a different code path and RSA operations are not affected at all. For the remaining platforms (e.g. OpenSSL built without assembly support), pre-existing countermeasures thwart bug attacks [1]. *) Static ECDH is theoretically affected: it is possible to construct elliptic curve points that would falsely appear to be on the given curve. However, there is no known computationally feasible way to construct such points with low order, and so the security of static ECDH private keys is believed to be unaffected. *) Other routines known to be theoretically affected are modular exponentiation, primality testing, DSA, RSA blinding, JPAKE and SRP. No exploits are known and straightforward bug attacks fail - either the attacker cannot control when the bug triggers, or no private key material is involved.

2014

CVE-2014-5139

Published at

6 August 2014

Found by

Joonas Kuorilehto and Riku Hietamäki (Codenomicon)

Affected

from 1.0.1 before 1.0.1i

References

A crash was found affecting SRP ciphersuites used in a Server Hello message. The issue affects OpenSSL clients and allows a malicious server to crash the client with a null pointer dereference (read) by specifying an SRP ciphersuite even though it was not properly negotiated with the client. This could lead to a Denial of Service.

CVE-2014-3569

Severity

Low

Published at

21 October 2014

Found by

Frank Schmirler

Affected

from 1.0.1j before 1.0.1k
from 1.0.0o before 1.0.0p
from 0.9.8zc before 0.9.8zd

References

When openssl is built with the no-ssl3 option and a SSL v3 ClientHello is received the ssl method would be set to NULL which could later result in a NULL pointer dereference.

CVE-2014-3568

Severity

Low

Published at

15 October 2014

Found by

Akamai Technologies

Affected

from 1.0.1 before 1.0.1j
from 1.0.0 before 1.0.0o
from 0.9.8 before 0.9.8zc

References

When OpenSSL is configured with “no-ssl3” as a build option, servers could accept and complete a SSL 3.0 handshake, and clients could be configured to send them.

CVE-2014-3567

Severity

Moderate

Published at

15 October 2014

Affected

from 1.0.1 before 1.0.1j
from 1.0.0 before 1.0.0o
from 0.9.8g before 0.9.8zc

References

When an OpenSSL SSL/TLS/DTLS server receives a session ticket the integrity of that ticket is first verified. In the event of a session ticket integrity check failing, OpenSSL will fail to free memory causing a memory leak. By sending a large number of invalid session tickets an attacker could exploit this issue in a Denial Of Service attack.

CVE-2014-3513

Severity

High

Published at

15 October 2014

Found by

LibreSSL project

Affected

from 1.0.1 before 1.0.1j

References

A flaw in the DTLS SRTP extension parsing code allows an attacker, who sends a carefully crafted handshake message, to cause OpenSSL to fail to free up to 64k of memory causing a memory leak. This could be exploited in a Denial Of Service attack. This issue affects OpenSSL 1.0.1 server implementations for both SSL/TLS and DTLS regardless of whether SRTP is used or configured. Implementations of OpenSSL that have been compiled with OPENSSL_NO_SRTP defined are not affected.

CVE-2014-3512

Published at

6 August 2014

Found by

Sean Devlin and Watson Ladd (Cryptography Services, NCC Group)

Affected

from 1.0.1 before 1.0.1i

References

A SRP buffer overrun was found. A malicious client or server can send invalid SRP parameters and overrun an internal buffer. Only applications which are explicitly set up for SRP use are affected.

CVE-2014-3511

Published at

6 August 2014

Found by

David Benjamin and Adam Langley (Google)

Affected

from 1.0.1 before 1.0.1i

References

A flaw in the OpenSSL SSL/TLS server code causes the server to negotiate TLS 1.0 instead of higher protocol versions when the ClientHello message is badly fragmented. This allows a man-in-the-middle attacker to force a downgrade to TLS 1.0 even if both the server and the client support a higher protocol version, by modifying the client’s TLS records.

CVE-2014-3510

Published at

6 August 2014

Found by

Felix Gröbert (Google)

Affected

from 1.0.1 before 1.0.1i
from 1.0.0 before 1.0.0n
from 0.9.8 before 0.9.8zb

References

A flaw in handling DTLS anonymous EC(DH) ciphersuites was found. OpenSSL DTLS clients enabling anonymous (EC)DH ciphersuites are subject to a denial of service attack. A malicious server can crash the client with a null pointer dereference (read) by specifying an anonymous (EC)DH ciphersuite and sending carefully crafted handshake messages.

CVE-2014-3509

Published at

6 August 2014

Found by

Gabor Tyukasz (LogMeIn Inc)

Affected

from 1.0.1 before 1.0.1i
from 1.0.0 before 1.0.0n

References

A race condition was found in ssl_parse_serverhello_tlsext. If a multithreaded client connects to a malicious server using a resumed session and the server sends an ec point format extension, it could write up to 255 bytes to freed memory.

CVE-2014-3508

Published at

6 August 2014

Found by

Ivan Fratric (Google)

Affected

from 1.0.1 before 1.0.1i
from 1.0.0 before 1.0.0n
from 0.9.8 before 0.9.8zb

References

A flaw in OBJ_obj2txt may cause pretty printing functions such as X509_name_oneline, X509_name_print_ex, to leak some information from the stack. Applications may be affected if they echo pretty printing output to the attacker. OpenSSL SSL/TLS clients and servers themselves are not affected.

CVE-2014-3507

Published at

6 August 2014

Found by

Adam Langley (Google)

Affected

from 1.0.1 before 1.0.1i
from 1.0.0a before 1.0.0n
from 0.9.8o before 0.9.8zb

References

A DTLS memory leak from zero-length fragments was found. By sending carefully crafted DTLS packets an attacker could cause OpenSSL to leak memory. This could lead to a Denial of Service attack.

CVE-2014-3506

Published at

6 August 2014

Found by

Adam Langley (Google)

Affected

from 1.0.1 before 1.0.1i
from 1.0.0 before 1.0.0n
from 0.9.8 before 0.9.8zb

References

A DTLS flaw leading to memory exhaustion was found. An attacker can force openssl to consume large amounts of memory whilst processing DTLS handshake messages. This could lead to a Denial of Service attack.

CVE-2014-3505

Published at

6 August 2014

Found by

Adam Langley and Wan-Teh Chang (Google)

Affected

from 1.0.1 before 1.0.1i
from 1.0.0 before 1.0.0n
from 0.9.8m before 0.9.8zb

References

A Double Free was found when processing DTLS packets. An attacker can force an error condition which causes openssl to crash whilst processing DTLS packets due to memory being freed twice. This could lead to a Denial of Service attack.

CVE-2014-3470

Published at

30 May 2014

Found by

Felix Gröbert and Ivan Fratrić (Google)

Affected

from 1.0.1 before 1.0.1h
from 1.0.0 before 1.0.0m
from 0.9.8 before 0.9.8za

References

OpenSSL TLS clients enabling anonymous ECDH ciphersuites are subject to a denial of service attack.

CVE-2014-0224

Published at

5 June 2014

Found by

KIKUCHI Masashi (Lepidum Co. Ltd.)

Affected

from 1.0.1 before 1.0.1h
from 1.0.0 before 1.0.0m
from 0.9.8 before 0.9.8za

References

An attacker can force the use of weak keying material in OpenSSL SSL/TLS clients and servers. This can be exploited by a Man-in-the-middle (MITM) attack where the attacker can decrypt and modify traffic from the attacked client and server.

CVE-2014-0221

Published at

5 June 2014

Found by

Imre Rad (Search-Lab Ltd.)

Affected

from 1.0.1 before 1.0.1h
from 1.0.0 before 1.0.0m
from 0.9.8 before 0.9.8za

References

By sending an invalid DTLS handshake to an OpenSSL DTLS client the code can be made to recurse eventually crashing in a DoS attack. Only applications using OpenSSL as a DTLS client are affected.

CVE-2014-0198

Published at

21 April 2014

Affected

from 1.0.1 before 1.0.1h
from 1.0.0 before 1.0.0m

References

A flaw in the do_ssl3_write function can allow remote attackers to cause a denial of service via a NULL pointer dereference. This flaw only affects OpenSSL 1.0.0 and 1.0.1 where SSL_MODE_RELEASE_BUFFERS is enabled, which is not the default and not common.

CVE-2014-0195

Published at

5 June 2014

Found by

Jüri Aedla

Affected

from 1.0.1 before 1.0.1h
from 1.0.0 before 1.0.0m
from 0.9.8o before 0.9.8za

References

A buffer overrun attack can be triggered by sending invalid DTLS fragments to an OpenSSL DTLS client or server. This is potentially exploitable to run arbitrary code on a vulnerable client or server. Only applications using OpenSSL as a DTLS client or server affected.

CVE-2014-0160

Published at

7 April 2014

Found by

Neel Mehta

Affected

from 1.0.1 before 1.0.1g

References

A missing bounds check in the handling of the TLS heartbeat extension can be used to reveal up to 64kB of memory to a connected client or server (a.k.a. Heartbleed). This issue did not affect versions of OpenSSL prior to 1.0.1.

CVE-2014-0076

Published at

14 February 2014

Found by

Yuval Yarom and Naomi Benger

Affected

from 1.0.1 before 1.0.1g
from 1.0.0 before 1.0.0m
from 0.9.8 before 0.9.8za

References

Fix for the attack described in the paper “Recovering OpenSSL ECDSA Nonces Using the FLUSH+RELOAD Cache Side-channel Attack”.

CVE-2013-4353

Published at

6 January 2014

Found by

Anton Johansson

Affected

from 1.0.1 before 1.0.1f

References

A carefully crafted invalid TLS handshake could crash OpenSSL with a NULL pointer exception. A malicious server could use this flaw to crash a connecting client. This issue only affected OpenSSL 1.0.1 versions.

CVE-2010-5298

Published at

8 April 2014

Affected

from 1.0.1 before 1.0.1h
from 1.0.0 before 1.0.0m

References

A race condition in the ssl3_read_bytes function can allow remote attackers to inject data across sessions or cause a denial of service. This flaw only affects multithreaded applications using OpenSSL 1.0.0 and 1.0.1, where SSL_MODE_RELEASE_BUFFERS is enabled, which is not the default and not common.

2013

CVE-2013-6450

Published at

13 December 2013

Found by

Dmitry Sobinov

Affected

from 1.0.1 before 1.0.1f
from 1.0.0 before 1.0.0l

References

A flaw in DTLS handling can cause an application using OpenSSL and DTLS to crash. This is not a vulnerability for OpenSSL prior to 1.0.0.

CVE-2013-6449

Published at

14 December 2013

Found by

Ron Barber

Affected

from 1.0.1 before 1.0.1f

References

A flaw in OpenSSL can cause an application using OpenSSL to crash when using TLS version 1.2. This issue only affected OpenSSL 1.0.1 versions.

CVE-2013-0169

Published at

4 February 2013

Found by

Nadhem J. AlFardan and Kenneth G. Paterson of the Information Security Group Royal Holloway, University of London

Affected

from 1.0.1 before 1.0.1d
from 1.0.0 before 1.0.0k
from 0.9.8 before 0.9.8y

References

A weakness in the handling of CBC ciphersuites in SSL, TLS and DTLS which could lead to plaintext recovery by exploiting timing differences arising during MAC processing.

CVE-2013-0166

Published at

5 February 2013

Found by

Stephen Henson

Affected

from 1.0.1 before 1.0.1d
from 1.0.0 before 1.0.0k
from 0.9.8 before 0.9.8y

References

A flaw in the OpenSSL handling of OCSP response verification can be exploited in a denial of service attack.

CVE-2012-2686

Published at

5 February 2013

Found by

Adam Langley and Wolfgang Ettlinger

Affected

from 1.0.1 before 1.0.1d

References

A flaw in the OpenSSL handling of CBC ciphersuites in TLS 1.1 and TLS 1.2 on AES-NI supporting platforms can be exploited in a DoS attack.

2012

CVE-2012-2333

Published at

10 May 2012

Found by

Codenomicon

Affected

from 1.0.1 before 1.0.1c
from 1.0.0 before 1.0.0j
from 0.9.8 before 0.9.8x

References

An integer underflow flaw, leading to a buffer over-read, was found in the way OpenSSL handled TLS 1.1, TLS 1.2, and DTLS (Datagram Transport Layer Security) application data record lengths when using a block cipher in CBC (cipher-block chaining) mode. A malicious TLS 1.1, TLS 1.2, or DTLS client or server could use this flaw to crash its connection peer.

CVE-2012-2131

Published at

24 April 2012

Found by

Red Hat

Affected

from 0.9.8v before 0.9.8w

References

It was discovered that the fix for CVE-2012-2110 released on 19 Apr 2012 was not sufficient to correct the issue for OpenSSL 0.9.8. This issue only affects OpenSSL 0.9.8v. OpenSSL 1.0.1a and 1.0.0i already contain a patch sufficient to correct CVE-2012-2110.

CVE-2012-2110

Published at

19 April 2012

Found by

Tavis Ormandy

Affected

from 1.0.1 before 1.0.1a
from 1.0.0 before 1.0.0i
from 0.9.8 before 0.9.8v

References

Multiple numeric conversion errors, leading to a buffer overflow, were found in the way OpenSSL parsed ASN.1 (Abstract Syntax Notation One) data from BIO (OpenSSL’s I/O abstraction) inputs. Specially-crafted DER (Distinguished Encoding Rules) encoded data read from a file or other BIO input could cause an application using the OpenSSL library to crash or, potentially, execute arbitrary code.

CVE-2012-0884

Published at

12 March 2012

Found by

Ivan Nestlerode

Affected

from 1.0.0 before 1.0.0h
from 0.9.8 before 0.9.8u

References

A weakness in the OpenSSL CMS and PKCS #7 code can be exploited using Bleichenbacher’s attack on PKCS #1 v1.5 RSA padding also known as the million message attack (MMA). Only users of CMS, PKCS #7, or S/MIME decryption operations are affected, SSL/TLS applications are not affected by this issue.

CVE-2012-0050

Published at

4 January 2012

Found by

Antonio Martin

Affected

from 1.0.0f before 1.0.0g
from 0.9.8s before 0.9.8t

References

A flaw in the fix to CVE-2011-4108 can be exploited in a denial of service attack. Only DTLS applications are affected.

CVE-2012-0027

Published at

4 January 2012

Found by

Andrey Kulikov

Affected

from 1.0.0 before 1.0.0f

References

A malicious TLS client can send an invalid set of GOST parameters which will cause the server to crash due to lack of error checking. This could be used in a denial-of-service attack. Only users of the OpenSSL GOST ENGINE are affected by this bug.

CVE-2011-4619

Published at

4 January 2012

Found by

George Kadianakis

Affected

from 1.0.0 before 1.0.0f
from 0.9.8 before 0.9.8s

References

Support for handshake restarts for server gated cryptograpy (SGC) can be used in a denial-of-service attack.

CVE-2011-4577

Published at

4 January 2012

Found by

Andrew Chi

Affected

from 1.0.0 before 1.0.0f
from 0.9.8 before 0.9.8s

References

RFC 3779 data can be included in certificates, and if it is malformed, may trigger an assertion failure. This could be used in a denial-of-service attack. Builds of OpenSSL are only vulnerable if configured with “enable-rfc3779”, which is not a default.

CVE-2011-4576

Published at

4 January 2012

Found by

Adam Langley

Affected

from 1.0.0 before 1.0.0f
from 0.9.8 before 0.9.8s

References

OpenSSL failed to clear the bytes used as block cipher padding in SSL 3.0 records which could leak the contents of memory in some circumstances.

CVE-2011-4109

Published at

4 January 2012

Found by

Ben Laurie

Affected

from 0.9.8 before 0.9.8s

References

If X509_V_FLAG_POLICY_CHECK is set in OpenSSL 0.9.8, then a policy check failure can lead to a double-free. The bug does not occur unless this flag is set. Users of OpenSSL 1.0.0 are not affected.

CVE-2011-4108

Published at

4 January 2012

Found by

Nadhem Alfardan and Kenny Paterson

Affected

from 1.0.0 before 1.0.0f
from 0.9.8 before 0.9.8s

References

OpenSSL was susceptable an extension of the Vaudenay padding oracle attack on CBC mode encryption which enables an efficient plaintext recovery attack against the OpenSSL implementation of DTLS by exploiting timing differences arising during decryption processing.

2011

CVE-2011-3210

Published at

6 September 2011

Found by

Adam Langley

Affected

from 1.0.0 before 1.0.0e

References

OpenSSL server code for ephemeral ECDH ciphersuites is not thread-safe, and furthermore can crash if a client violates the protocol by sending handshake messages in incorrect order. Only server-side applications that specifically support ephemeral ECDH ciphersuites are affected, and only if ephemeral ECDH ciphersuites are enabled in the configuration.

CVE-2011-3207

Published at

6 September 2011

Found by

Kaspar Brand

Affected

from 1.0.0 before 1.0.0e

References

Under certain circumstances OpenSSL’s internal certificate verification routines can incorrectly accept a CRL whose nextUpdate field is in the past. Applications are only affected by the CRL checking vulnerability if they enable OpenSSL’s internal CRL checking which is off by default. Applications which use their own custom CRL checking (such as Apache) are not affected.

CVE-2011-0014

Published at

8 February 2011

Found by

Neel Mehta

Affected

from 1.0.0 before 1.0.0d
from 0.9.8h before 0.9.8r

References

A buffer over-read flaw was discovered in the way OpenSSL parsed the Certificate Status Request TLS extensions in ClientHello TLS handshake messages. A remote attacker could possibly use this flaw to crash an SSL server using the affected OpenSSL functionality.

2010

CVE-2010-4252

Published at

2 December 2010

Found by

Sebastian Martini

Affected

from 1.0.0 before 1.0.0c

References

An error in OpenSSL’s experimental J-PAKE implementation which could lead to successful validation by someone with no knowledge of the shared secret. The OpenSSL Team still consider the implementation of J-PAKE to be experimental and is not compiled by default.

CVE-2010-4180

Published at

2 December 2010

Found by

Martin Rex

Affected

from 1.0.0 before 1.0.0c
from 0.9.8 before 0.9.8q

References

A flaw in the OpenSSL SSL/TLS server code where an old bug workaround allows malicious clients to modify the stored session cache ciphersuite. In some cases the ciphersuite can be downgraded to a weaker one on subsequent connections. This issue only affects OpenSSL based SSL/TLS server if it uses OpenSSL’s internal caching mechanisms and the SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG flag (many applications enable this by using the SSL_OP_ALL option).

CVE-2010-3864

Published at

16 November 2010

Found by

Rob Hulswit

Affected

from 1.0.0 before 1.0.0b
from 0.9.8 before 0.9.8p

References

A flaw in the OpenSSL TLS server extension code parsing which on affected servers can be exploited in a buffer overrun attack. Any OpenSSL based TLS server is vulnerable if it is multi-threaded and uses OpenSSL’s internal caching mechanism. Servers that are multi-process and/or disable internal session caching are NOT affected.

CVE-2010-1633

Published at

1 June 2010

Found by

Peter-Michael Hager

Affected

from 1.0.0 before 1.0.0a

References

An invalid Return value check in pkey_rsa_verifyrecover was discovered. When verification recovery fails for RSA keys an uninitialised buffer with an undefined length is returned instead of an error code. This could lead to an information leak.

CVE-2010-0742

Published at

1 June 2010

Found by

Ronald Moesbergen

Affected

from 0.9.8h before 0.9.8o
from 1.0.0 before 1.0.0a

References

A flaw in the handling of CMS structures containing OriginatorInfo was found which could lead to a write to invalid memory address or double free. CMS support is disabled by default in OpenSSL 0.9.8 versions.

CVE-2010-0740

Published at

24 March 2010

Found by

Bodo Moeller and Adam Langley (Google)

Affected

from 0.9.8f before 0.9.8n

References

In TLS connections, certain incorrectly formatted records can cause an OpenSSL client or server to crash due to a read attempt at NULL.

CVE-2010-0433

Published at

19 January 2010

Found by

Todd Rinaldo, Tomas Hoger (Red Hat)

Affected

from 0.9.8 before 0.9.8n

References

A missing return value check flaw was discovered in OpenSSL, that could possibly cause OpenSSL to call a Kerberos library function with invalid arguments, resulting in a NULL pointer dereference crash in the MIT Kerberos library. In certain configurations, a remote attacker could use this flaw to crash a TLS/SSL server using OpenSSL by requesting Kerberos cipher suites during the TLS handshake.

CVE-2009-4355

Published at

13 January 2010

Found by

Michael K Johnson and Andy Grimm (rPath)

Affected

from 0.9.8 before 0.9.8m

References

A memory leak in the zlib_stateful_finish function in crypto/comp/c_zlib.c allows remote attackers to cause a denial of service via vectors that trigger incorrect calls to the CRYPTO_cleanup_all_ex_data function.

CVE-2009-3245

Published at

23 February 2010

Found by

Martin Olsson, Neel Mehta

Affected

from 0.9.8 before 0.9.8m

References

It was discovered that OpenSSL did not always check the return value of the bn_wexpand() function. An attacker able to trigger a memory allocation failure in that function could cause an application using the OpenSSL library to crash or, possibly, execute arbitrary code.

2009

CVE-2009-3555

Published at

5 November 2009

Affected

from 0.9.8 before 0.9.8m

References

Implement RFC5746 to address vulnerabilities in SSL/TLS renegotiation.

CVE-2009-1387

Published at

5 February 2009

Found by

Robin Seggelmann

Affected

from 0.9.8 before 0.9.8m

References

Fix denial of service flaw due in the DTLS implementation. A remote attacker could use this flaw to cause a DTLS server to crash.

CVE-2009-1386

Published at

2 June 2009

Found by

Alex Lam

Affected

from 0.9.8 before 0.9.8i

References

Fix a NULL pointer dereference if a DTLS server recieved ChangeCipherSpec as first record. A remote attacker could use this flaw to cause a DTLS server to crash.

CVE-2009-1379

Published at

12 May 2009

Found by

Daniel Mentz, Robin Seggelmann

Affected

from 0.9.8 before 0.9.8m

References

Use-after-free vulnerability in the dtls1_retrieve_buffered_fragment function could cause a client accessing a malicious DTLS server to crash.

CVE-2009-1378

Published at

12 May 2009

Found by

Daniel Mentz, Robin Seggelmann

Affected

from 0.9.8 before 0.9.8m

References

Fix a denial of service flaw in the DTLS implementation. In dtls1_process_out_of_seq_message() the check if the current message is already buffered was missing. For every new message was memory allocated, allowing an attacker to perform an denial of service attack against a DTLS server by sending out of seq handshake messages until there is no memory left.

CVE-2009-1377

Published at

12 May 2009

Found by

Daniel Mentz, Robin Seggelmann

Affected

from 0.9.8 before 0.9.8m

References

Fix a denial of service flaw in the DTLS implementation. Records are buffered if they arrive with a future epoch to be processed after finishing the corresponding handshake. There is currently no limitation to this buffer allowing an attacker to perform a DOS attack to a DTLS server by sending records with future epochs until there is no memory left.

CVE-2009-0789

Published at

25 March 2009

Found by

Paolo Ganci

Affected

from 0.9.8 before 0.9.8k

References

When a malformed ASN1 structure is received it’s contents are freed up and zeroed and an error condition returned. On a small number of platforms where sizeof(long) < sizeof(void *) (for example WIN64) this can cause an invalid memory access later resulting in a crash when some invalid structures are read, for example RSA public keys.

CVE-2009-0591

Published at

25 March 2009

Found by

Ivan Nestlerode, IBM

Affected

from 0.9.8h before 0.9.8k

References

The function CMS_verify() does not correctly handle an error condition involving malformed signed attributes. This will cause an invalid set of signed attributes to appear valid and content digests will not be checked.

CVE-2009-0590

Published at

25 March 2009

Affected

from 0.9.8 before 0.9.8k

References

The function ASN1_STRING_print_ex() when used to print a BMPString or UniversalString will crash with an invalid memory access if the encoded length of the string is illegal. Any OpenSSL application which prints out the contents of a certificate could be affected by this bug, including SSL servers, clients and S/MIME software.

CVE-2008-5077

Published at

7 January 2009

Found by

google

Affected

from 0.9.8 before 0.9.8j

References

The Google Security Team discovered several functions inside OpenSSL incorrectly checked the result after calling the EVP_VerifyFinal function, allowing a malformed signature to be treated as a good signature rather than as an error. This issue affected the signature checks on DSA and ECDSA keys used with SSL/TLS. One way to exploit this flaw would be for a remote attacker who is in control of a malicious server or who can use a ‘man in the middle’ attack to present a malformed SSL/TLS signature from a certificate chain to a vulnerable client, bypassing validation.

2008

CVE-2008-1672

Published at

28 May 2008

Found by

codenomicon

Affected

from 0.9.8f before 0.9.8h

References

Testing using the Codenomicon TLS test suite discovered a flaw if the ‘Server Key exchange message’ is omitted from a TLS handshake in OpenSSL 0.9.8f and OpenSSL 0.9.8g. If a client connects to a malicious server with particular cipher suites, the server could cause the client to crash.

CVE-2008-0891

Published at

28 May 2008

Found by

codenomicon

Affected

from 0.9.8f before 0.9.8h

References

Testing using the Codenomicon TLS test suite discovered a flaw in the handling of server name extension data in OpenSSL 0.9.8f and OpenSSL 0.9.8g. If OpenSSL has been compiled using the non-default TLS server name extensions, a remote attacker could send a carefully crafted packet to a server application using OpenSSL and cause it to crash.

2007

CVE-2007-5502

Published at

29 November 2007

Found by

Geoff Lowe

Affected

from fips-1.1.1 before fips-1.1.2

References

The PRNG implementation for the OpenSSL FIPS Object Module 1.1.1 does not perform auto-seeding during the FIPS self-test, which generates random data that is more predictable than expected and makes it easier for attackers to bypass protection mechanisms that rely on the randomness.

CVE-2007-5135

Published at

12 October 2007

Found by

Moritz Jodeit

Affected

from 0.9.8 before 0.9.8f

References

A flaw was found in the SSL_get_shared_ciphers() utility function. An attacker could send a list of ciphers to an application that used this function and overrun a buffer with a single byte. Few applications make use of this vulnerable function and generally it is used only when applications are compiled for debugging.

CVE-2007-4995

Published at

12 October 2007

Found by

Andy Polyakov

Affected

from 0.9.8 before 0.9.8f

References

A flaw in DTLS support. An attacker could create a malicious client or server that could trigger a heap overflow. This is possibly exploitable to run arbitrary code, but it has not been verified.

2006

CVE-2006-4343

Published at

28 September 2006

Found by

openssl

Affected

from 0.9.7 before 0.9.7l
from 0.9.8 before 0.9.8d

References

A flaw in the SSLv2 client code was discovered. When a client application used OpenSSL to create an SSLv2 connection to a malicious server, that server could cause the client to crash.

CVE-2006-4339

Published at

5 September 2006

Found by

openssl

Affected

from 0.9.7 before 0.9.7k
from 0.9.8 before 0.9.8c

References

Daniel Bleichenbacher discovered an attack on PKCS #1 v1.5 signatures where under certain circumstances it may be possible for an attacker to forge a PKCS #1 v1.5 signature that would be incorrectly verified by OpenSSL.

CVE-2006-3738

Published at

28 September 2006

Found by

openssl

Affected

from 0.9.7 before 0.9.7l
from 0.9.8 before 0.9.8d

References

A buffer overflow was discovered in the SSL_get_shared_ciphers() utility function. An attacker could send a list of ciphers to an application that uses this function and overrun a buffer.

CVE-2006-2940

Published at

28 September 2006

Found by

openssl

Affected

from 0.9.7 before 0.9.7l
from 0.9.8 before 0.9.8d

References

Certain types of public key can take disproportionate amounts of time to process. This could be used by an attacker in a denial of service attack.

CVE-2006-2937

Published at

28 September 2006

Found by

openssl

Affected

from 0.9.7 before 0.9.7l
from 0.9.8 before 0.9.8d

References

During the parsing of certain invalid ASN.1 structures an error condition is mishandled. This can result in an infinite loop which consumes system memory.

2005

CVE-2005-2969

Published at

11 October 2005

Found by

researcher

Affected

from 0.9.7 before 0.9.7h
from 0.9.8 before 0.9.8a

References

A deprecated option, SSL_OP_MISE_SSLV2_RSA_PADDING, could allow an attacker acting as a “man in the middle” to force a connection to downgrade to SSL 2.0 even if both parties support better protocols.

2004

CVE-2004-0975

Published at

30 September 2004

Affected

from 0.9.7 before 0.9.7f
from 0.9.6 before 0.9.6-cvs

References

The der_chop script created temporary files insecurely which could allow local users to overwrite files via a symlink attack on temporary files. Note that it is quite unlikely that a user would be using the redundant der_chop script, and this script was removed from the OpenSSL distribution.

CVE-2004-0112

Published at

17 March 2004

Found by

OpenSSL group (Stephen Henson)

Affected

from 0.9.7a before 0.9.7d

References

A flaw in SSL/TLS handshaking code when using Kerberos ciphersuites. A remote attacker could perform a carefully crafted SSL/TLS handshake against a server configured to use Kerberos ciphersuites in such a way as to cause OpenSSL to crash. Most applications have no ability to use Kerberos ciphersuites and will therefore be unaffected.

CVE-2004-0081

Published at

17 March 2004

Found by

OpenSSL group

Affected

from 0.9.6 before 0.9.6d

References

The Codenomicon TLS Test Tool found that some unknown message types were handled incorrectly, allowing a remote attacker to cause a denial of service (infinite loop).

CVE-2004-0079

Published at

17 March 2004

Found by

OpenSSL group

Affected

from 0.9.7 before 0.9.7d
from 0.9.6c before 0.9.6m

References

The Codenomicon TLS Test Tool uncovered a null-pointer assignment in the do_change_cipher_spec() function. A remote attacker could perform a carefully crafted SSL/TLS handshake against a server that used the OpenSSL library in such a way as to cause a crash.

2003

CVE-2003-0851

Published at

4 November 2003

Found by

Novell

Affected

from 0.9.6k before 0.9.6l

References

A flaw in OpenSSL 0.9.6k (only) would cause certain ASN.1 sequences to trigger a large recursion. On platforms such as Windows this large recursion cannot be handled correctly and so the bug causes OpenSSL to crash. A remote attacker could exploit this flaw if they can send arbitrary ASN.1 sequences which would cause OpenSSL to crash. This could be performed for example by sending a client certificate to a SSL/TLS enabled server which is configured to accept them.

CVE-2003-0545

Published at

30 September 2003

Found by

NISCC

Affected

from 0.9.7 before 0.9.7c

References

Certain ASN.1 encodings that were rejected as invalid by the parser could trigger a bug in the deallocation of the corresponding data structure, corrupting the stack, leading to a crash.

CVE-2003-0544

Published at

30 September 2003

Found by

NISCC

Affected

from 0.9.6 before 0.9.6k
from 0.9.7 before 0.9.7c

References

Incorrect tracking of the number of characters in certain ASN.1 inputs could allow remote attackers to cause a denial of service (crash) by sending an SSL client certificate that causes OpenSSL to read past the end of a buffer when the long form is used.

CVE-2003-0543

Published at

30 September 2003

Found by

NISCC

Affected

from 0.9.7 before 0.9.7c
from 0.9.6 before 0.9.6k

References

An integer overflow could allow remote attackers to cause a denial of service (crash) via an SSL client certificate with certain ASN.1 tag values.

CVE-2003-0147

Published at

14 March 2003

Affected

from 0.9.7 before 0.9.7b
from 0.9.6 before 0.9.6j

References

RSA blinding was not enabled by default, which could allow local and remote attackers to obtain a server’s private key by determining factors using timing differences on (1) the number of extra reductions during Montgomery reduction, and (2) the use of different integer multiplication algorithms (“Karatsuba” and normal).

CVE-2003-0131

Published at

19 March 2003

Affected

from 0.9.6 before 0.9.6j
from 0.9.7 before 0.9.7b

References

The SSL and TLS components allowed remote attackers to perform an unauthorized RSA private key operation via a modified Bleichenbacher attack that uses a large number of SSL or TLS connections using PKCS #1 v1.5 padding that caused OpenSSL to leak information regarding the relationship between ciphertext and the associated plaintext, aka the “Klima-Pokorny-Rosa attack”.

CVE-2003-0078

Published at

19 February 2003

Affected

from 0.9.7 before 0.9.7a
from 0.9.6 before 0.9.6i

References

sl3_get_record in s3_pkt.c did not perform a MAC computation if an incorrect block cipher padding was used, causing an information leak (timing discrepancy) that may make it easier to launch cryptographic attacks that rely on distinguishing between padding and MAC verification errors, possibly leading to extraction of the original plaintext, aka the “Vaudenay timing attack.”.

2002

CVE-2002-1568

Published at

8 August 2002

Affected

from 0.9.6e before 0.9.6f

References

The use of assertions when detecting buffer overflow attacks allowed remote attackers to cause a denial of service (crash) by sending certain messages to cause OpenSSL to abort from a failed assertion, as demonstrated using SSLv2 CLIENT_MASTER_KEY messages, which were not properly handled in s2_srvr.c.

CVE-2002-0659

Published at

30 July 2002

Affected

from 0.9.6a before 0.9.6e

References

A flaw in the ASN1 library allowed remote attackers to cause a denial of service by sending invalid encodings.

CVE-2002-0657

Published at

30 July 2002

Found by

OpenSSL Group (A.L. Digital)

Affected

from 0.9.7-beta3 before 0.9.7

References

A buffer overflow when Kerberos is enabled allowed attackers to execute arbitrary code by sending a long master key. Note that this flaw did not affect any released version of 0.9.6 or 0.9.7.

CVE-2002-0656

Published at

30 July 2002

Found by

OpenSSL Group (A.L. Digital)

Affected

from 0.9.6 before 0.9.6e

References

A buffer overflow allowed remote attackers to execute arbitrary code by sending a large client master key in SSL2 or a large session ID in SSL3.

CVE-2002-0655

Published at

30 July 2002

Found by

OpenSSL Group (A.L. Digital)

Affected

from 0.9.6 before 0.9.6e

References

Inproper handling of ASCII representations of integers on 64 bit platforms allowed remote attackers to cause a denial of service or possibly execute arbitrary code.

Not Vulnerabilities

CVE-2010-0928: This was not treated as a security issue as it is outside of the OpenSSL threat model.
CVE-2007-6755: Only OpenSSL FIPS module shipped Dual EC DRBG, and it was not affected.
CVE-2002-20001: We do not consider this to be a vulnerability in OpenSSL.