CVE-2024-5535

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.

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.

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.

The OpenSSL Project is a collaborative effort to develop a robust, commercial-grade, fully featured, and Open Source toolkit implementing the Secure Sockets Layer (SSL v2/v3) and Transport Layer Security (TLS v1) protocols as well as a full-strength general purpose cryptography library. The project is managed by a worldwide community of volunteers that use the Internet to communicate, plan, and develop the OpenSSL tookit and its related documentation.

Security Fix(es):

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…

EDK II is a modern, feature-rich, cross-platform firmware development environment for the UEFI and PI specifications.

Security Fix(es):

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…

OpenSSL is a robust, commercial-grade, and full-featured toolkit for the Transport Layer Security (TLS) and Secure Sockets Layer (SSL) protocols.

Security Fix(es):

Issue summary: A timing side-channel which could potentially allow recovering the private key exists in the ECDSA signature computation.

Impact summary: A timing side-channel in ECDSA signature computations could allow recovering the private key by an attacker. However, measuring the timing would require either local access to the signing application or a very fast network connection with low latency.

There is a timing signal of around 300 nanoseconds when the top word of the inverted ECDSA nonce value is zero. This can happen with significant probability only for some of the supported elliptic curves. In particular the NIST P-521 curve is affected. To be able to measure this leak, the attacker process must either be located in the same physical computer or must have a very fast network connection with low latency. For that reason the severity of this vulnerability is Low.(CVE-2024-13176)

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…

MySQL is a multi-user, multi-threaded SQL database server. It consists of the MySQL server daemon (mysqld) and many client programs and libraries.

Security Fix(es):

• openssl: SSL_select_next_proto buffer overread (CVE-2024-5535)

• krb5: GSS message token handling (CVE-2024-37371)

• curl: libcurl: ASN.1 date parser overread (CVE-2024-7264)

• mysql: Thread Pooling unspecified vulnerability (CPU Oct 2024) (CVE-2024-21238)

• mysql: X Plugin unspecified vulnerability (CPU Oct 2024) (CVE-2024-21196)

• mysql: Optimizer unspecified vulnerability (CPU Oct 2024) (CVE-2024-21241)

• mysql: Client programs unspecified vulnerability (CPU Oct 2024) (CVE-2024-21231)

• mysql: Information Schema unspecified vulnerability (CPU Oct 2024) (CVE-2024-21197)

• mysql: InnoDB unspecified vulnerability (CPU Oct 2024) (CVE-2024-21218)

• mysql: Optimizer unspecified vulnerability (CPU Oct 2024) (CVE-2024-21201)

• mysql: InnoDB unspecified vulnerability (CPU Oct 2024) (CVE-2024-21236)

• mysql: Group Replication GCS unspecified vulnerability (CPU Oct 2024) (CVE-2024-21237)

• mysql: FTS unspecified vulnerability (CPU Oct 2024) (CVE-2024-21203)

• mysql: Health Monitor unspecified vulnerability (CPU Oct 2024) (CVE-2024-21212)

• mysql: DML unspecified vulnerability (CPU Oct 2024) (CVE-2024-21219)

• mysql: Optimizer unspecified vulnerability (CPU Oct 2024) (CVE-2024-21230)

• mysql: InnoDB unspecified vulnerability (CPU Oct 2024) (CVE-2024-21213)

• mysql: InnoDB unspecified vulnerability (CPU Oct 2024) (CVE-2024-21194)

• mysql: InnoDB unspecified vulnerability (CPU Oct 2024) (CVE-2024-21199)

• mysql: PS unspecified vulnerability (CPU Oct 2024) (CVE-2024-21193)

• mysql: DDL unspecified vulnerability (CPU Oct 2024) (CVE-2024-21198)

• mysql: mysqldump unspecified vulnerability (CPU Oct 2024) (CVE-2024-21247)

• mysql: InnoDB unspecified vulnerability (CPU Oct 2024) (CVE-2024-21239)

• curl: curl netrc password leak (CVE-2024-11053)

• mysql: InnoDB unspecified vulnerability (CPU Jan 2025) (CVE-2025-21497)

