From a86caf9d9187814640dd066573cd8c221ed1e82e Mon Sep 17 00:00:00 2001 From: Azure Linux Security Servicing Account Date: Wed, 26 Aug 2026 20:42:53 +0000 Subject: [PATCH 1/2] Patch openssl for CVE-2026-75803, CVE-2026-63076, CVE-2026-63075, CVE-2026-63074, CVE-2026-63073, CVE-2026-63072, CVE-2026-54874 --- SPECS/openssl/CVE-2026-54874.patch | 91 ++++++++ SPECS/openssl/CVE-2026-63072.patch | 51 +++++ SPECS/openssl/CVE-2026-63073.patch | 42 ++++ SPECS/openssl/CVE-2026-63074.patch | 53 +++++ SPECS/openssl/CVE-2026-63075.patch | 197 ++++++++++++++++++ SPECS/openssl/CVE-2026-63076.patch | 42 ++++ SPECS/openssl/CVE-2026-75803.patch | 153 ++++++++++++++ SPECS/openssl/openssl.spec | 12 +- .../manifests/package/pkggen_core_aarch64.txt | 10 +- .../manifests/package/pkggen_core_x86_64.txt | 10 +- .../manifests/package/toolchain_aarch64.txt | 12 +- .../manifests/package/toolchain_x86_64.txt | 12 +- 12 files changed, 662 insertions(+), 23 deletions(-) create mode 100644 SPECS/openssl/CVE-2026-54874.patch create mode 100644 SPECS/openssl/CVE-2026-63072.patch create mode 100644 SPECS/openssl/CVE-2026-63073.patch create mode 100644 SPECS/openssl/CVE-2026-63074.patch create mode 100644 SPECS/openssl/CVE-2026-63075.patch create mode 100644 SPECS/openssl/CVE-2026-63076.patch create mode 100644 SPECS/openssl/CVE-2026-75803.patch diff --git a/SPECS/openssl/CVE-2026-54874.patch b/SPECS/openssl/CVE-2026-54874.patch new file mode 100644 index 00000000000..64d91b949ad --- /dev/null +++ b/SPECS/openssl/CVE-2026-54874.patch @@ -0,0 +1,91 @@ +From e8d55072e55dd5096de11e2e6c149f5422b9aa30 Mon Sep 17 00:00:00 2001 +From: Matt Caswell +Date: Tue, 23 Jun 2026 11:53:17 +0100 +Subject: [PATCH] Avoid full read buffer allocation when buffering DTLS + next-epoch records + +dtls_rlayer_buffer_record() buffers records that arrive early for the +next epoch while a handshake is in progress. It did this by taking +ownership of the entire live read buffer (sized for the largest +possible record, ~16.7KB) and allocating a brand new one to carry on +reading, regardless of how small the buffered record actually was. +With the queue capped at 100 entries, a peer could send around 100 +tiny bogus next-epoch records (~14 bytes each on the wire) and force +around 1.7MB of heap allocation per connection. + +Instead, copy only the record's own on-wire bytes (header and +ciphertext) into the queue entry, and leave the live read buffer +untouched. Memory use is now proportional to what the peer actually +sends. + +Fixes CVE-2026-54874 + +Assisted-by: Claude:claude-sonnet-4-6 +Reviewed-by: Milan Broz +Reviewed-by: Tomas Mraz +Reviewed-by: Andrew Dinh +Merge-date: Mon Aug 24 15:39:09 2026 +Signed-off-by: Azure Linux Security Servicing Account +Upstream-reference: https://github.com/openssl/openssl/commit/7110cb2f75806d0bf809eb2f90790d477900be40.patch +--- + ssl/record/methods/dtls_meth.c | 29 +++++++++++++---------------- + 1 file changed, 13 insertions(+), 16 deletions(-) + +diff --git a/ssl/record/methods/dtls_meth.c b/ssl/record/methods/dtls_meth.c +index b13945a..9e7126c 100644 +--- a/ssl/record/methods/dtls_meth.c ++++ b/ssl/record/methods/dtls_meth.c +@@ -299,29 +299,26 @@ static int dtls_rlayer_buffer_record(OSSL_RECORD_LAYER *rl, struct pqueue_st *qu + return -1; + } + +- rdata->packet = rl->packet; ++ /* ++ * Take a copy of just this record's on-wire bytes (header + ciphertext) ++ * rather than the whole (much larger) read buffer. The live rl->rbuf is ++ * left untouched and continues to be used for subsequent reads. ++ */ + rdata->packet_length = rl->packet_length; +- memcpy(&(rdata->rbuf), &rl->rbuf, sizeof(TLS_BUFFER)); +- memcpy(&(rdata->rrec), &rl->rrec[0], sizeof(TLS_RL_RECORD)); +- +- item->data = rdata; +- +- rl->packet = NULL; +- rl->packet_length = 0; +- memset(&rl->rbuf, 0, sizeof(TLS_BUFFER)); +- memset(&rl->rrec[0], 0, sizeof(rl->rrec[0])); +- +- if (!tls_setup_read_buffer(rl)) { +- /* RLAYERfatal() already called */ +- OPENSSL_free(rdata->rbuf.buf); ++ rdata->packet = OPENSSL_memdup(rl->packet, rl->packet_length); ++ if (rdata->packet == NULL) { + OPENSSL_free(rdata); + pitem_free(item); ++ RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); + return -1; + } ++ memcpy(&(rdata->rrec), &rl->rrec[0], sizeof(TLS_RL_RECORD)); ++ ++ item->data = rdata; + + if (pqueue_insert(queue, item) == NULL) { + /* Must be a duplicate so ignore it */ +- OPENSSL_free(rdata->rbuf.buf); ++ OPENSSL_free(rdata->packet); + OPENSSL_free(rdata); + pitem_free(item); + } +@@ -607,7 +604,7 @@ static int dtls_free(OSSL_RECORD_LAYER *rl) + /* Push to the next record layer */ + ret &= BIO_write_ex(rl->next, rdata->packet, rdata->packet_length, + &written); +- OPENSSL_free(rdata->rbuf.buf); ++ OPENSSL_free(rdata->packet); + OPENSSL_free(item->data); + pitem_free(item); + } +-- +2.45.4 + diff --git a/SPECS/openssl/CVE-2026-63072.patch b/SPECS/openssl/CVE-2026-63072.patch new file mode 100644 index 00000000000..19fca871098 --- /dev/null +++ b/SPECS/openssl/CVE-2026-63072.patch @@ -0,0 +1,51 @@ +From c8948e1c0eaaec49987b641d5076b89d302ad2c6 Mon Sep 17 00:00:00 2001 +From: Daniel Kubec +Date: Sun, 2 Aug 2026 00:23:39 +0000 +Subject: [PATCH] Fix heap buffer overflow (8-byte OOB write) in AES-WRAP-PAD + unwrap + +On its integrity-failure paths that primitive writes and cleanses up to inlen +bytes of the output buffer. Size the buffer for that worst case so a failed +unwrap cannot write past the allocation. + +Fixes CVE-2026-63072 + +Reviewed-by: Milan Broz +Reviewed-by: Andrew Dinh +Merge-date: Mon Aug 24 14:44:05 2026 +Signed-off-by: Azure Linux Security Servicing Account +Upstream-reference: https://github.com/openssl/openssl/commit/9ec2f6d2ae2bcad907cf7ee38584855bafe4979a.patch +--- + crypto/cms/cms_kari.c | 9 ++++++++- + 1 file changed, 8 insertions(+), 1 deletion(-) + +diff --git a/crypto/cms/cms_kari.c b/crypto/cms/cms_kari.c +index 79697cd..74d5841 100644 +--- a/crypto/cms/cms_kari.c ++++ b/crypto/cms/cms_kari.c +@@ -217,6 +217,7 @@ static int cms_kek_cipher(unsigned char **pout, size_t *poutlen, + int rv = 0; + unsigned char *out = NULL; + int outlen; ++ size_t outsize; + + keklen = EVP_CIPHER_CTX_get_key_length(kari->ctx); + if (keklen > EVP_MAX_KEY_LENGTH) +@@ -230,7 +231,13 @@ static int cms_kek_cipher(unsigned char **pout, size_t *poutlen, + /* obtain output length of ciphered key */ + if (!EVP_CipherUpdate(kari->ctx, NULL, &outlen, in, inlen)) + goto err; +- out = OPENSSL_malloc(outlen); ++ /* ++ * On its integrity-failure paths that primitive writes and cleanses up to ++ * inlen bytes of the output buffer. Size the buffer for that worst case so ++ * a failed unwrap cannot write past the allocation. ++ */ ++ outsize = (size_t)outlen < inlen ? inlen : (size_t)outlen; ++ out = OPENSSL_malloc(outsize); + if (out == NULL) + goto err; + if (!EVP_CipherUpdate(kari->ctx, out, &outlen, in, inlen)) +-- +2.45.4 + diff --git a/SPECS/openssl/CVE-2026-63073.patch b/SPECS/openssl/CVE-2026-63073.patch new file mode 100644 index 00000000000..acdeb9ed376 --- /dev/null +++ b/SPECS/openssl/CVE-2026-63073.patch @@ -0,0 +1,42 @@ +From 7d84f4435382b0f6e7ec2e602064dc2f9d3664cf Mon Sep 17 00:00:00 2001 +From: Norbert Pocs +Date: Mon, 20 Jul 2026 14:10:47 +0200 +Subject: [PATCH] CMP unexpected sender DN used as format string in + ERR_raise_data() + +ossl_cmp_msg_check_update() converts an unexpected CMP response sender DN with +X509_NAME_oneline() and passes that peer-controlled string directly as the +format argument to ERR_raise_data(). Printable percent characters survive the +DN conversion, so a sender such as CN=%s%n reaches vsnprintf() as active format +syntax without matching varargs. + +Fixes: CVE-2026-63073 + +Original patch by: Filipe Casal of Trail of Bits in collaboration with OpenAI + +Signed-off-by: Norbert Pocs +Reviewed-by: Milan Broz +Reviewed-by: Igor Ustinov +Merge-date: Mon Aug 24 13:02:29 2026 +Signed-off-by: Azure Linux Security Servicing Account +Upstream-reference: https://github.com/openssl/openssl/commit/a7e5a6eea8fd3ccca6b6fbba031a5fbf8a3d93b4.patch +--- + crypto/cmp/cmp_vfy.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/crypto/cmp/cmp_vfy.c b/crypto/cmp/cmp_vfy.c +index d6d18d7..f89a65f 100644 +--- a/crypto/cmp/cmp_vfy.c ++++ b/crypto/cmp/cmp_vfy.c +@@ -730,7 +730,7 @@ int ossl_cmp_msg_check_update(OSSL_CMP_CTX *ctx, const OSSL_CMP_MSG *msg, + "expected sender", expected_sender)) { + str = X509_NAME_oneline(actual_sender, NULL, 0); + ERR_raise_data(ERR_LIB_CMP, CMP_R_UNEXPECTED_SENDER, +- str != NULL ? str : ""); ++ "%s", str != NULL ? str : ""); + OPENSSL_free(str); + return 0; + } +-- +2.45.4 + diff --git a/SPECS/openssl/CVE-2026-63074.patch b/SPECS/openssl/CVE-2026-63074.patch new file mode 100644 index 00000000000..4c61d1e7dd4 --- /dev/null +++ b/SPECS/openssl/CVE-2026-63074.patch @@ -0,0 +1,53 @@ +From 2e579bc487e3ba8f7161796eaa554cc239a66d21 Mon Sep 17 00:00:00 2001 +From: Neil Horman +Date: Tue, 30 Jun 2026 15:09:01 -0400 +Subject: [PATCH] Fix unbounded cert cache growth in cmp + +If a remote user sends cmp messages to a server with a list of +extraCerts and the message is rejected, the extraCerts from the message +remain in the server contexts untrusted certificate stack. This exposes +servers with long lived ctx objects to denial of service attacks in +which an attacker sends messages intending to be rejected with a large +list of additional cerificated repeatedly, forcing the server to store +them indefinately. + +Fix it by rolling back the added extra certs if the message is rejected, +using the same method we do when the context is configured to not do +caching at all. + +Fixes openssl/srt#224 + +Fixes CVE-2026-63074 + +Reviewed-by: Milan Broz +Reviewed-by: Tomas Mraz +Merge-date: Mon Aug 24 12:42:57 2026 +Signed-off-by: Azure Linux Security Servicing Account +Upstream-reference: https://github.com/openssl/openssl/commit/f636f9ca0fa1bae5b42f9e787f025c96fb09c43a.patch +--- + crypto/cmp/cmp_vfy.c | 9 +++++++-- + 1 file changed, 7 insertions(+), 2 deletions(-) + +diff --git a/crypto/cmp/cmp_vfy.c b/crypto/cmp/cmp_vfy.c +index f89a65f..b6d69ff 100644 +--- a/crypto/cmp/cmp_vfy.c ++++ b/crypto/cmp/cmp_vfy.c +@@ -774,8 +774,13 @@ int ossl_cmp_msg_check_update(OSSL_CMP_CTX *ctx, const OSSL_CMP_MSG *msg, + res = 1; /* support more aggressive fuzzing by letting invalid msg pass */ + #endif + +- /* remove extraCerts again if not caching */ +- if (ctx->noCacheExtraCerts) ++ /* ++ * remove extraCerts again if not caching ++ * or if we failed validation above, lest a remote user ++ * starts sending us lots of certificates in invalid messages ++ * leading to a DOS from unbounded certificate stack growth ++ */ ++ if (ctx->noCacheExtraCerts || res != 1) + while (num_added-- > 0) + X509_free(sk_X509_shift(ctx->untrusted)); + +-- +2.45.4 + diff --git a/SPECS/openssl/CVE-2026-63075.patch b/SPECS/openssl/CVE-2026-63075.patch new file mode 100644 index 00000000000..6a31c0414f3 --- /dev/null +++ b/SPECS/openssl/CVE-2026-63075.patch @@ -0,0 +1,197 @@ +From 1045a4e5dff9dd08cbd76c04df3b4b69c80edf59 Mon Sep 17 00:00:00 2001 +From: Neil Horman +Date: Thu, 9 Jul 2026 15:34:30 -0400 +Subject: [PATCH] Don't store ACK-only frames in TX history for QUIC. +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +When QUIC sends an ACK-only frame, there is no expectation that the +peer will ack that ack (i.e. it is itself not ack-eliciting). However, +our implementation stores these frames in the TX history regardless. In and +of itself thats ok, but if a malicious client establishes a connection, +and then drives the connection such that ack-only frames are forced from +the peer (i.e. by sending numerous ping frames), and then withholding +any subseqent acks for ack-eliciting data, like legitimate data, said +malicious client can force inappropriate memory growth on the server, +leading to potential DOS attacks. + +Don't store any ACK-only frames in the TX history to address this. Record it in +our TX history so that the send window moves forward appropriately, but for +ack-only frames, immediately remove it, since we don't expect to get an ack for +them anyway. + +Initially authored by Opal Wright + +The initial proposal had some shortcommings in which the highest pn +acked value was not accounted for which I have fixed with the assistance +of Claude + +Assisted-by: Anthopic Sonnet 5 + +Fixes CVE-2026-63075 + +Reviewed-by: Saša Nedvědický +Reviewed-by: Bob Beck +Merge-date: Mon Aug 24 12:28:10 2026 +Signed-off-by: Azure Linux Security Servicing Account +Upstream-reference: https://github.com/openssl/openssl/commit/c902e5f16d6a9e130e96d3ca6d8f64d71652e393.patch +--- + include/internal/quic_ackm.h | 5 ++++ + ssl/quic/quic_ackm.c | 32 +++++++++++++++++++++++++ + ssl/quic/quic_txp.c | 46 ++++++++++++++++++++++++++---------- + 3 files changed, 71 insertions(+), 12 deletions(-) + +diff --git a/include/internal/quic_ackm.h b/include/internal/quic_ackm.h +index c0617da..aa402d2 100644 +--- a/include/internal/quic_ackm.h ++++ b/include/internal/quic_ackm.h +@@ -129,6 +129,11 @@ struct ossl_ackm_tx_pkt_st { + }; + + int ossl_ackm_on_tx_packet(OSSL_ACKM *ackm, OSSL_ACKM_TX_PKT *pkt); ++ ++/* ++ * Records transmission of a packet containing only ACK frames. ++ */ ++int ossl_ackm_on_tx_ack_only_packet(OSSL_ACKM *ackm, OSSL_ACKM_TX_PKT *pkt); + int ossl_ackm_on_rx_datagram(OSSL_ACKM *ackm, size_t num_bytes); + + #define OSSL_ACKM_ECN_NONE 0 +diff --git a/ssl/quic/quic_ackm.c b/ssl/quic/quic_ackm.c +index 503a6ea..2b9ca61 100644 +--- a/ssl/quic/quic_ackm.c ++++ b/ssl/quic/quic_ackm.c +@@ -1131,6 +1131,38 @@ int ossl_ackm_on_tx_packet(OSSL_ACKM *ackm, OSSL_ACKM_TX_PKT *pkt) + return 1; + } + ++int ossl_ackm_on_tx_ack_only_packet(OSSL_ACKM *ackm, OSSL_ACKM_TX_PKT *pkt) ++{ ++ struct tx_pkt_history_st *h; ++ unsigned int pkt_space; ++ ++ if (pkt == NULL || pkt->pkt_space >= QUIC_PN_SPACE_NUM) ++ return 0; ++ ++ /* ++ * A packet containing only an ACK frame must not be treated as ++ * in-flight or ack-eliciting; if it were, ossl_ackm_on_tx_packet() ++ * below would (correctly) perform bytes-in-flight/timer/CC bookkeeping ++ * for a packet we are about to discard from history, which would be ++ * incorrect. ++ */ ++ if (pkt->is_inflight || pkt->is_ack_eliciting) ++ return 0; ++ ++ pkt_space = pkt->pkt_space; ++ ++ /* ++ * No one can expect ACK for packet which carries ACK frames only ++ * (ack_only packet). The ACKM does not need to keep record for ack_only ++ * packet. For ack_only packet the ACKM manager must be updated by the ++ * highest packet number which got sent. ++ */ ++ h = get_tx_history(ackm, pkt_space); ++ h->highest_sent = pkt->pkt_num; ++ ++ return 1; ++} ++ + int ossl_ackm_on_rx_datagram(OSSL_ACKM *ackm, size_t num_bytes) + { + /* No-op on the client. */ +diff --git a/ssl/quic/quic_txp.c b/ssl/quic/quic_txp.c +index 5acc3fe..b447ea2 100644 +--- a/ssl/quic/quic_txp.c ++++ b/ssl/quic/quic_txp.c +@@ -2835,6 +2835,20 @@ fatal_err: + return TXP_ERR_INTERNAL; + } + ++static int txp_pkt_is_ack_only(const QUIC_TXPIM_PKT *tpkt) ++{ ++ return tpkt->had_ack_frame ++ && !tpkt->ackm_pkt.is_inflight ++ && !tpkt->ackm_pkt.is_ack_eliciting ++ && !tpkt->had_handshake_done_frame ++ && !tpkt->had_max_data_frame ++ && !tpkt->had_max_streams_bidi_frame ++ && !tpkt->had_max_streams_uni_frame ++ && !tpkt->had_conn_close ++ && tpkt->retx_head == NULL ++ && ossl_quic_txpim_pkt_get_num_chunks(tpkt) == 0; ++} ++ + /* + * Commits and queues a packet for transmission. There is no backing out after + * this. +@@ -2843,8 +2857,9 @@ fatal_err: + * + * - Sends the packet to the QTX for encryption and transmission; + * +- * - Records the packet as having been transmitted in FIFM. ACKM is informed, +- * etc. and the TXPIM record is filed. ++ * - Records non-ACK-only packets as having been transmitted in FIFM. ACKM is ++ * informed, etc. and the TXPIM record is filed only when later callbacks ++ * need it. + * + * - Informs various subsystems of frames that were sent and clears frame + * wanted flags so that we do not generate the same frames again. +@@ -2871,7 +2886,7 @@ static int txp_pkt_commit(OSSL_QUIC_TX_PACKETISER *txp, + uint32_t archetype, + int *txpim_pkt_reffed) + { +- int rc = 1; ++ int ack_only, rc = 1; + uint32_t enc_level = pkt->h.enc_level; + uint32_t pn_space = ossl_quic_enc_level_to_pn_space(enc_level); + QUIC_TXPIM_PKT *tpkt = pkt->tpkt; +@@ -2915,28 +2930,35 @@ static int txp_pkt_commit(OSSL_QUIC_TX_PACKETISER *txp, + return 0; /* alloc error */ + } + +- /* Dispatch to FIFD. */ +- if (!ossl_quic_fifd_pkt_commit(&txp->fifd, tpkt)) ++ ack_only = txp_pkt_is_ack_only(tpkt); ++ ++ /* Dispatch packets that need loss/retransmit callbacks to FIFD. */ ++ if (!ack_only && !ossl_quic_fifd_pkt_commit(&txp->fifd, tpkt)) + return 0; + + /* + * Transmission and Post-Packet Generation Bookkeeping + * =================================================== + * +- * No backing out anymore - at this point the ACKM has recorded the packet +- * as having been sent, so we need to increment our next PN counter, or +- * the ACKM will complain when we try to record a duplicate packet with +- * the same PN later. At this point actually sending the packet may still +- * fail. In this unlikely event it will simply be handled as though it +- * were a lost packet. ++ * No backing out anymore - at this point we need to increment our next PN ++ * counter, or the ACKM will complain when we try to record a duplicate ++ * packet with the same PN later. Non-ACK-only packets have also been ++ * recorded in ACKM, so if QTX write fails they are handled as though they ++ * were lost. ACK-only packets are not recorded and will be cleaned up by ++ * the caller. + */ + ++txp->next_pn[pn_space]; +- *txpim_pkt_reffed = 1; ++ if (!ack_only) ++ *txpim_pkt_reffed = 1; + + /* Send the packet. */ + if (!ossl_qtx_write_pkt(txp->args.qtx, &txpkt)) + return 0; + ++ if (ack_only ++ && !ossl_ackm_on_tx_ack_only_packet(txp->args.ackm, &tpkt->ackm_pkt)) ++ rc = 0; ++ + /* + * Record FC and stream abort frames as sent; deactivate streams which no + * longer have anything to do. +-- +2.45.4 + diff --git a/SPECS/openssl/CVE-2026-63076.patch b/SPECS/openssl/CVE-2026-63076.patch new file mode 100644 index 00000000000..86fab33796d --- /dev/null +++ b/SPECS/openssl/CVE-2026-63076.patch @@ -0,0 +1,42 @@ +From 6faaf242e8fac2a2b65b0bd5520e469861b8349a Mon Sep 17 00:00:00 2001 +From: Daniel Kubec +Date: Tue, 21 Jul 2026 11:19:29 +0200 +Subject: [PATCH] Fix Remote NULL deref in ossl_cmp_calc_protection() via + crafted protectionAlg + +ossl_cmp_calc_protection() only checked whether the protectionAlg parameter +(ppval) was NULL before treating it as a PBMParameter ASN1_STRING. + +X509_ALGOR_get0() does not validate the ASN.1 type of the parameter against what +the caller expects. For id-PasswordBasedMAC, a crafted message can encode the +parameter as a BOOLEAN instead of the expected PBMParameter SEQUENCE. Because +the ASN1_TYPE value union overlays the boolean int on the pointer field, ppval +comes back as a bogus non-NULL pointer (e.g. 0xff). + +Fixes CVE-2026-63076 + +Reviewed-by: Milan Broz +Reviewed-by: Norbert Pocs +Merge-date: Sat Aug 22 06:11:45 2026 +Signed-off-by: Azure Linux Security Servicing Account +Upstream-reference: https://github.com/openssl/openssl/commit/a1f348ccb328c3afbd4ba6883f9b7c813c043259.patch +--- + crypto/cmp/cmp_protect.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/crypto/cmp/cmp_protect.c b/crypto/cmp/cmp_protect.c +index e9c4d52..d45f0da 100644 +--- a/crypto/cmp/cmp_protect.c ++++ b/crypto/cmp/cmp_protect.c +@@ -66,7 +66,7 @@ ASN1_BIT_STRING *ossl_cmp_calc_protection(const OSSL_CMP_CTX *ctx, + ERR_raise(ERR_LIB_CMP, CMP_R_MISSING_PBM_SECRET); + return NULL; + } +- if (ppval == NULL) { ++ if (pptype != V_ASN1_SEQUENCE || ppval == NULL) { + ERR_raise(ERR_LIB_CMP, CMP_R_ERROR_CALCULATING_PROTECTION); + return NULL; + } +-- +2.45.4 + diff --git a/SPECS/openssl/CVE-2026-75803.patch b/SPECS/openssl/CVE-2026-75803.patch new file mode 100644 index 00000000000..6a501169de0 --- /dev/null +++ b/SPECS/openssl/CVE-2026-75803.patch @@ -0,0 +1,153 @@ +From 8bbdb66edc32e5e2149cd65e5d80a0aa71ddec57 Mon Sep 17 00:00:00 2001 +From: Billy Brumley +Date: Tue, 4 Aug 2026 07:35:48 -0400 +Subject: [PATCH] Check the tag on EVP_Cipher() finalize: Poly1305 and OCB + AEADs + +For the affected OpenSSL built-in provider AEAD implementations, +EVP_Cipher(ctx, out, NULL, 0) reaches the ccipher callback as a +NULL-input terminal call. OCB and ChaCha20-Poly1305 took an early exit +on an empty message, with or without AAD, and returned success without +comparing an explicitly supplied tag. Consequently a corrupted tag was +accepted before this change. + +Make these built-in callbacks perform their terminal tag operation, +aligning their explicit-tag handling with the streaming Final path +without defining NULL input as part of the generic EVP_Cipher() +contract. + +AES-GCM-SIV also failed to generate a tag when Final was its first +empty-message operation. Generate the tag in that case and propagate +failures from the matching empty-message decrypt operation. + +The stable ChaCha20-Poly1305 implementation aliases Update to the +one-shot cipher callback, so this backport introduces a dedicated Update +callback to preserve zero-length Update as a no-op. + +Follow-up to #31555 +Fixes #32258 +Fixes CVE-2026-75803 + +Assisted-by: Claude:claude-opus-4-8 +Assisted-by: Codex:gpt-5.6-sol + +(cherry picked from commit 5741d29a5f356e05262cd0936a472a9961398d53) + +Co-authored-by: Mounir IDRASSI +Reviewed-by: Bob Beck +Reviewed-by: Tomas Mraz +Merge-date: Wed Aug 19 17:41:16 2026 +Merged-from: https://github.com/openssl/openssl/pull/32416 +Signed-off-by: Azure Linux Security Servicing Account +Upstream-reference: https://github.com/openssl/openssl/commit/bf95f5f772e9362f87b25cfa2f8cb15d984865b9.patch +--- + .../ciphers/cipher_aes_gcm_siv_hw.c | 14 +++++++--- + .../implementations/ciphers/cipher_aes_ocb.c | 4 +++ + .../ciphers/cipher_chacha20_poly1305.c | 27 ++++++++++++++----- + 3 files changed, 34 insertions(+), 11 deletions(-) + +diff --git a/providers/implementations/ciphers/cipher_aes_gcm_siv_hw.c b/providers/implementations/ciphers/cipher_aes_gcm_siv_hw.c +index fe33aa6..f77ed76 100644 +--- a/providers/implementations/ciphers/cipher_aes_gcm_siv_hw.c ++++ b/providers/implementations/ciphers/cipher_aes_gcm_siv_hw.c +@@ -267,11 +267,17 @@ static int aes_gcm_siv_finish(PROV_AES_GCM_SIV_CTX *ctx) + { + int ret = 0; + +- if (ctx->enc) ++ if (ctx->enc) { ++ /* Generate the tag when Final is the first empty-message operation. */ ++ if (ctx->generated_tag == 0 ++ && aes_gcm_siv_encrypt(ctx, NULL, NULL, 0) == 0) ++ return 0; + return ctx->generated_tag; +- if (!ctx->generated_tag) +- aes_gcm_siv_decrypt(ctx, NULL, NULL, 0); +- ret = !CRYPTO_memcmp(ctx->tag, ctx->user_tag, sizeof(ctx->tag)); ++ } ++ if (ctx->generated_tag == 0 ++ && aes_gcm_siv_decrypt(ctx, NULL, NULL, 0) == 0) ++ return 0; ++ ret = CRYPTO_memcmp(ctx->tag, ctx->user_tag, sizeof(ctx->tag)) == 0; + ret &= ctx->have_user_tag; + return ret; + } +diff --git a/providers/implementations/ciphers/cipher_aes_ocb.c b/providers/implementations/ciphers/cipher_aes_ocb.c +index 71b1fda..24845f3 100644 +--- a/providers/implementations/ciphers/cipher_aes_ocb.c ++++ b/providers/implementations/ciphers/cipher_aes_ocb.c +@@ -509,6 +509,10 @@ static int aes_ocb_cipher(void *vctx, unsigned char *out, size_t *outl, + if (!ossl_prov_is_running()) + return 0; + ++ /* NULL input indicates Final, which must generate or check the tag. */ ++ if (in == NULL) ++ return aes_ocb_block_final(vctx, out, outl, outsize); ++ + if (outsize < inl) { + ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL); + return 0; +diff --git a/providers/implementations/ciphers/cipher_chacha20_poly1305.c b/providers/implementations/ciphers/cipher_chacha20_poly1305.c +index 4e4c8b0..7e7d1e0 100644 +--- a/providers/implementations/ciphers/cipher_chacha20_poly1305.c ++++ b/providers/implementations/ciphers/cipher_chacha20_poly1305.c +@@ -1,5 +1,5 @@ + /* +- * Copyright 2019-2025 The OpenSSL Project Authors. All Rights Reserved. ++ * Copyright 2019-2026 The OpenSSL Project Authors. All Rights Reserved. + * + * Licensed under the Apache License 2.0 (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy +@@ -30,11 +30,11 @@ static OSSL_FUNC_cipher_get_params_fn chacha20_poly1305_get_params; + static OSSL_FUNC_cipher_get_ctx_params_fn chacha20_poly1305_get_ctx_params; + static OSSL_FUNC_cipher_set_ctx_params_fn chacha20_poly1305_set_ctx_params; + static OSSL_FUNC_cipher_cipher_fn chacha20_poly1305_cipher; ++static OSSL_FUNC_cipher_update_fn chacha20_poly1305_update; + static OSSL_FUNC_cipher_final_fn chacha20_poly1305_final; + static OSSL_FUNC_cipher_gettable_ctx_params_fn chacha20_poly1305_gettable_ctx_params; + static OSSL_FUNC_cipher_settable_ctx_params_fn chacha20_poly1305_settable_ctx_params; + #define chacha20_poly1305_gettable_params ossl_cipher_generic_gettable_params +-#define chacha20_poly1305_update chacha20_poly1305_cipher + + static void *chacha20_poly1305_newctx(void *provctx) + { +@@ -301,11 +301,6 @@ static int chacha20_poly1305_cipher(void *vctx, unsigned char *out, + if (!ossl_prov_is_running()) + return 0; + +- if (inl == 0) { +- *outl = 0; +- return 1; +- } +- + if (outsize < inl) { + ERR_raise(ERR_LIB_PROV, PROV_R_OUTPUT_BUFFER_TOO_SMALL); + return 0; +@@ -317,6 +312,24 @@ static int chacha20_poly1305_cipher(void *vctx, unsigned char *out, + return 1; + } + ++static int chacha20_poly1305_update(void *vctx, unsigned char *out, ++ size_t *outl, size_t outsize, ++ const unsigned char *in, size_t inl) ++{ ++ /* ++ * A zero-length update is a no-op. Only EVP_Cipher() and Final produce or ++ * check the authentication tag. ++ */ ++ if (inl == 0) { ++ if (!ossl_prov_is_running()) ++ return 0; ++ *outl = 0; ++ return 1; ++ } ++ ++ return chacha20_poly1305_cipher(vctx, out, outl, outsize, in, inl); ++} ++ + static int chacha20_poly1305_final(void *vctx, unsigned char *out, size_t *outl, + size_t outsize) + { +-- +2.45.4 + diff --git a/SPECS/openssl/openssl.spec b/SPECS/openssl/openssl.spec index ef5f3858eb2..f1fe3b300ac 100644 --- a/SPECS/openssl/openssl.spec +++ b/SPECS/openssl/openssl.spec @@ -9,7 +9,7 @@ Summary: Utilities from the general purpose cryptography library with TLS implementation Name: openssl Version: 3.3.7 -Release: 4%{?dist} +Release: 5%{?dist} Vendor: Microsoft Corporation Distribution: Azure Linux Source: https://github.com/openssl/openssl/releases/download/openssl-%{version}/openssl-%{version}.tar.gz @@ -81,6 +81,13 @@ Patch110: CVE-2026-42767.patch Patch111: CVE-2026-45447.patch Patch112: CVE-2026-42769.patch Patch113: CVE-2026-42770.patch +Patch114: CVE-2026-54874.patch +Patch115: CVE-2026-63072.patch +Patch116: CVE-2026-63073.patch +Patch117: CVE-2026-63074.patch +Patch118: CVE-2026-63075.patch +Patch119: CVE-2026-63076.patch +Patch120: CVE-2026-75803.patch License: Apache-2.0 URL: http://www.openssl.org/ @@ -377,6 +384,9 @@ install -m644 %{SOURCE9} \ %ldconfig_scriptlets libs %changelog +* Wed Aug 26 2026 Azure Linux Security Servicing Account - 3.3.7-5 +- Patch for CVE-2026-75803, CVE-2026-63076, CVE-2026-63075, CVE-2026-63074, CVE-2026-63073, CVE-2026-63072, CVE-2026-54874 + * Thu Jul 16 2026 Kanishk Bansal - 3.3.7-4 - Patch CVE-2026-45447, CVE-2026-42769, CVE-2026-42770 diff --git a/toolkit/resources/manifests/package/pkggen_core_aarch64.txt b/toolkit/resources/manifests/package/pkggen_core_aarch64.txt index 1349a92959d..47f8dad6e9b 100644 --- a/toolkit/resources/manifests/package/pkggen_core_aarch64.txt +++ b/toolkit/resources/manifests/package/pkggen_core_aarch64.txt @@ -170,11 +170,11 @@ gtk-doc-1.33.2-1.azl3.noarch.rpm autoconf-2.72-2.azl3.noarch.rpm automake-1.16.5-2.azl3.noarch.rpm ocaml-srpm-macros-9-4.azl3.noarch.rpm -openssl-3.3.7-4.azl3.aarch64.rpm -openssl-devel-3.3.7-4.azl3.aarch64.rpm -openssl-libs-3.3.7-4.azl3.aarch64.rpm -openssl-perl-3.3.7-4.azl3.aarch64.rpm -openssl-static-3.3.7-4.azl3.aarch64.rpm +openssl-3.3.7-5.azl3.aarch64.rpm +openssl-devel-3.3.7-5.azl3.aarch64.rpm +openssl-libs-3.3.7-5.azl3.aarch64.rpm +openssl-perl-3.3.7-5.azl3.aarch64.rpm +openssl-static-3.3.7-5.azl3.aarch64.rpm libcap-2.69-15.azl3.aarch64.rpm libcap-devel-2.69-15.azl3.aarch64.rpm debugedit-5.0-3.azl3.aarch64.rpm diff --git a/toolkit/resources/manifests/package/pkggen_core_x86_64.txt b/toolkit/resources/manifests/package/pkggen_core_x86_64.txt index 92a56a6eace..705a83bed42 100644 --- a/toolkit/resources/manifests/package/pkggen_core_x86_64.txt +++ b/toolkit/resources/manifests/package/pkggen_core_x86_64.txt @@ -170,11 +170,11 @@ gtk-doc-1.33.2-1.azl3.noarch.rpm autoconf-2.72-2.azl3.noarch.rpm automake-1.16.5-2.azl3.noarch.rpm ocaml-srpm-macros-9-4.azl3.noarch.rpm -openssl-3.3.7-4.azl3.x86_64.rpm -openssl-devel-3.3.7-4.azl3.x86_64.rpm -openssl-libs-3.3.7-4.azl3.x86_64.rpm -openssl-perl-3.3.7-4.azl3.x86_64.rpm -openssl-static-3.3.7-4.azl3.x86_64.rpm +openssl-3.3.7-5.azl3.x86_64.rpm +openssl-devel-3.3.7-5.azl3.x86_64.rpm +openssl-libs-3.3.7-5.azl3.x86_64.rpm +openssl-perl-3.3.7-5.azl3.x86_64.rpm +openssl-static-3.3.7-5.azl3.x86_64.rpm libcap-2.69-15.azl3.x86_64.rpm libcap-devel-2.69-15.azl3.x86_64.rpm debugedit-5.0-3.azl3.x86_64.rpm diff --git a/toolkit/resources/manifests/package/toolchain_aarch64.txt b/toolkit/resources/manifests/package/toolchain_aarch64.txt index a2afd9b623b..20ad2a229af 100644 --- a/toolkit/resources/manifests/package/toolchain_aarch64.txt +++ b/toolkit/resources/manifests/package/toolchain_aarch64.txt @@ -287,12 +287,12 @@ npth-debuginfo-1.6-4.azl3.aarch64.rpm npth-devel-1.6-4.azl3.aarch64.rpm ntsysv-1.25-1.azl3.aarch64.rpm ocaml-srpm-macros-9-4.azl3.noarch.rpm -openssl-3.3.7-4.azl3.aarch64.rpm -openssl-debuginfo-3.3.7-4.azl3.aarch64.rpm -openssl-devel-3.3.7-4.azl3.aarch64.rpm -openssl-libs-3.3.7-4.azl3.aarch64.rpm -openssl-perl-3.3.7-4.azl3.aarch64.rpm -openssl-static-3.3.7-4.azl3.aarch64.rpm +openssl-3.3.7-5.azl3.aarch64.rpm +openssl-debuginfo-3.3.7-5.azl3.aarch64.rpm +openssl-devel-3.3.7-5.azl3.aarch64.rpm +openssl-libs-3.3.7-5.azl3.aarch64.rpm +openssl-perl-3.3.7-5.azl3.aarch64.rpm +openssl-static-3.3.7-5.azl3.aarch64.rpm p11-kit-0.26.5-1.azl3.aarch64.rpm p11-kit-debuginfo-0.26.5-1.azl3.aarch64.rpm p11-kit-devel-0.26.5-1.azl3.aarch64.rpm diff --git a/toolkit/resources/manifests/package/toolchain_x86_64.txt b/toolkit/resources/manifests/package/toolchain_x86_64.txt index 4d6fd92ab2c..53765575d46 100644 --- a/toolkit/resources/manifests/package/toolchain_x86_64.txt +++ b/toolkit/resources/manifests/package/toolchain_x86_64.txt @@ -295,12 +295,12 @@ npth-debuginfo-1.6-4.azl3.x86_64.rpm npth-devel-1.6-4.azl3.x86_64.rpm ntsysv-1.25-1.azl3.x86_64.rpm ocaml-srpm-macros-9-4.azl3.noarch.rpm -openssl-3.3.7-4.azl3.x86_64.rpm -openssl-debuginfo-3.3.7-4.azl3.x86_64.rpm -openssl-devel-3.3.7-4.azl3.x86_64.rpm -openssl-libs-3.3.7-4.azl3.x86_64.rpm -openssl-perl-3.3.7-4.azl3.x86_64.rpm -openssl-static-3.3.7-4.azl3.x86_64.rpm +openssl-3.3.7-5.azl3.x86_64.rpm +openssl-debuginfo-3.3.7-5.azl3.x86_64.rpm +openssl-devel-3.3.7-5.azl3.x86_64.rpm +openssl-libs-3.3.7-5.azl3.x86_64.rpm +openssl-perl-3.3.7-5.azl3.x86_64.rpm +openssl-static-3.3.7-5.azl3.x86_64.rpm p11-kit-0.26.5-1.azl3.x86_64.rpm p11-kit-debuginfo-0.26.5-1.azl3.x86_64.rpm p11-kit-devel-0.26.5-1.azl3.x86_64.rpm From e628497c3272c08939ee6c5d681c508ea5fb1326 Mon Sep 17 00:00:00 2001 From: Kanishk Bansal Date: Wed, 26 Aug 2026 20:46:11 +0000 Subject: [PATCH 2/2] Manually add patch for CVE-2026-14457 --- SPECS/openssl/CVE-2026-14457.patch | 153 +++++++++++++++++++++++++++++ SPECS/openssl/openssl.spec | 3 +- 2 files changed, 155 insertions(+), 1 deletion(-) create mode 100644 SPECS/openssl/CVE-2026-14457.patch diff --git a/SPECS/openssl/CVE-2026-14457.patch b/SPECS/openssl/CVE-2026-14457.patch new file mode 100644 index 00000000000..4a850f77bb0 --- /dev/null +++ b/SPECS/openssl/CVE-2026-14457.patch @@ -0,0 +1,153 @@ +From 1e8c398db67404babd3e5af999bb6bd86f720c76 Mon Sep 17 00:00:00 2001 +From: Viktor Dukhovni +Date: Sat, 27 Jun 2026 01:02:53 +1000 +Subject: [PATCH] Handle signature_algorithms_cert extension in key-only + context + +Servers or clients that configure only a private key in +expectation of always negotiating use of RFC7250 raw public keys +failed to handle the "signature_algorithms_cert" extension. + +The issue is now resolved and the RPK tests now check that +key-only configurations are robust also when the extension +is sent by the peer. + +Key-only configurations are quite uncommon. As a best practice, +RPK-capable servers and clients pair their private key with a +(possibly self-signed) certificate, enabling fallback to X.509 +handshakes with non-RPK peers. + +Fixes CVE-2026-14457 + +Reviewed-by: Eugene Syromiatnikov +Reviewed-by: Tomas Mraz +Reviewed-by: Norbert Pocs +Merge-date: Mon Aug 24 12:49:45 2026 + +Upstream Patch Reference: https://github.com/openssl/openssl/commit/1e8c398db67404babd3e5af999bb6bd86f720c76.patch +--- + ssl/t1_lib.c | 14 ++++++++++ + test/rpktest.c | 76 +++++++++++++++++++++++++++++++++++++++++++------- + 2 files changed, 80 insertions(+), 10 deletions(-) + +diff --git a/ssl/t1_lib.c b/ssl/t1_lib.c +index 93367804bbbc7..89faa0b642692 100644 +--- a/ssl/t1_lib.c ++++ b/ssl/t1_lib.c +@@ -3634,6 +3634,20 @@ static int check_cert_usable(SSL_CONNECTION *s, const SIGALG_LOOKUP *sig, + if (supported <= 0) + return 0; + ++ /* ++ * When RPK is negotiated there are no certificate signatures to ++ * constrain, and there may not even be a certificate configured. ++ */ ++ if (TLSEXT_cert_type_rpk == (s->server ? s->ext.server_cert_type : s->ext.client_cert_type)) ++ return 1; ++ ++ /* ++ * RPK was enabled, adding candidate private-key-only slots, but was not ++ * negotiated, so the key-only slot is not usable. ++ */ ++ if (x == NULL) ++ return 0; ++ + /* + * The TLS 1.3 signature_algorithms_cert extension places restrictions + * on the sigalg with which the certificate was signed (by its issuer). +diff --git a/test/rpktest.c b/test/rpktest.c +index 4722d6dc3c702..a2505a4254e58 100644 +--- a/test/rpktest.c ++++ b/test/rpktest.c +@@ -38,6 +38,37 @@ static OSSL_PROVIDER *defctxnull = NULL; + static const unsigned char cert_type_rpk[] = { TLSEXT_cert_type_rpk, TLSEXT_cert_type_x509 }; + static const unsigned char SID_CTX[] = { 'r', 'p', 'k' }; + ++/* ++ * Wire form of a SignatureSchemeList that lists rsa_pkcs1_sha256 ++ * and ed448 -- between them they cover the issuer signature on ++ * every cert this file loads from test/certs ++ * (sha256WithRSAEncryption for the RSA/ECDSA/Ed25519 leaves and ++ * ED448 for the Ed448 leaf), so the extension is harmless when ++ * the handshake is non-RPK and the server's check_cert_usable() ++ * has to walk the list against a real cert. When RPK is ++ * negotiated check_cert_usable() returns early without inspecting ++ * the list, and when the slot is an RPK-listed key-only slot but ++ * X509 was negotiated check_cert_usable() returns 0 on the x == ++ * NULL path -- the inevitable outcome, now discovered earlier. ++ * ++ * Payload: length, rsa_pkcs1_sha256, ed448 ++ */ ++static const unsigned char sigalgs_cert_payload[] = { ++ 0x00, 0x04, ++ 0x04, 0x01, ++ 0x08, 0x08 ++}; ++ ++static int sigalgs_cert_add_cb(SSL *s, unsigned int ext_type, ++ unsigned int context, ++ const unsigned char **out, size_t *outlen, ++ X509 *x, size_t chainidx, int *al, void *add_arg) ++{ ++ *out = sigalgs_cert_payload; ++ *outlen = sizeof(sigalgs_cert_payload); ++ return 1; ++} ++ + static int rpk_verify_client_cb(int ok, X509_STORE_CTX *ctx) + { + int err = X509_STORE_CTX_get_error(ctx); +@@ -255,18 +286,43 @@ static int test_rpk(int idx) + /* NEW */ + SSL_CTX_set_verify(cctx, SSL_VERIFY_PEER, rpk_verify_client_cb); + +- if (!TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl, +- NULL, NULL))) ++ /* ++ * Send signature_algorithms_cert in every ClientHello, and in ++ * every TLS 1.3 CertificateRequest. The OpenSSL stack doesn't ++ * construct this extension by default in either direction, so ++ * register a custom add hook on both ends. This exercises the ++ * three distinct paths through check_cert_usable() on whichever ++ * side receives the extension: ++ * - RPK was negotiated for this side's cert -- early return 1, ++ * list contents ignored. ++ * - RPK was offered but X509 was negotiated and this side's ++ * slot holds only a private key -- x == NULL, return 0 ++ * (any peer-sent signature_algorithms_cert against a key-only ++ * slot would otherwise trigger a crash). ++ * - X509 negotiated with a real cert -- walk the list, find ++ * a match against the issuer's signature algorithm. ++ * The server's registration only fires on TLS 1.3 connections ++ * where the server requests a client certificate (case 2, 9, ++ * 10 etc.); on TLS 1.2 the sigalgs travel inside the ++ * CertificateRequest body, not as a separate extension. ++ */ ++ if (!TEST_true(SSL_CTX_add_custom_ext(cctx, ++ TLSEXT_TYPE_signature_algorithms_cert, ++ SSL_EXT_CLIENT_HELLO, ++ sigalgs_cert_add_cb, NULL, NULL, ++ NULL, NULL)) ++ || !TEST_true(SSL_CTX_add_custom_ext(sctx, ++ TLSEXT_TYPE_signature_algorithms_cert, ++ SSL_EXT_TLS1_3_CERTIFICATE_REQUEST, ++ sigalgs_cert_add_cb, NULL, NULL, ++ NULL, NULL)) ++ || !TEST_true(create_ssl_objects(sctx, cctx, &serverssl, &clientssl, ++ NULL, NULL)) ++ || !TEST_int_gt(SSL_dane_enable(serverssl, NULL), 0) ++ || !TEST_int_gt(SSL_dane_enable(clientssl, "example.com"), 0) ++ || !TEST_int_eq(SSL_use_PrivateKey_file(serverssl, privkey_file, SSL_FILETYPE_PEM), 1)) + goto end; + +- if (!TEST_int_gt(SSL_dane_enable(serverssl, NULL), 0)) +- goto end; +- if (!TEST_int_gt(SSL_dane_enable(clientssl, "example.com"), 0)) +- goto end; +- +- /* Set private key and certificate */ +- if (!TEST_int_eq(SSL_use_PrivateKey_file(serverssl, privkey_file, SSL_FILETYPE_PEM), 1)) +- goto end; + /* Only a private key */ + if (idx == 1) { + if (idx_server_server_rpk == 0 || idx_client_server_rpk == 0) { diff --git a/SPECS/openssl/openssl.spec b/SPECS/openssl/openssl.spec index f1fe3b300ac..99bdb2c15c7 100644 --- a/SPECS/openssl/openssl.spec +++ b/SPECS/openssl/openssl.spec @@ -88,6 +88,7 @@ Patch117: CVE-2026-63074.patch Patch118: CVE-2026-63075.patch Patch119: CVE-2026-63076.patch Patch120: CVE-2026-75803.patch +Patch121: CVE-2026-14457.patch License: Apache-2.0 URL: http://www.openssl.org/ @@ -385,7 +386,7 @@ install -m644 %{SOURCE9} \ %changelog * Wed Aug 26 2026 Azure Linux Security Servicing Account - 3.3.7-5 -- Patch for CVE-2026-75803, CVE-2026-63076, CVE-2026-63075, CVE-2026-63074, CVE-2026-63073, CVE-2026-63072, CVE-2026-54874 +- Patch for CVE-2026-75803, CVE-2026-63076, CVE-2026-63075, CVE-2026-63074, CVE-2026-63073, CVE-2026-63072, CVE-2026-54874, CVE-2026-14457 * Thu Jul 16 2026 Kanishk Bansal - 3.3.7-4 - Patch CVE-2026-45447, CVE-2026-42769, CVE-2026-42770