Skip to contentSkip to conversation

botan: patch CVE-2026-32877

PATCH New Gyorgy Sarvari 1 participant 3 messages Apr 6

lore
Share & tools
lore
#0 lore raw

PATCH 1/3 botan: patch CVE-2026-32877

Details: https://nvd.nist.gov/vuln/detail/CVE-2026-32877

Backport the patch that was identified by Debian[1].
The included test passed successfully (along with the other tests).

[1]: https://security-tracker.debian.org/tracker/CVE-2026-32877

---
 .../botan/botan/CVE-2026-32877.patch          | 158 ++++++++++++++++++
 meta-oe/recipes-crypto/botan/botan_3.10.0.bb  |   4 +-
 2 files changed, 161 insertions(+), 1 deletion(-)
 create mode 100644 meta-oe/recipes-crypto/botan/botan/CVE-2026-32877.patch
meta-oe/recipes-crypto/botan/botan/CVE-2026-32877.patch new file +158 -0
new file mode 100644
index 0000000000..871f5c9a1b
@@ -0,0 +1,158 @@
+From a0048a6b97a349a3cb4a5f955d350ab2921719cc Mon Sep 17 00:00:00 2001
+From: Jack Lloyd <[email protected]>
+Date: Sun, 15 Mar 2026 11:39:50 -0400
+Subject: [PATCH] In SM2 verify the C3 field is of the required length
+
+Previously the decryption step assumed that C3 was equal in length to the MAC
+output. If C3 is shorter than expected, up to 31 bytes of arbitrary heap data
+would be compared with the computed MAC. This heap over-read would potentially
+result in denial of service.
+
+CVE: CVE-2026-32877
+Upstream-Status: Backport [https://github.com/randombit/botan/commit/f3c31f96f58f1d1d482032d8f4286dc9ebbc6712]
+Signed-off-by: Gyorgy Sarvari <[email protected]>
+---
+ src/lib/pubkey/sm2/sm2_enc.cpp        |  7 +++-
+ src/tests/data/pubkey/sm2_invalid.vec | 60 +++++++++++++++++++++++++++
+ src/tests/test_sm2.cpp                | 31 ++++++++++++++
+ 3 files changed, 97 insertions(+), 1 deletion(-)
+ create mode 100644 src/tests/data/pubkey/sm2_invalid.vec
+
+diff --git a/src/lib/pubkey/sm2/sm2_enc.cpp b/src/lib/pubkey/sm2/sm2_enc.cpp
+index 7a1b990..1141089 100644
+--- a/src/lib/pubkey/sm2/sm2_enc.cpp
++++ b/src/lib/pubkey/sm2/sm2_enc.cpp
+@@ -133,6 +133,11 @@ class SM2_Decryption_Operation final : public PK_Ops::Decryption {
+             .end_cons()
+             .verify_end();
+ 
++         // Wrong length so certainly invalid, reject immediately
++         if(C3.size() != m_hash->output_length()) {
++            return secure_vector<uint8_t>();
++         }
++
+          std::vector<uint8_t> recode_ctext;
+          DER_Encoder(recode_ctext)
+             .start_sequence()
+@@ -170,7 +175,7 @@ class SM2_Decryption_Operation final : public PK_Ops::Decryption {
+          m_hash->update(y2_bytes);
+          const auto u = m_hash->final();
+ 
+-         if(!CT::is_equal(u.data(), C3.data(), m_hash->output_length()).as_bool()) {
++         if(!CT::is_equal<uint8_t>(u, C3).as_bool()) {
+             return secure_vector<uint8_t>();
+          }
+ 
+diff --git a/src/tests/data/pubkey/sm2_invalid.vec b/src/tests/data/pubkey/sm2_invalid.vec
+new file mode 100644
+index 0000000..2517510
+--- /dev/null
++++ b/src/tests/data/pubkey/sm2_invalid.vec
+@@ -0,0 +1,60 @@
++
++Key = 8C84F7F069CD09D59543ED980CFEB77E68C7D39B9B73D359EA67C0CDB2A86B6F
++
++
++# Empty
++Ctext =
++
++# Just the SEQUENCE marker
++Ctext = 30
++
++# Truncated
++Ctext = 3072022100A772DF5FFFDA85C05D9B82233B1E5F7DF7A87788504ABD4F74D265D49E5002C0022055C8A934A29DE58B31A063CDA81F12ABC712FB9ADC8988DA0FBD9FFF304E27CF04202E1B8A86EF14243EE2E9D74E0D0E7498DFAC2F0EFA8C5883D74F3682649386960409CA311F43DB0E5E51
++
++# C3 MAC too short
++Ctext = 3071022100A772DF5FFFDA85C05D9B82233B1E5F7DF7A87788504ABD4F74D265D49E5002C0022055C8A934A29DE58B31A063CDA81F12ABC712FB9ADC8988DA0FBD9FFF304E27CF041F2E1B8A86EF14243EE2E9D74E0D0E7498DFAC2F0EFA8C5883D74F36826493860409CA311F43DB0E5E516F
++
++# C3 MAC too long
++Ctext = 3073022100A772DF5FFFDA85C05D9B82233B1E5F7DF7A87788504ABD4F74D265D49E5002C0022055C8A934A29DE58B31A063CDA81F12ABC712FB9ADC8988DA0FBD9FFF304E27CF04212E1B8A86EF14243EE2E9D74E0D0E7498DFAC2F0EFA8C5883D74F368264938696000409CA311F43DB0E5E516F
++
++# C3 and C2 fields swapped
++Ctext = 3072022100A772DF5FFFDA85C05D9B82233B1E5F7DF7A87788504ABD4F74D265D49E5002C0022055C8A934A29DE58B31A063CDA81F12ABC712FB9ADC8988DA0FBD9FFF304E27CF0409CA311F43DB0E5E516F04202E1B8A86EF14243EE2E9D74E0D0E7498DFAC2F0EFA8C5883D74F368264938696
++
++# C3 MAC last bit flipped
++Ctext = 3072022100A772DF5FFFDA85C05D9B82233B1E5F7DF7A87788504ABD4F74D265D49E5002C0022055C8A934A29DE58B31A063CDA81F12ABC712FB9ADC8988DA0FBD9FFF304E27CF04202E1B8A86EF14243EE2E9D74E0D0E7498DFAC2F0EFA8C5883D74F3682649386970409CA311F43DB0E5E516F
++
++# C3 MAC first byte inverted
++Ctext = 3072022100A772DF5FFFDA85C05D9B82233B1E5F7DF7A87788504ABD4F74D265D49E5002C0022055C8A934A29DE58B31A063CDA81F12ABC712FB9ADC8988DA0FBD9FFF304E27CF0420D11B8A86EF14243EE2E9D74E0D0E7498DFAC2F0EFA8C5883D74F3682649386960409CA311F43DB0E5E516F
++
++# C1 y off by one
++Ctext = 3072022100A772DF5FFFDA85C05D9B82233B1E5F7DF7A87788504ABD4F74D265D49E5002C0022055C8A934A29DE58B31A063CDA81F12ABC712FB9ADC8988DA0FBD9FFF304E27D004202E1B8A86EF14243EE2E9D74E0D0E7498DFAC2F0EFA8C5883D74F3682649386960409CA311F43DB0E5E516F
++
++# C1 x/y serialization boundary shift
++Ctext = 3073022100A772DF5FFFDA85C05D9B82233B1E5F7DF7A87788504ABD4F74D265D49E500200022100C055C8A934A29DE58B31A063CDA81F12ABC712FB9ADC8988DA0FBD9FFF304E2704202E1B8A86EF14243EE2E9D74E0D0E7498DFAC2F0EFA8C5883D74F3682649386960409CA311F43DB0E5E516F
++
++# C1 is generator point
++Ctext = 3072022032C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7022100BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A004202E1B8A86EF14243EE2E9D74E0D0E7498DFAC2F0EFA8C5883D74F3682649386960409CA311F43DB0E5E516F
++
++# C1 is origin (0,0)
++Ctext = 303302010002010004202E1B8A86EF14243EE2E9D74E0D0E7498DFAC2F0EFA8C5883D74F3682649386960409CA311F43DB0E5E516F
++
++# C1 x equals field prime
++Ctext = 3072022100FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF022055C8A934A29DE58B31A063CDA81F12ABC712FB9ADC8988DA0FBD9FFF304E27CF04202E1B8A86EF14243EE2E9D74E0D0E7498DFAC2F0EFA8C5883D74F3682649386960409CA311F43DB0E5E516F
++
++# C2 last bit flipped
++Ctext = 3072022100A772DF5FFFDA85C05D9B82233B1E5F7DF7A87788504ABD4F74D265D49E5002C0022055C8A934A29DE58B31A063CDA81F12ABC712FB9ADC8988DA0FBD9FFF304E27CF04202E1B8A86EF14243EE2E9D74E0D0E7498DFAC2F0EFA8C5883D74F3682649386960409CA311F43DB0E5E516E
++
++# C2 replaced with empty
++Ctext = 3069022100A772DF5FFFDA85C05D9B82233B1E5F7DF7A87788504ABD4F74D265D49E5002C0022055C8A934A29DE58B31A063CDA81F12ABC712FB9ADC8988DA0FBD9FFF304E27CF04202E1B8A86EF14243EE2E9D74E0D0E7498DFAC2F0EFA8C5883D74F3682649386960400
++
++# Trailing byte after SEQUENCE
++Ctext = 3072022100A772DF5FFFDA85C05D9B82233B1E5F7DF7A87788504ABD4F74D265D49E5002C0022055C8A934A29DE58B31A063CDA81F12ABC712FB9ADC8988DA0FBD9FFF304E27CF04202E1B8A86EF14243EE2E9D74E0D0E7498DFAC2F0EFA8C5883D74F3682649386960409CA311F43DB0E5E516F00
++
++# SEQUENCE with non-minimal long-form length
++Ctext = 308172022100A772DF5FFFDA85C05D9B82233B1E5F7DF7A87788504ABD4F74D265D49E5002C0022055C8A934A29DE58B31A063CDA81F12ABC712FB9ADC8988DA0FBD9FFF304E27CF04202E1B8A86EF14243EE2E9D74E0D0E7498DFAC2F0EFA8C5883D74F3682649386960409CA311F43DB0E5E516F
++
++# INTEGER x1 with non-minimal leading zero
++Ctext = 307302220000A772DF5FFFDA85C05D9B82233B1E5F7DF7A87788504ABD4F74D265D49E5002C0022055C8A934A29DE58B31A063CDA81F12ABC712FB9ADC8988DA0FBD9FFF304E27CF04202E1B8A86EF14243EE2E9D74E0D0E7498DFAC2F0EFA8C5883D74F3682649386960409CA311F43DB0E5E516F
++
++# OCTET STRING C3 with non-minimal long-form length
++Ctext = 3073022100A772DF5FFFDA85C05D9B82233B1E5F7DF7A87788504ABD4F74D265D49E5002C0022055C8A934A29DE58B31A063CDA81F12ABC712FB9ADC8988DA0FBD9FFF304E27CF0481202E1B8A86EF14243EE2E9D74E0D0E7498DFAC2F0EFA8C5883D74F3682649386960409CA311F43DB0E5E516F
+diff --git a/src/tests/test_sm2.cpp b/src/tests/test_sm2.cpp
+index 2ffb14a..c5d2360 100644
+--- a/src/tests/test_sm2.cpp
++++ b/src/tests/test_sm2.cpp
+@@ -9,6 +9,7 @@
+ 
+ #if defined(BOTAN_HAS_SM2)
+    #include "test_pubkey.h"
++   #include <botan/pubkey.h>
+    #include <botan/sm2.h>
+ #endif
+ 
+@@ -108,4 +109,34 @@ BOTAN_REGISTER_TEST("pubkey", "sm2_keygen", SM2_Keygen_Tests);
+ 
+ #endif
+ 
++namespace {
++
++class SM2_Invalid_Ciphertexts : public Text_Based_Test {
++   public:
++      SM2_Invalid_Ciphertexts() : Text_Based_Test("pubkey/sm2_invalid.vec", "Key,Ctext") {}
++
++      bool clear_between_callbacks() const override { return false; }
++
++      Test::Result run_one_test(const std::string& /*header*/, const VarMap& vars) override {
++         Test::Result result("SM2 invalid ciphertext");
++
++         const auto key = vars.get_req_bin("Key");
++         const auto ctext = vars.get_req_bin("Ctext");
++
++         const auto group = Botan::EC_Group::from_name("sm2p256v1");
++         const auto pkey = Botan::SM2_PrivateKey(group, Botan::EC_Scalar::deserialize(group, key).value());
++
++         Botan::PK_Decryptor_EME dec(pkey, rng(), "SM3");
++
++         result.test_throws<Botan::Exception>("Decryption should fail for invalid ciphertext",
++                                              [&] { dec.decrypt(ctext); });
++
++         return result;
++      }
++};
++
++BOTAN_REGISTER_TEST("pubkey", "sm2_invalid_ctext", SM2_Invalid_Ciphertexts);
++
++}  // namespace
++
+ }  // namespace Botan_Tests
meta-oe/recipes-crypto/botan/botan_3.10.0.bb +3 -1
index e079dd73de..392c1aac94 100644
@@ -4,7 +4,9 @@ LICENSE = "BSD-2-Clause"
 LIC_FILES_CHKSUM = "file://license.txt;md5=3f911cecfc74a2d9f1ead9a07bd92a6e"
 SECTION = "libs"
 
-SRC_URI = "https://botan.randombit.net/releases/Botan-${PV}.tar.xz"
+SRC_URI = "https://botan.randombit.net/releases/Botan-${PV}.tar.xz \
+           file://CVE-2026-32877.patch \
+           "
 SRC_URI[sha256sum] = "fde194236f6d5434f136ea0a0627f6cc9d26af8b96e9f1e1c7d8c82cd90f4f24"
 
 S = "${UNPACKDIR}/Botan-${PV}"
#1 lore raw

PATCH 2/3 botan: patch CVE-2026-32883

Details: https://nvd.nist.gov/vuln/detail/CVE-2026-32883

Backport the patch that was identified by Debian[1].
The included test passed successfully (along with the other tests).

[1]: https://security-tracker.debian.org/tracker/CVE-2026-32883

---
 .../botan/botan/CVE-2026-32883.patch          | 171 ++++++++++++++++++
 meta-oe/recipes-crypto/botan/botan_3.10.0.bb  |   1 +
 2 files changed, 172 insertions(+)
 create mode 100644 meta-oe/recipes-crypto/botan/botan/CVE-2026-32883.patch
meta-oe/recipes-crypto/botan/botan/CVE-2026-32883.patch new file +171 -0
new file mode 100644
index 0000000000..9cace2118e
@@ -0,0 +1,171 @@
+From 38a49aafc8115ddb6275ca6bbb8748b3d7b3064d Mon Sep 17 00:00:00 2001
+From: Jack Lloyd <[email protected]>
+Date: Sun, 15 Mar 2026 10:28:52 -0400
+Subject: [PATCH] Fix OCSP response verification
+
+During a refactoring of OCSP (#3067) the check that the OCSP response signature
+is valid was omitted. This allows OCSP responses to be forged.
+
+CVE: CVE-2026-32883
+Upstream-Status: Backport [https://github.com/randombit/botan/commit/acbffadcede18b36eea42beae57e6cae4b4da4a0]
+Signed-off-by: Gyorgy Sarvari <[email protected]>
+---
+ src/lib/x509/x509path.cpp | 67 +++++++++++++++++++++++----------------
+ src/tests/test_ocsp.cpp   | 47 +++++++++++++++++++++++++++
+ 2 files changed, 87 insertions(+), 27 deletions(-)
+
+diff --git a/src/lib/x509/x509path.cpp b/src/lib/x509/x509path.cpp
+index 4059d32..8212bb2 100644
+--- a/src/lib/x509/x509path.cpp
++++ b/src/lib/x509/x509path.cpp
+@@ -298,6 +298,41 @@ Certificate_Status_Code verify_ocsp_signing_cert(const X509_Certificate& signing
+    return validation_result.result();
+ }
+ 
++std::set<Certificate_Status_Code> evaluate_ocsp_response(const OCSP::Response& ocsp_response,
++                                                         const X509_Certificate& subject,
++                                                         const X509_Certificate& ca,
++                                                         const std::vector<X509_Certificate>& cert_path,
++                                                         const std::vector<Certificate_Store*>& certstores,
++                                                         std::chrono::system_clock::time_point ref_time,
++                                                         const Path_Validation_Restrictions& restrictions) {
++   // Handle softfail conditions (eg. OCSP unavailable)
++   if(auto dummy_status = ocsp_response.dummy_status()) {
++      return {dummy_status.value()};
++   }
++
++   // Find the certificate that signed this OCSP response
++   auto signing_cert = ocsp_response.find_signing_certificate(ca, restrictions.trusted_ocsp_responders());
++   if(!signing_cert) {
++      return {Certificate_Status_Code::OCSP_ISSUER_NOT_FOUND};
++   }
++
++   // Verify the signing certificate is trusted
++   auto cert_status = verify_ocsp_signing_cert(
++      signing_cert.value(), ca, concat(ocsp_response.certificates(), cert_path), certstores, ref_time, restrictions);
++   if(cert_status > Certificate_Status_Code::FIRST_ERROR_STATUS) {
++      return {cert_status, Certificate_Status_Code::OCSP_ISSUER_NOT_TRUSTED};
++   }
++
++   // Verify the cryptographic signature on the OCSP response
++   auto sig_status = ocsp_response.verify_signature(signing_cert.value());
++   if(sig_status != Certificate_Status_Code::OCSP_SIGNATURE_OK) {
++      return {sig_status};
++   }
++
++   // All checks passed, return the certificate's revocation status
++   return {ocsp_response.status_for(ca, subject, ref_time, restrictions.max_ocsp_age())};
++}
++
+ }  // namespace
+ 
+ CertificatePathStatusCodes PKIX::check_ocsp(const std::vector<X509_Certificate>& cert_path,
+@@ -312,38 +347,16 @@ CertificatePathStatusCodes PKIX::check_ocsp(const std::vector<X509_Certificate>&
+    CertificatePathStatusCodes cert_status(cert_path.size() - 1);
+ 
+    for(size_t i = 0; i != cert_path.size() - 1; ++i) {
+-      std::set<Certificate_Status_Code>& status = cert_status.at(i);
+-
+       const X509_Certificate& subject = cert_path.at(i);
+       const X509_Certificate& ca = cert_path.at(i + 1);
+ 
+-      if(i < ocsp_responses.size() && (ocsp_responses.at(i) != std::nullopt) &&
+-         (ocsp_responses.at(i)->status() == OCSP::Response_Status_Code::Successful)) {
++      if(i < ocsp_responses.size() && ocsp_responses.at(i).has_value() &&
++         ocsp_responses.at(i)->status() == OCSP::Response_Status_Code::Successful) {
+          try {
+-            const auto& ocsp_response = ocsp_responses.at(i);
+-
+-            if(auto dummy_status = ocsp_response->dummy_status()) {
+-               // handle softfail conditions
+-               status.insert(dummy_status.value());
+-            } else if(auto signing_cert =
+-                         ocsp_response->find_signing_certificate(ca, restrictions.trusted_ocsp_responders());
+-                      !signing_cert) {
+-               status.insert(Certificate_Status_Code::OCSP_ISSUER_NOT_FOUND);
+-            } else if(auto ocsp_signing_cert_status =
+-                         verify_ocsp_signing_cert(signing_cert.value(),
+-                                                  ca,
+-                                                  concat(ocsp_response->certificates(), cert_path),
+-                                                  certstores,
+-                                                  ref_time,
+-                                                  restrictions);
+-                      ocsp_signing_cert_status > Certificate_Status_Code::FIRST_ERROR_STATUS) {
+-               status.insert(ocsp_signing_cert_status);
+-               status.insert(Certificate_Status_Code::OCSP_ISSUER_NOT_TRUSTED);
+-            } else {
+-               status.insert(ocsp_response->status_for(ca, subject, ref_time, restrictions.max_ocsp_age()));
+-            }
++            cert_status.at(i) = evaluate_ocsp_response(
++               ocsp_responses.at(i).value(), subject, ca, cert_path, certstores, ref_time, restrictions);
+          } catch(Exception&) {
+-            status.insert(Certificate_Status_Code::OCSP_RESPONSE_INVALID);
++            cert_status.at(i).insert(Certificate_Status_Code::OCSP_RESPONSE_INVALID);
+          }
+       }
+    }
+diff --git a/src/tests/test_ocsp.cpp b/src/tests/test_ocsp.cpp
+index 06383cd..54b2c03 100644
+--- a/src/tests/test_ocsp.cpp
++++ b/src/tests/test_ocsp.cpp
+@@ -408,6 +408,52 @@ class OCSP_Tests final : public Test {
+          return result;
+       }
+ 
++      static Test::Result test_forged_ocsp_signature_is_rejected() {
++         Test::Result result("OCSP response with forged signature is rejected by path validation");
++
++         auto ee = load_test_X509_cert("x509/ocsp/randombit.pem");
++         auto ca = load_test_X509_cert("x509/ocsp/letsencrypt.pem");
++         auto trust_root = load_test_X509_cert("x509/ocsp/geotrust.pem");
++
++         const std::vector<Botan::X509_Certificate> cert_path = {ee, ca, trust_root};
++
++         Botan::Certificate_Store_In_Memory certstore;
++         certstore.add_certificate(trust_root);
++
++         const auto valid_time = Botan::calendar_point(2016, 11, 18, 12, 30, 0).to_std_timepoint();
++
++         // Verify the unmodified response is accepted
++         {
++            auto ocsp = load_test_OCSP_resp("x509/ocsp/randombit_ocsp.der");
++            const auto ocsp_status = Botan::PKIX::check_ocsp(
++               cert_path, {ocsp}, {&certstore}, valid_time, Botan::Path_Validation_Restrictions());
++
++            if(result.test_eq("Legitimate: expected result count", ocsp_status.size(), 1) &&
++               result.test_eq("Legitimate: expected status count", ocsp_status[0].size(), 1)) {
++               result.test_eq("Legitimate response is accepted",
++                                   ocsp_status[0].contains(Botan::Certificate_Status_Code::OCSP_RESPONSE_GOOD), true);
++            }
++         }
++
++         // Tamper with the signature and verify check_ocsp rejects it
++         {
++            auto ocsp_bytes = Test::read_binary_data_file("x509/ocsp/randombit_ocsp.der");
++            ocsp_bytes.back() ^= 0x01;
++            Botan::OCSP::Response forged_ocsp(ocsp_bytes.data(), ocsp_bytes.size());
++
++            const auto ocsp_status = Botan::PKIX::check_ocsp(
++               cert_path, {forged_ocsp}, {&certstore}, valid_time, Botan::Path_Validation_Restrictions());
++
++            if(result.test_eq("Forged: expected result count", ocsp_status.size(), 1) &&
++               result.test_eq("Forged: expected status count", ocsp_status[0].size(), 1)) {
++               result.test_eq("Forged signature is rejected",
++                                   ocsp_status[0].contains(Botan::Certificate_Status_Code::OCSP_SIGNATURE_ERROR), true);
++            }
++         }
++
++         return result;
++      }
++
+       static Test::Result test_responder_cert_with_nocheck_extension() {
+          Test::Result result("BDr's OCSP response contains certificate featuring NoCheck extension");
+ 
+@@ -436,6 +482,7 @@ class OCSP_Tests final : public Test {
+          results.push_back(test_response_verification_without_next_update_without_max_age());
+          results.push_back(test_response_verification_softfail());
+          results.push_back(test_response_verification_with_additionally_trusted_responder());
++         results.push_back(test_forged_ocsp_signature_is_rejected());
+          results.push_back(test_responder_cert_with_nocheck_extension());
+ 
+    #if defined(BOTAN_HAS_ONLINE_REVOCATION_CHECKS)
meta-oe/recipes-crypto/botan/botan_3.10.0.bb +1 -0
index 392c1aac94..b613dd2a04 100644
@@ -6,6 +6,7 @@ SECTION = "libs"
 
 SRC_URI = "https://botan.randombit.net/releases/Botan-${PV}.tar.xz \
            file://CVE-2026-32877.patch \
+           file://CVE-2026-32883.patch \
            "
 SRC_URI[sha256sum] = "fde194236f6d5434f136ea0a0627f6cc9d26af8b96e9f1e1c7d8c82cd90f4f24"
 
#2 lore raw

PATCH 3/3 botan: patch CVE-2026-32884

In reply to Gyorgy Sarvari

Details: https://nvd.nist.gov/vuln/detail/CVE-2026-32884

The backported patch was selected based on the security.rst[1] file of the project, that mentions the date of the fix. When looked through the commits from that date, picked the one that's description matches the CVE description.

The included test passed successfully (along with the other tests).

[1]: https://github.com/randombit/botan/blob/master/doc/security.rst

---
 .../botan/botan/CVE-2026-32884.patch          | 171 ++++++++++++++++++
 meta-oe/recipes-crypto/botan/botan_3.10.0.bb  |   1 +
 2 files changed, 172 insertions(+)
 create mode 100644 meta-oe/recipes-crypto/botan/botan/CVE-2026-32884.patch
meta-oe/recipes-crypto/botan/botan/CVE-2026-32884.patch new file +171 -0
new file mode 100644
index 0000000000..f207ee2caa
@@ -0,0 +1,171 @@
+From cbc8b341ea4b38c388e89682b86da107a9fdc38c Mon Sep 17 00:00:00 2001
+From: Jack Lloyd <[email protected]>
+Date: Sun, 15 Mar 2026 11:17:22 -0400
+Subject: [PATCH] Fix name constraint DNS check when falling back to CN
+
+When verifying name constraints which restrict the set of allowed DNS names, the
+logic would first check the Subject Alternative Name if available, but if the
+SAN is absent then it would check the CN field of the issued name since that is
+a common fallback for DNS names when the SAN is missing.
+
+However this check failed to properly canonicalize the potential DNS name in the
+CN, allowing a mis-issued cert with a mixed-case CN field and absent SAN to
+bypass any imposed excludedSubtrees rules.
+
+CVE: CVE-2026-32884
+Upstream-Status: Backport [https://github.com/randombit/botan/commit/db8baebd92bded036da6faf8bf3c324b67de9cf4]
+Signed-off-by: Gyorgy Sarvari <[email protected]>
+---
+ src/lib/x509/name_constraint.cpp              | 16 +++++++---
+ .../Invalid_DNS_Excluded_Mixed_Case_CN.crt    | 19 ++++++++++++
+ .../Root_DNS_Excluded_Mixed_Case_CN.crt       | 19 ++++++++++++
+ src/tests/test_name_constraint.cpp            | 29 +++++++++++++++++++
+ 4 files changed, 79 insertions(+), 4 deletions(-)
+ create mode 100644 src/tests/data/x509/name_constraint/Invalid_DNS_Excluded_Mixed_Case_CN.crt
+ create mode 100644 src/tests/data/x509/name_constraint/Root_DNS_Excluded_Mixed_Case_CN.crt
+
+diff --git a/src/lib/x509/name_constraint.cpp b/src/lib/x509/name_constraint.cpp
+index e767624..8708b95 100644
+--- a/src/lib/x509/name_constraint.cpp
++++ b/src/lib/x509/name_constraint.cpp
+@@ -19,6 +19,14 @@ namespace Botan {
+ 
+ class DER_Encoder;
+ 
++namespace {
++
++std::string canonicalize_dns_name(std::string_view name) {
++   return tolower_string(name);
++}
++
++}  // namespace
++
+ std::string GeneralName::type() const {
+    switch(m_type) {
+       case NameType::Unknown:
+@@ -75,7 +83,7 @@ void GeneralName::decode_from(BER_Decoder& ber) {
+       m_type = NameType::DNS;
+       // Store it in case insensitive form so we don't have to do it
+       // again while matching
+-      m_name.emplace<DNS_IDX>(tolower_string(ASN1::to_string(obj)));
++      m_name.emplace<DNS_IDX>(canonicalize_dns_name(ASN1::to_string(obj)));
+    } else if(obj.is_a(6, ASN1_Class::ContextSpecific)) {
+       m_type = NameType::URI;
+       m_name.emplace<URI_IDX>(ASN1::to_string(obj));
+@@ -174,7 +182,7 @@ GeneralName::MatchResult GeneralName::matches(const X509_Certificate& cert) cons
+          // Check CN instead...
+          for(const std::string& cn : dn.get_attribute("CN")) {
+             if(!string_to_ipv4(cn).has_value()) {
+-               score.add(matches_dns(cn, constraint));
++               score.add(matches_dns(canonicalize_dns_name(cn), constraint));
+             }
+          }
+       }
+@@ -421,7 +429,7 @@ bool NameConstraints::is_permitted(const X509_Certificate& cert, bool reject_unk
+                   return false;
+                }
+             } else {
+-               if(!is_permitted_dns_name(cn)) {
++               if(!is_permitted_dns_name(canonicalize_dns_name(cn))) {
+                   return false;
+                }
+             }
+@@ -540,7 +548,7 @@ bool NameConstraints::is_excluded(const X509_Certificate& cert, bool reject_unkn
+                   return true;
+                }
+             } else {
+-               if(is_excluded_dns_name(cn)) {
++               if(is_excluded_dns_name(canonicalize_dns_name(cn))) {
+                   return true;
+                }
+             }
+diff --git a/src/tests/data/x509/name_constraint/Invalid_DNS_Excluded_Mixed_Case_CN.crt b/src/tests/data/x509/name_constraint/Invalid_DNS_Excluded_Mixed_Case_CN.crt
+new file mode 100644
+index 0000000..fe2c773
+--- /dev/null
++++ b/src/tests/data/x509/name_constraint/Invalid_DNS_Excluded_Mixed_Case_CN.crt
+@@ -0,0 +1,19 @@
++-----BEGIN CERTIFICATE-----
++MIIDCTCCAfGgAwIBAgIUAbjRT6B+WHVf1Wo9JdFHlHegF1cwDQYJKoZIhvcNAQEL
++BQAwFzEVMBMGA1UEAwwMVGVzdCBSb290IENBMB4XDTI2MDMxNTE0NTM1MloXDTI3
++MDMxNTE0NTM1MlowFzEVMBMGA1UEAwwMU3ViLkVWSUwuQ09NMIIBIjANBgkqhkiG
++9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsn1rve+kuZJd2udT4QEnjdws+YRT+lJI+rG/
++4OpljAcxQywCc6oHDY4ouaqOKdhT9+luvqRVSEnH3JfczT/D+wZD+gBOlgUqsmXp
++QasD8HSyHWdjyaLrkZuBGICoUZTh9a7ZOPuIQ2sblxOvBm3klndpSpXJC6sJsWAk
++tyU+5WdNz+ncTC82sFSY0YQLC2QvxckEP6Jxi4I+h9vANtWXCk6CRz/kT4dY3cD4
++VBFtAy+vUVYUZnLi48fEYlMt4rP64OerY7hjw8gE+66rmUQPml4+DAek+xJtL4Sl
++Q0SGytWE9tJb1zzICv4TNvj/+IKmbK4BCu7fVjOd2C64zNFTywIDAQABo00wSzAJ
++BgNVHRMEAjAAMB0GA1UdDgQWBBS6hC1DrVlXAq/GWDYl/UQbP4TmLTAfBgNVHSME
++GDAWgBQPZ2Gp3izLTRAUzQKCKRLbM5OA2DANBgkqhkiG9w0BAQsFAAOCAQEAcWBy
++f9+tJDDj7T7z4QziZnxIfKP7x7uP9wAlYGRpKcbbW6SHAg6DA1V5GBWHendkg1hb
++Nywy7pUFgJ0xlJ7KYr76Ylfa1BTUPT+gExJWvSmsg8WSQ4q3bOMVB1qRxWDv/8KY
++ZOT03KEzLyGL6ia9r/UFw1jibxS26Ff6qCE9EhDLA/4z0D/+9QzdLATuzSn/SLSR
++wtarLaWhCfOSpfRrekYhaSndG45BCKpUd99iWt1HA4LyjZe8/8cxsRkD8klaCalG
++8pRp+PolijzmYsrEXuG22Bq2idgxHTRvw8l4rBQrSdMWuWqqTdIpFIUrXNft0a5f
++d8RmhI6PZlPL43OCxw==
++-----END CERTIFICATE-----
+diff --git a/src/tests/data/x509/name_constraint/Root_DNS_Excluded_Mixed_Case_CN.crt b/src/tests/data/x509/name_constraint/Root_DNS_Excluded_Mixed_Case_CN.crt
+new file mode 100644
+index 0000000..503206f
+--- /dev/null
++++ b/src/tests/data/x509/name_constraint/Root_DNS_Excluded_Mixed_Case_CN.crt
+@@ -0,0 +1,19 @@
++-----BEGIN CERTIFICATE-----
++MIIDGjCCAgKgAwIBAgIUJj5ZhECZYOzt5qWnoN8DMcZzlzgwDQYJKoZIhvcNAQEL
++BQAwFzEVMBMGA1UEAwwMVGVzdCBSb290IENBMB4XDTI2MDMxNTE0NTM1MloXDTM2
++MDMxMjE0NTM1MlowFzEVMBMGA1UEAwwMVGVzdCBSb290IENBMIIBIjANBgkqhkiG
++9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtEqBgRHixpRodBHeqXrcttdKD3tpGG+S67tM
++WT1h+572k6EFIZ9RVfYokH32sNFNz8LNI5FwKKFTf/WaVhMdsqxaMrf/+06UzKdw
++7dKz+Q5uLGrygv6opSVqhojkjLZH78zmEER0Gba4Ac4FGq5pjafA2jtoIMDyQ2SV
++IpOy932WCajQL6IM20yHPQAsr0c0hoFP4RdbJPuiEVPfZv95VjEwwV0zMBFmiICk
++gItEDfiexBHEIvXAGNBModMHaBhUDzHZp0X7gNW/MD2ieiQGoLTyG/t7sKv0J3zV
++LnUpXVIrmHSIkGVfuc5EFOlq6OXZ/J29VjPEnVVeZARDhgyGRQIDAQABo14wXDAP
++BgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQPZ2Gp3izLTRAUzQKCKRLbM5OA2DAO
++BgNVHQ8BAf8EBAMCAQYwGgYDVR0eAQH/BBAwDqEMMAqCCGV2aWwuY29tMA0GCSqG
++SIb3DQEBCwUAA4IBAQA5RLYaZWVxFIKpZRM5ZBk4fDDlAvRl7NVhMeQO3DMyyIzw
++Bp7IIEgH0I6PlL4/02SzSaqUuVVXYyO1LhbgBlFnE1h818zz+jN06i0lUemuXGAo
++wnHBwLW+V/r0JBm4BbnbneCYHUFS07sfR9IjQqV9Futp2WILwieZ7Ib96xGuX96L
++f6pxYEd82rYSXa/K14HvMKXkzC3qe72V+/E1GOPZqzlbZFriYfRUHUOY6P7LjcWl
++3Z+aUQcG8vEHbJjTd+ZZzP2PICjLKgaX1acpBOUR6pelHgcUmuR3z86V/DD8TWsH
++BHDLLBxTje/8fL0PR4qo4r4F+2Cj+hXnY/TFVQ+W
++-----END CERTIFICATE-----
+diff --git a/src/tests/test_name_constraint.cpp b/src/tests/test_name_constraint.cpp
+index 61aff53..5daa343 100644
+--- a/src/tests/test_name_constraint.cpp
++++ b/src/tests/test_name_constraint.cpp
+@@ -69,6 +69,35 @@ class Name_Constraint_Tests final : public Test {
+ 
+ BOTAN_REGISTER_TEST("x509", "x509_path_name_constraint", Name_Constraint_Tests);
+ 
++// Verify that DNS constraints are case-insensitive also when falling back to the CN
++class Name_Constraint_Excluded_CN_Case_Test final : public Test {
++   public:
++      std::vector<Test::Result> run() override {
++         Test::Result result("X509v3 Name Constraints: excluded DNS with mixed-case CN and no SAN");
++
++         const Botan::X509_Certificate root(
++            Test::data_file("x509/name_constraint/Root_DNS_Excluded_Mixed_Case_CN.crt"));
++         const Botan::X509_Certificate leaf(
++            Test::data_file("x509/name_constraint/Invalid_DNS_Excluded_Mixed_Case_CN.crt"));
++
++         Botan::Certificate_Store_In_Memory trusted;
++         trusted.add_certificate(root);
++
++         const Botan::Path_Validation_Restrictions restrictions(false, 80);
++         const auto validation_time = Botan::calendar_point(2026, 6, 1, 0, 0, 0).to_std_timepoint();
++
++         const auto path_result = Botan::x509_path_validate(
++            leaf, restrictions, trusted, "" /* hostname */, Botan::Usage_Type::UNSPECIFIED, validation_time);
++
++         result.test_eq(
++            "validation result", path_result.result_string(), "Certificate does not pass name constraint");
++
++         return {result};
++      }
++};
++
++BOTAN_REGISTER_TEST("x509", "x509_name_constraint_excluded_cn_case", Name_Constraint_Excluded_CN_Case_Test);
++
+ #endif
+ 
+ }  // namespace
meta-oe/recipes-crypto/botan/botan_3.10.0.bb +1 -0
index b613dd2a04..0986a76557 100644
@@ -7,6 +7,7 @@ SECTION = "libs"
 SRC_URI = "https://botan.randombit.net/releases/Botan-${PV}.tar.xz \
            file://CVE-2026-32877.patch \
            file://CVE-2026-32883.patch \
+           file://CVE-2026-32884.patch \
            "
 SRC_URI[sha256sum] = "fde194236f6d5434f136ea0a0627f6cc9d26af8b96e9f1e1c7d8c82cd90f4f24"