• mysql: MySQL Server Options Vulnerability (CVE-2025-21520)

• mysql: High Privilege Denial of Service Vulnerability in MySQL Server (CVE-2025-21490)

• mysql: Information Schema unspecified vulnerability (CPU Jan 2025) (CVE-2025-21529)

• mysql: InnoDB unspecified vulnerability (CPU Jan 2025) (CVE-2025-21531)

• mysql: Optimizer unspecified vulnerability (CPU Jan 2025) (CVE-2025-21504)

• mysql: Privileges unspecified vulnerability (CPU Jan 2025) (CVE-2025-21540)

• mysql: MySQL Server InnoDB Denial of Service and Unauthorized Data Modification Vulnerability (CVE-2025-21555)

• mysql: Packaging unspecified vulnerability (CPU Jan 2025) (CVE-2025-21543)

• mysql: MySQL Server InnoDB Denial of Service and Unauthorized Data Modification Vulnerability (CVE-2025-21491)

• mysql: DDL unspecified vulnerability (CPU Jan 2025) (CVE-2025-21525)

• mysql: Optimizer unspecified vulnerability (CPU Jan 2025) (CVE-2025-21536)

• mysql: Thread Pooling unspecified vulnerability (CPU Jan 2025) (CVE-2025-21521)

• mysql: Optimizer unspecified vulnerability (CPU Jan 2025) (CVE-2025-21501)

• mysql: Performance Schema unspecified vulnerability (CPU Jan 2025) (CVE-2025-21534)

• mysql: Privileges unspecified vulnerability (CPU Jan 2025) (CVE-2025-21494)

• mysql: Privileges unspecified vulnerability (CPU Jan 2025) (CVE-2025-21519)

• mysql: Parser unspecified vulnerability (CPU Jan 2025) (CVE-2025-21522)

• mysql: InnoDB unspecified vulnerability (CPU Jan 2025) (CVE-2025-21503)

• mysql: Optimizer unspecified vulnerability (CPU Jan 2025) (CVE-2025-21518)

• mysql: MySQL Server InnoDB Denial of Service and Unauthorized Data Modification Vulnerability (CVE-2025-21559)

• mysql: Privilege Misuse in MySQL Server Security Component (CVE-2025-21546)

• mysql: Optimizer unspecified vulnerability (CPU Jan 2025) (CVE-2025-21500)

• mysql: InnoDB unspecified vulnerability (CPU Jan 2025) (CVE-2025-21523)

• mysql: Components Services unspecified vulnerability (CPU Jan…

The OpenSSL toolkit provides support for secure communications between machines. OpenSSL includes a certificate management tool and shared libraries which provide various cryptographic algorithms and protocols. This package contains Windows (MinGW) libraries and development tools.

Security Fix(es):

• openssl: SSL_select_next_proto buffer overread (CVE-2024-5535)

For more details about the security issue(s), including the impact, a CVSS score, acknowledgments, and other related information, refer to the CVE page(s) listed in the References section.

Root has patched CVE-2024-5535 in the openssl package for Root:Alpine:3.15. Multiple fixed versions available.

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.

OpenSSL is a toolkit that implements the Secure Sockets Layer (SSL) and Transport Layer Security (TLS) protocols, as well as a full-strength general-purpose cryptography library.

Security Fix(es):

• openssl: SSL_select_next_proto buffer overread (CVE-2024-5535)

For more details about the security issue(s), including the impact, a CVSS score, acknowledgments, and other related information, refer to the CVE page(s) listed in the References section.

OpenSSL is a toolkit that implements the Secure Sockets Layer (SSL) and Transport Layer Security (TLS) protocols, as well as a full-strength general-purpose cryptography library.

Security Fix(es):

• openssl: Unbounded memory growth with session handling in TLSv1.3 (CVE-2024-2511)
• openssl: Excessive time spent checking DSA keys and parameters (CVE-2024-4603)
• openssl: Use After Free with SSL_free_buffers (CVE-2024-4741)
• openssl: SSL_select_next_proto buffer overread (CVE-2024-5535)

For more details about the security issue(s), including the impact, a CVSS score, acknowledgments, and other related information, refer to the CVE page(s) listed in the References section.

Additional Changes:

For detailed information on changes in this release, see the AlmaLinux Release Notes linked from the References section.

MySQL is a multi-user, multi-threaded SQL database server. It consists of the MySQL server daemon (mysqld) and many client programs and libraries.

Security Fix(es):

• openssl: SSL_select_next_proto buffer overread (CVE-2024-5535)
• krb5: GSS message token handling (CVE-2024-37371)
• curl: libcurl: ASN.1 date parser overread (CVE-2024-7264)
• mysql: Thread Pooling unspecified vulnerability (CPU Oct 2024) (CVE-2024-21238)
• mysql: X Plugin unspecified vulnerability (CPU Oct 2024) (CVE-2024-21196)
• mysql: Optimizer unspecified vulnerability (CPU Oct 2024) (CVE-2024-21241)
• mysql: Client programs unspecified vulnerability (CPU Oct 2024) (CVE-2024-21231)
• mysql: Information Schema unspecified vulnerability (CPU Oct 2024) (CVE-2024-21197)
• mysql: InnoDB unspecified vulnerability (CPU Oct 2024) (CVE-2024-21218)
• mysql: Optimizer unspecified vulnerability (CPU Oct 2024) (CVE-2024-21201)
• mysql: InnoDB unspecified vulnerability (CPU Oct 2024) (CVE-2024-21236)
• mysql: Group Replication GCS unspecified vulnerability (CPU Oct 2024) (CVE-2024-21237)
• mysql: FTS unspecified vulnerability (CPU Oct 2024) (CVE-2024-21203)
• mysql: Health Monitor unspecified vulnerability (CPU Oct 2024) (CVE-2024-21212)
• mysql: DML unspecified vulnerability (CPU Oct 2024) (CVE-2024-21219)
• mysql: Optimizer unspecified vulnerability (CPU Oct 2024) (CVE-2024-21230)
• mysql: InnoDB unspecified vulnerability (CPU Oct 2024) (CVE-2024-21213)
• mysql: InnoDB unspecified vulnerability (CPU Oct 2024) (CVE-2024-21194)
• mysql: InnoDB unspecified vulnerability (CPU Oct 2024) (CVE-2024-21199)
• mysql: PS unspecified vulnerability (CPU Oct 2024) (CVE-2024-21193)
• mysql: DDL unspecified vulnerability (CPU Oct 2024) (CVE-2024-21198)
• mysql: mysqldump unspecified vulnerability (CPU Oct 2024) (CVE-2024-21247)
• mysql: InnoDB unspecified vulnerability (CPU Oct 2024) (CVE-2024-21239)
• curl: curl netrc password leak (CVE-2024-11053)
• mysql: InnoDB unspecified vulnerability (CPU Jan 2025) (CVE-2025-21497)
• mysql: MySQL Server Options Vulnerability (CVE-2025-21520)
• mysql: High Privilege Denial of Service Vulnerability in MySQL Server (CVE-2025-21490)
• mysql: Information Schema unspecified vulnerability (CPU Jan 2025) (CVE-2025-21529)
• mysql: InnoDB unspecified vulnerability (CPU Jan 2025) (CVE-2025-21531)
• mysql: Optimizer unspecified vulnerability (CPU Jan 2025) (CVE-2025-21504)
• mysql: Privileges unspecified vulnerability (CPU Jan 2025) (CVE-2025-21540)
• mysql: MySQL Server InnoDB Denial of Service and Unauthorized Data Modification Vulnerability (CVE-2025-21555)
• mysql: Packaging unspecified vulnerability (CPU Jan 2025) (CVE-2025-21543)
• mysql: MySQL Server InnoDB Denial of Service and Unauthorized Data Modification Vulnerability (CVE-2025-21491)
• mysql: DDL unspecified vulnerability (CPU Jan 2025) (CVE-2025-21525)
• mysql: Optimizer unspecified vulnerability (CPU Jan 2025) (CVE-2025-21536)
• mysql: Thread Pooling unspecified vulnerability (CPU Jan 2025) (CVE-2025-21521)
• mysql: Optimizer unspecified vulnerability (CPU Jan 2025) (CVE-2025-21501)
• mysql: Performance Schema unspecified vulnerability (CPU Jan 2025) (CVE-2025-21534)
• mysql: Privileges unspecified vulnerability (CPU Jan 2025) (CVE-2025-21494)
• mysql: Privileges unspecified vulnerability (CPU Jan 2025) (CVE-2025-21519)
• mysql: Parser unspecified vulnerability (CPU Jan 2025) (CVE-2025-21522)
• mysql: InnoDB unspecified vulnerability (CPU Jan 2025) (CVE-2025-21503)
• mysql: Optimizer unspecified vulnerability (CPU Jan 2025) (CVE-2025-21518)
• mysql: MySQL Server InnoDB Denial of Service and Unauthorized Data Modification Vulnerability (CVE-2025-21559)
• mysql: Privilege Misuse in MySQL Server Security Component (CVE-2025-21546)
• mysql: Optimizer unspecified vulnerability (CPU Jan 2025) (CVE-2025-21500)
• mysql: InnoDB unspecified vulnerability (CPU Jan 2025) (CVE-2025-21523)
• mysql:…

MySQL is a multi-user, multi-threaded SQL database server. It consists of the MySQL server daemon (mysqld) and many client programs and libraries.

Security Fix(es):

• openssl: SSL_select_next_proto buffer overread (CVE-2024-5535)
• krb5: GSS message token handling (CVE-2024-37371)
• curl: libcurl: ASN.1 date parser overread (CVE-2024-7264)
• mysql: Thread Pooling unspecified vulnerability (CPU Oct 2024) (CVE-2024-21238)
• mysql: X Plugin unspecified vulnerability (CPU Oct 2024) (CVE-2024-21196)
• mysql: Optimizer unspecified vulnerability (CPU Oct 2024) (CVE-2024-21241)
• mysql: Client programs unspecified vulnerability (CPU Oct 2024) (CVE-2024-21231)
• mysql: Information Schema unspecified vulnerability (CPU Oct 2024) (CVE-2024-21197)
• mysql: InnoDB unspecified vulnerability (CPU Oct 2024) (CVE-2024-21218)
• mysql: Optimizer unspecified vulnerability (CPU Oct 2024) (CVE-2024-21201)
• mysql: InnoDB unspecified vulnerability (CPU Oct 2024) (CVE-2024-21236)
• mysql: Group Replication GCS unspecified vulnerability (CPU Oct 2024) (CVE-2024-21237)
• mysql: FTS unspecified vulnerability (CPU Oct 2024) (CVE-2024-21203)
• mysql: Health Monitor unspecified vulnerability (CPU Oct 2024) (CVE-2024-21212)
• mysql: DML unspecified vulnerability (CPU Oct 2024) (CVE-2024-21219)
• mysql: Optimizer unspecified vulnerability (CPU Oct 2024) (CVE-2024-21230)
• mysql: InnoDB unspecified vulnerability (CPU Oct 2024) (CVE-2024-21213)
• mysql: InnoDB unspecified vulnerability (CPU Oct 2024) (CVE-2024-21194)
• mysql: InnoDB unspecified vulnerability (CPU Oct 2024) (CVE-2024-21199)
• mysql: PS unspecified vulnerability (CPU Oct 2024) (CVE-2024-21193)
• mysql: DDL unspecified vulnerability (CPU Oct 2024) (CVE-2024-21198)
• mysql: mysqldump unspecified vulnerability (CPU Oct 2024) (CVE-2024-21247)
• mysql: InnoDB unspecified vulnerability (CPU Oct 2024) (CVE-2024-21239)
• curl: curl netrc password leak (CVE-2024-11053)
• mysql: InnoDB unspecified vulnerability (CPU Jan 2025) (CVE-2025-21497)
• mysql: MySQL Server Options Vulnerability (CVE-2025-21520)
• mysql: High Privilege Denial of Service Vulnerability in MySQL Server (CVE-2025-21490)
• mysql: Information Schema unspecified vulnerability (CPU Jan 2025) (CVE-2025-21529)
• mysql: InnoDB unspecified vulnerability (CPU Jan 2025) (CVE-2025-21531)
• mysql: Optimizer unspecified vulnerability (CPU Jan 2025) (CVE-2025-21504)
• mysql: Privileges unspecified vulnerability (CPU Jan 2025) (CVE-2025-21540)
• mysql: MySQL Server InnoDB Denial of Service and Unauthorized Data Modification Vulnerability (CVE-2025-21555)
• mysql: Packaging unspecified vulnerability (CPU Jan 2025) (CVE-2025-21543)
• mysql: MySQL Server InnoDB Denial of Service and Unauthorized Data Modification Vulnerability (CVE-2025-21491)
• mysql: DDL unspecified vulnerability (CPU Jan 2025) (CVE-2025-21525)
• mysql: Optimizer unspecified vulnerability (CPU Jan 2025) (CVE-2025-21536)
• mysql: Thread Pooling unspecified vulnerability (CPU Jan 2025) (CVE-2025-21521)
• mysql: Optimizer unspecified vulnerability (CPU Jan 2025) (CVE-2025-21501)
• mysql: Performance Schema unspecified vulnerability (CPU Jan 2025) (CVE-2025-21534)
• mysql: Privileges unspecified vulnerability (CPU Jan 2025) (CVE-2025-21494)
• mysql: Privileges unspecified vulnerability (CPU Jan 2025) (CVE-2025-21519)
• mysql: Parser unspecified vulnerability (CPU Jan 2025) (CVE-2025-21522)
• mysql: InnoDB unspecified vulnerability (CPU Jan 2025) (CVE-2025-21503)
• mysql: Optimizer unspecified vulnerability (CPU Jan 2025) (CVE-2025-21518)
• mysql: MySQL Server InnoDB Denial of Service and Unauthorized Data Modification Vulnerability (CVE-2025-21559)
• mysql: Privilege Misuse in MySQL Server Security Component (CVE-2025-21546)
• mysql: Optimizer unspecified vulnerability (CPU Jan 2025) (CVE-2025-21500)
• mysql: InnoDB unspecified vulnerability (CPU Jan 2025) (CVE-2025-21523)
• mysql:…

The OpenSSL toolkit provides support for secure communications between machines. OpenSSL includes a certificate management tool and shared libraries which provide various cryptographic algorithms and protocols. This package contains Windows (MinGW) libraries and development tools.

Security Fix(es):

• openssl: SSL_select_next_proto buffer overread (CVE-2024-5535)

For more details about the security issue(s), including the impact, a CVSS score, acknowledgments, and other related information, refer to the CVE page(s) listed in the References section.

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.

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.

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.

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.

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-5535: Validate provided client list in ssl/ssl_lib.c. Clarify SSL_select_next_proto documentation

• CVE-2024-5535: Validate provided client list in ssl/ssl_lib.c. Clarify SSL_select_next_proto documentation

• CVE-2024-5535: Validate provided client list in ssl/ssl_lib.c. Clarify SSL_select_next_proto documentation

• Update to MySQL 8.0.41
• CVEs fixed: CVE-2024-5535 CVE-2024-7264 CVE-2024-11053 CVE-2024-21193 CVE-2024-21194 CVE-2024-21196 CVE-2024-21197 CVE-2024-21198 CVE-2024-21199 CVE-2024-21201 CVE-2024-21203 CVE-2024-21212 CVE-2024-21213 CVE-2024-21218 CVE-2024-21219 CVE-2024-21230 CVE-2024-21231 CVE-2024-21236 CVE-2024-21237 CVE-2024-21238 CVE-2024-21239 CVE-2024-21241 CVE-2024-21247 CVE-2024-37371 CVE-2025-21490 CVE-2025-21491 CVE-2025-21494 CVE-2025-21497 CVE-2025-21500 CVE-2025-21501 CVE-2025-21503 CVE-2025-21504 CVE-2025-21505 CVE-2025-21518 CVE-2025-21519 CVE-2025-21520 CVE-2025-21521 CVE-2025-21522 CVE-2025-21523 CVE-2025-21525 CVE-2025-21529 CVE-2025-21531 CVE-2025-21534 CVE-2025-21536 CVE-2025-21540 CVE-2025-21543 CVE-2025-21546 CVE-2025-21555 CVE-2025-21559
• Rebase mysql-mtr.patch
• Remove mysql-fix-includes-robin-hood.patch
• Rebase mysql-increase-wait-until-connect-timeout.patch

• Update to MySQL 8.0.41
• CVEs fixed: CVE-2024-5535 CVE-2024-7264 CVE-2024-11053 CVE-2024-21193 CVE-2024-21194 CVE-2024-21196 CVE-2024-21197 CVE-2024-21198 CVE-2024-21199 CVE-2024-21201 CVE-2024-21203 CVE-2024-21212 CVE-2024-21213 CVE-2024-21218 CVE-2024-21219 CVE-2024-21230 CVE-2024-21231 CVE-2024-21236 CVE-2024-21237 CVE-2024-21238 CVE-2024-21239 CVE-2024-21241 CVE-2024-21247 CVE-2024-37371 CVE-2025-21490 CVE-2025-21491 CVE-2025-21494 CVE-2025-21497 CVE-2025-21500 CVE-2025-21501 CVE-2025-21503 CVE-2025-21504 CVE-2025-21505 CVE-2025-21518 CVE-2025-21519 CVE-2025-21520 CVE-2025-21521 CVE-2025-21522 CVE-2025-21523 CVE-2025-21525 CVE-2025-21529 CVE-2025-21531 CVE-2025-21534 CVE-2025-21536 CVE-2025-21540 CVE-2025-21543 CVE-2025-21546 CVE-2025-21555 CVE-2025-21559
• Rebase mysql-mtr.patch
• Remove mysql-fix-includes-robin-hood.patch
• Rebase mysql-increase-wait-until-connect-timeout.patch

• Update to MySQL 8.0.41
• CVEs fixed: CVE-2024-5535 CVE-2024-7264 CVE-2024-11053 CVE-2024-21193 CVE-2024-21194 CVE-2024-21196 CVE-2024-21197 CVE-2024-21198 CVE-2024-21199 CVE-2024-21201 CVE-2024-21203 CVE-2024-21212 CVE-2024-21213 CVE-2024-21218 CVE-2024-21219 CVE-2024-21230 CVE-2024-21231 CVE-2024-21236 CVE-2024-21237 CVE-2024-21238 CVE-2024-21239 CVE-2024-21241 CVE-2024-21247 CVE-2024-37371 CVE-2025-21490 CVE-2025-21491 CVE-2025-21494 CVE-2025-21497 CVE-2025-21500 CVE-2025-21501 CVE-2025-21503 CVE-2025-21504 CVE-2025-21505 CVE-2025-21518 CVE-2025-21519 CVE-2025-21520 CVE-2025-21521 CVE-2025-21522 CVE-2025-21523 CVE-2025-21525 CVE-2025-21529 CVE-2025-21531 CVE-2025-21534 CVE-2025-21536 CVE-2025-21540 CVE-2025-21543 CVE-2025-21546 CVE-2025-21555 CVE-2025-21559
• Rebase mysql-mtr.patch
• Remove mysql-fix-includes-robin-hood.patch
• Rebase mysql-increase-wait-until-connect-timeout.patch

• CVE-2021-3711: fix SM2 decryption buffer overflow; check the plaintext buffer is large enough when decrypting SM2; add extended tests for SM2
• CVE-2022-3996: fix X.509 policy constraints double-locking denial of service
• CVE-2023-0464: fix excessive resource use verifying X.509 policy constraints
• CVE-2023-0466: fix X509_VERIFY_PARAM_add0_policy() does not enable policy check
• CVE-2023-2650: restrict the size of OBJECT IDENTIFIERs that OBJ_obj2txt translates
• CVE-2024-13176: fix timing side-channel in ECDSA signature computation
• CVE-2024-5535: validate provided client list in SSL_select_next_proto
• CVE-2025-9230: fix out-of-bounds read and write in RFC 3211 KEK unwrap
• CVE-2025-69419: fix one-byte write-before-buffer in PKCS#12 BMPString conversion
• CVE-2025-69421: fix NULL dereference in PKCS12_item_decrypt_d2i_ex()
• CVE-2026-28387: fix use-after-free / double-free in dane_match()
• CVE-2026-28388: fix NULL dereference in check_delta_base()
• CVE-2026-28389: fix NULL dereference in dh/ecdh_cms_set_shared_info()
• CVE-2026-28390: fix NULL dereference in rsa_cms_decrypt()

• CVE-2021-3711: fix SM2 decryption buffer overflow; check the plaintext buffer is large enough when decrypting SM2; add extended tests for SM2
• CVE-2022-3996: fix X.509 policy constraints double-locking denial of service
• CVE-2023-0464: fix excessive resource use verifying X.509 policy constraints
• CVE-2023-0466: fix X509_VERIFY_PARAM_add0_policy() does not enable policy check
• CVE-2023-2650: restrict the size of OBJECT IDENTIFIERs that OBJ_obj2txt translates
• CVE-2024-13176: fix timing side-channel in ECDSA signature computation
• CVE-2024-5535: validate provided client list in SSL_select_next_proto
• CVE-2025-9230: fix out-of-bounds read and write in RFC 3211 KEK unwrap
• CVE-2025-69419: fix one-byte write-before-buffer in PKCS#12 BMPString conversion
• CVE-2025-69421: fix NULL dereference in PKCS12_item_decrypt_d2i_ex()
• CVE-2026-28387: fix use-after-free / double-free in dane_match()
• CVE-2026-28388: fix NULL dereference in check_delta_base()
• CVE-2026-28389: fix NULL dereference in dh/ecdh_cms_set_shared_info()
• CVE-2026-28390: fix NULL dereference in rsa_cms_decrypt()

• CVE-2021-3711: fix SM2 decryption buffer overflow; check the plaintext buffer is large enough when decrypting SM2; add extended tests for SM2
• CVE-2022-3996: fix X.509 policy constraints double-locking denial of service
• CVE-2023-0464: fix excessive resource use verifying X.509 policy constraints
• CVE-2023-0466: fix X509_VERIFY_PARAM_add0_policy() does not enable policy check
• CVE-2023-2650: restrict the size of OBJECT IDENTIFIERs that OBJ_obj2txt translates
• CVE-2024-13176: fix timing side-channel in ECDSA signature computation
• CVE-2024-5535: validate provided client list in SSL_select_next_proto
• CVE-2025-9230: fix out-of-bounds read and write in RFC 3211 KEK unwrap
• CVE-2025-69419: fix one-byte write-before-buffer in PKCS#12 BMPString conversion
• CVE-2025-69421: fix NULL dereference in PKCS12_item_decrypt_d2i_ex()
• CVE-2026-28387: fix use-after-free / double-free in dane_match()
• CVE-2026-28388: fix NULL dereference in check_delta_base()
• CVE-2026-28389: fix NULL dereference in dh/ecdh_cms_set_shared_info()
• CVE-2026-28390: fix NULL dereference in rsa_cms_decrypt()

SSL_select_next_proto buffer overread. (CVE-2024-5535)

The updated packages fix security vulnerabilities

The updated packages fix security vulnerabilities

These are all security issues fixed in the libopenssl-1_1-devel-1.1.1w-11.1 package on the GA media of openSUSE Tumbleweed.

These are all security issues fixed in the libopenssl-3-devel-3.1.4-11.1 package on the GA media of openSUSE Tumbleweed.

OpenSSL is a toolkit that implements the Secure Sockets Layer (SSL) and Transport Layer Security (TLS) protocols, as well as a full-strength general-purpose cryptography library.

Security Fix(es):

• openssl: SSL_select_next_proto buffer overread (CVE-2024-5535)

For more details about the security issue(s), including the impact, a CVSS score, acknowledgments, and other related information, refer to the CVE page(s) listed in the References section.