diff --git a/0048-fix-CVE-2023-0464.patch b/0048-fix-CVE-2023-0464.patch new file mode 100644 index 0000000000000000000000000000000000000000..e887693b43490dd27834760af034b20e1f280074 --- /dev/null +++ b/0048-fix-CVE-2023-0464.patch @@ -0,0 +1,259 @@ +From dbf899a67d84f8e35a29aba3e6905713ca931283 Mon Sep 17 00:00:00 2001 +From: Pauli +Date: Sat, 6 May 2023 17:37:51 +0800 +Subject: [PATCH 1/1] fix CVE 2023 0464 + +--- + CHANGES.md | 9 +++++++++ + NEWS.md | 2 ++ + crypto/x509/pcy_local.h | 8 +++++++- + crypto/x509/pcy_node.c | 13 ++++++++++--- + crypto/x509/pcy_tree.c | 36 ++++++++++++++++++++++++++---------- + 5 files changed, 54 insertions(+), 14 deletions(-) + +diff --git a/CHANGES.md b/CHANGES.md +index 84933a8..5cf1f60 100644 +--- a/CHANGES.md ++++ b/CHANGES.md +@@ -30,6 +30,14 @@ breaking changes, and mappings for the large list of deprecated functions. + + ### Changes between 3.0.6 and 3.0.7 [1 Nov 2022] + ++ * Limited the number of nodes created in a policy tree to mitigate ++ against CVE-2023-0464. The default limit is set to 1000 nodes, which ++ should be sufficient for most installations. If required, the limit ++ can be adjusted by setting the OPENSSL_POLICY_TREE_NODES_MAX build ++ time define to a desired maximum number of nodes or zero to allow ++ unlimited growth. ++ ([CVE-2023-0464]) ++ + * Fixed two buffer overflows in punycode decoding functions. + + A buffer overrun can be triggered in X.509 certificate verification, +@@ -19415,6 +19423,7 @@ ndif + + + ++[CVE-2023-0464]: https://www.openssl.org/news/vulnerabilities.html#CVE-2023-0464 + [CVE-2022-2274]: https://www.openssl.org/news/vulnerabilities.html#CVE-2022-2274 + [CVE-2022-2097]: https://www.openssl.org/news/vulnerabilities.html#CVE-2022-2274 + [CVE-2020-1971]: https://www.openssl.org/news/vulnerabilities.html#CVE-2020-1971 +diff --git a/NEWS.md b/NEWS.md +index e55777f..450c590 100644 +--- a/NEWS.md ++++ b/NEWS.md +@@ -24,6 +24,7 @@ OpenSSL 3.0 + * Fixed regressions introduced in 3.0.6 version. + * Fixed two buffer overflows in punycode decoding functions. + ([CVE-2022-3786]) and ([CVE-2022-3602]) ++ * Limited the number of nodes created in a policy tree ([CVE-2023-0464]) + + ### Major changes between OpenSSL 3.0.5 and OpenSSL 3.0.6 [11 Oct 2022] + +@@ -1419,6 +1420,7 @@ OpenSSL 0.9.x + + + ++[CVE-2023-0464]: https://www.openssl.org/news/vulnerabilities.html#CVE-2023-0464 + [CVE-2022-2274]: https://www.openssl.org/news/vulnerabilities.html#CVE-2022-2274 + [CVE-2022-2097]: https://www.openssl.org/news/vulnerabilities.html#CVE-2022-2274 + [CVE-2020-1971]: https://www.openssl.org/news/vulnerabilities.html#CVE-2020-1971 +diff --git a/crypto/x509/pcy_local.h b/crypto/x509/pcy_local.h +index 18b53cc..e7b569e 100644 +--- a/crypto/x509/pcy_local.h ++++ b/crypto/x509/pcy_local.h +@@ -111,6 +111,11 @@ struct X509_POLICY_LEVEL_st { + }; + + struct X509_POLICY_TREE_st { ++ /* The number of nodes in the tree */ ++ size_t node_count; ++ /* The maximum number of nodes in the tree */ ++ size_t node_maximum; ++ + /* This is the tree 'level' data */ + X509_POLICY_LEVEL *levels; + int nlevel; +@@ -157,7 +162,8 @@ X509_POLICY_NODE *ossl_policy_tree_find_sk(STACK_OF(X509_POLICY_NODE) *sk, + X509_POLICY_NODE *ossl_policy_level_add_node(X509_POLICY_LEVEL *level, + X509_POLICY_DATA *data, + X509_POLICY_NODE *parent, +- X509_POLICY_TREE *tree); ++ X509_POLICY_TREE *tree, ++ int extra_data); + void ossl_policy_node_free(X509_POLICY_NODE *node); + int ossl_policy_node_match(const X509_POLICY_LEVEL *lvl, + const X509_POLICY_NODE *node, const ASN1_OBJECT *oid); +diff --git a/crypto/x509/pcy_node.c b/crypto/x509/pcy_node.c +index 9d9a7ea..47865c1 100644 +--- a/crypto/x509/pcy_node.c ++++ b/crypto/x509/pcy_node.c +@@ -59,10 +59,16 @@ X509_POLICY_NODE *ossl_policy_level_find_node(const X509_POLICY_LEVEL *level, + X509_POLICY_NODE *ossl_policy_level_add_node(X509_POLICY_LEVEL *level, + X509_POLICY_DATA *data, + X509_POLICY_NODE *parent, +- X509_POLICY_TREE *tree) ++ X509_POLICY_TREE *tree, ++ int extra_data) ++ + { + X509_POLICY_NODE *node; + ++ /* Verify that the tree isn't too large. This mitigates CVE-2023-0464 */ ++ if (tree->node_maximum > 0 && tree->node_count >= tree->node_maximum) ++ return NULL; ++ + node = OPENSSL_zalloc(sizeof(*node)); + if (node == NULL) { + ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE); +@@ -70,7 +76,7 @@ X509_POLICY_NODE *ossl_policy_level_add_node(X509_POLICY_LEVEL *level, + } + node->data = data; + node->parent = parent; +- if (level) { ++ if (level != NULL) { + if (OBJ_obj2nid(data->valid_policy) == NID_any_policy) { + if (level->anyPolicy) + goto node_error; +@@ -90,7 +96,7 @@ X509_POLICY_NODE *ossl_policy_level_add_node(X509_POLICY_LEVEL *level, + } + } + +- if (tree) { ++ if (extra_data) { + if (tree->extra_data == NULL) + tree->extra_data = sk_X509_POLICY_DATA_new_null(); + if (tree->extra_data == NULL){ +@@ -103,6 +109,7 @@ X509_POLICY_NODE *ossl_policy_level_add_node(X509_POLICY_LEVEL *level, + } + } + ++ tree->node_count++; + if (parent) + parent->nchild++; + +diff --git a/crypto/x509/pcy_tree.c b/crypto/x509/pcy_tree.c +index fa45da5..b1271ea 100644 +--- a/crypto/x509/pcy_tree.c ++++ b/crypto/x509/pcy_tree.c +@@ -14,6 +14,17 @@ + + #include "pcy_local.h" + ++/* ++ * If the maximum number of nodes in the policy tree isn't defined, set it to ++ * a generous default of 1000 nodes. ++ * ++ * Defining this to be zero means unlimited policy tree growth which opens the ++ * door on CVE-2023-0464. ++ */ ++#ifndef OPENSSL_POLICY_TREE_NODES_MAX ++# define OPENSSL_POLICY_TREE_NODES_MAX 1000 ++#endif ++ + static void expected_print(BIO *channel, + X509_POLICY_LEVEL *lev, X509_POLICY_NODE *node, + int indent) +@@ -117,6 +128,9 @@ static int tree_init(X509_POLICY_TREE **ptree, STACK_OF(X509) *certs, + return X509_PCY_TREE_INTERNAL; + } + ++ /* Limit the growth of the tree to mitigate CVE-2023-0464 */ ++ tree->node_maximum = OPENSSL_POLICY_TREE_NODES_MAX; ++ + /* + * At this point check for invalid policies and required explicit policy. + * Note that the explicit_policy counter is a count-down to zero, with the +@@ -180,7 +194,7 @@ static int tree_init(X509_POLICY_TREE **ptree, STACK_OF(X509) *certs, + if ((data = ossl_policy_data_new(NULL, + OBJ_nid2obj(NID_any_policy), 0)) == NULL) + goto bad_tree; +- if (ossl_policy_level_add_node(level, data, NULL, tree) == NULL) { ++ if (ossl_policy_level_add_node(level, data, NULL, tree, 1) == NULL) { + ossl_policy_data_free(data); + goto bad_tree; + } +@@ -239,7 +253,8 @@ static int tree_init(X509_POLICY_TREE **ptree, STACK_OF(X509) *certs, + * Return value: 1 on success, 0 otherwise + */ + static int tree_link_matching_nodes(X509_POLICY_LEVEL *curr, +- X509_POLICY_DATA *data) ++ X509_POLICY_DATA *data, ++ X509_POLICY_TREE *tree) + { + X509_POLICY_LEVEL *last = curr - 1; + int i, matched = 0; +@@ -249,13 +264,13 @@ static int tree_link_matching_nodes(X509_POLICY_LEVEL *curr, + X509_POLICY_NODE *node = sk_X509_POLICY_NODE_value(last->nodes, i); + + if (ossl_policy_node_match(last, node, data->valid_policy)) { +- if (ossl_policy_level_add_node(curr, data, node, NULL) == NULL) ++ if (ossl_policy_level_add_node(curr, data, node, tree, 0) == NULL) + return 0; + matched = 1; + } + } + if (!matched && last->anyPolicy) { +- if (ossl_policy_level_add_node(curr, data, last->anyPolicy, NULL) == NULL) ++ if (ossl_policy_level_add_node(curr, data, last->anyPolicy, tree, 0) == NULL) + return 0; + } + return 1; +@@ -268,7 +283,8 @@ static int tree_link_matching_nodes(X509_POLICY_LEVEL *curr, + * Return value: 1 on success, 0 otherwise. + */ + static int tree_link_nodes(X509_POLICY_LEVEL *curr, +- const X509_POLICY_CACHE *cache) ++ const X509_POLICY_CACHE *cache, ++ X509_POLICY_TREE *tree) + { + int i; + +@@ -276,7 +292,7 @@ static int tree_link_nodes(X509_POLICY_LEVEL *curr, + X509_POLICY_DATA *data = sk_X509_POLICY_DATA_value(cache->data, i); + + /* Look for matching nodes in previous level */ +- if (!tree_link_matching_nodes(curr, data)) ++ if (!tree_link_matching_nodes(curr, data, tree)) + return 0; + } + return 1; +@@ -307,7 +323,7 @@ static int tree_add_unmatched(X509_POLICY_LEVEL *curr, + /* Curr may not have anyPolicy */ + data->qualifier_set = cache->anyPolicy->qualifier_set; + data->flags |= POLICY_DATA_FLAG_SHARED_QUALIFIERS; +- if (ossl_policy_level_add_node(curr, data, node, tree) == NULL) { ++ if (ossl_policy_level_add_node(curr, data, node, tree, 1) == NULL) { + ossl_policy_data_free(data); + return 0; + } +@@ -370,7 +386,7 @@ static int tree_link_any(X509_POLICY_LEVEL *curr, + /* Finally add link to anyPolicy */ + if (last->anyPolicy && + ossl_policy_level_add_node(curr, cache->anyPolicy, +- last->anyPolicy, NULL) == NULL) ++ last->anyPolicy, tree, 0) == NULL) + return 0; + return 1; + } +@@ -553,7 +569,7 @@ static int tree_calculate_user_set(X509_POLICY_TREE *tree, + extra->flags = POLICY_DATA_FLAG_SHARED_QUALIFIERS + | POLICY_DATA_FLAG_EXTRA_NODE; + node = ossl_policy_level_add_node(NULL, extra, anyPolicy->parent, +- tree); ++ tree, 1); + } + if (!tree->user_policies) { + tree->user_policies = sk_X509_POLICY_NODE_new_null(); +@@ -580,7 +596,7 @@ static int tree_evaluate(X509_POLICY_TREE *tree) + + for (i = 1; i < tree->nlevel; i++, curr++) { + cache = ossl_policy_cache_set(curr->cert); +- if (!tree_link_nodes(curr, cache)) ++ if (!tree_link_nodes(curr, cache, tree)) + return X509_PCY_TREE_INTERNAL; + + if (!(curr->flags & X509_V_FLAG_INHIBIT_ANY) +-- +2.31.1 + diff --git a/0049-fix-CVE-2023-0465.patch b/0049-fix-CVE-2023-0465.patch new file mode 100644 index 0000000000000000000000000000000000000000..88d8685162adced2c89d559baf80365819642fac --- /dev/null +++ b/0049-fix-CVE-2023-0465.patch @@ -0,0 +1,91 @@ +From 93e500e954f4724365a7ee31c9dce2bd502a6f3d Mon Sep 17 00:00:00 2001 +From: Matt Caswell +Date: Sat, 6 May 2023 16:52:37 +0800 +Subject: [PATCH 1/1] fix CVE 2023 0465 + +--- + CHANGES.md | 8 ++++++++ + NEWS.md | 3 +++ + crypto/x509/x509_vfy.c | 12 ++++++++++-- + 3 files changed, 21 insertions(+), 2 deletions(-) + +diff --git a/CHANGES.md b/CHANGES.md +index 5cf1f60..bee4757 100644 +--- a/CHANGES.md ++++ b/CHANGES.md +@@ -30,6 +30,13 @@ breaking changes, and mappings for the large list of deprecated functions. + + ### Changes between 3.0.6 and 3.0.7 [1 Nov 2022] + ++ * Fixed an issue where invalid certificate policies in leaf certificates are ++ silently ignored by OpenSSL and other certificate policy checks are skipped ++ for that certificate. A malicious CA could use this to deliberately assert ++ invalid certificate policies in order to circumvent policy checking on the ++ certificate altogether. ++ ([CVE-2023-0465]) ++ + * Limited the number of nodes created in a policy tree to mitigate + against CVE-2023-0464. The default limit is set to 1000 nodes, which + should be sufficient for most installations. If required, the limit +@@ -19423,6 +19430,7 @@ ndif + + + ++[CVE-2023-0465]: https://www.openssl.org/news/vulnerabilities.html#CVE-2023-0465 + [CVE-2023-0464]: https://www.openssl.org/news/vulnerabilities.html#CVE-2023-0464 + [CVE-2022-2274]: https://www.openssl.org/news/vulnerabilities.html#CVE-2022-2274 + [CVE-2022-2097]: https://www.openssl.org/news/vulnerabilities.html#CVE-2022-2274 +diff --git a/NEWS.md b/NEWS.md +index 450c590..e43a2ad 100644 +--- a/NEWS.md ++++ b/NEWS.md +@@ -25,6 +25,8 @@ OpenSSL 3.0 + * Fixed two buffer overflows in punycode decoding functions. + ([CVE-2022-3786]) and ([CVE-2022-3602]) + * Limited the number of nodes created in a policy tree ([CVE-2023-0464]) ++ * Fixed handling of invalid certificate policies in leaf certificates ++ ([CVE-2023-0465]) + + ### Major changes between OpenSSL 3.0.5 and OpenSSL 3.0.6 [11 Oct 2022] + +@@ -1420,6 +1422,7 @@ OpenSSL 0.9.x + + + ++[CVE-2023-0465]: https://www.openssl.org/news/vulnerabilities.html#CVE-2023-0465 + [CVE-2023-0464]: https://www.openssl.org/news/vulnerabilities.html#CVE-2023-0464 + [CVE-2022-2274]: https://www.openssl.org/news/vulnerabilities.html#CVE-2022-2274 + [CVE-2022-2097]: https://www.openssl.org/news/vulnerabilities.html#CVE-2022-2274 +diff --git a/crypto/x509/x509_vfy.c b/crypto/x509/x509_vfy.c +index 859d5ca..61167f6 100644 +--- a/crypto/x509/x509_vfy.c ++++ b/crypto/x509/x509_vfy.c +@@ -1655,15 +1655,23 @@ static int check_policy(X509_STORE_CTX *ctx) + goto memerr; + /* Invalid or inconsistent extensions */ + if (ret == X509_PCY_TREE_INVALID) { +- int i; ++ int i, cbcalled = 0; + + /* Locate certificates with bad extensions and notify callback. */ +- for (i = 1; i < sk_X509_num(ctx->chain); i++) { ++ for (i = 0; i < sk_X509_num(ctx->chain); i++) { + X509 *x = sk_X509_value(ctx->chain, i); + ++ if ((x->ex_flags & EXFLAG_INVALID_POLICY) != 0) ++ cbcalled = 1; + CB_FAIL_IF((x->ex_flags & EXFLAG_INVALID_POLICY) != 0, + ctx, x, i, X509_V_ERR_INVALID_POLICY_EXTENSION); + } ++ if (!cbcalled) { ++ /* Should not be able to get here */ ++ ERR_raise(ERR_LIB_X509, ERR_R_INTERNAL_ERROR); ++ return 0; ++ } ++ /* The callback ignored the error so we return success */ + return 1; + } + if (ret == X509_PCY_TREE_FAILURE) { +-- +2.31.1 + diff --git a/0050-fix-CVE-2023-0466.patch b/0050-fix-CVE-2023-0466.patch new file mode 100644 index 0000000000000000000000000000000000000000..124bfdbd9e0609a9aaa94bbb65f54de7234f466a --- /dev/null +++ b/0050-fix-CVE-2023-0466.patch @@ -0,0 +1,85 @@ +From 79878304c42e58ed63f39ea138035ac7d26bed63 Mon Sep 17 00:00:00 2001 +From: Tomas Mraz +Date: Sat, 6 May 2023 16:56:21 +0800 +Subject: [PATCH 1/1] fix CVE 2023 0466 + +--- + CHANGES.md | 6 ++++++ + NEWS.md | 2 ++ + doc/man3/X509_VERIFY_PARAM_set_flags.pod | 9 +++++++-- + 3 files changed, 15 insertions(+), 2 deletions(-) + +diff --git a/CHANGES.md b/CHANGES.md +index bee4757..2943a2a 100644 +--- a/CHANGES.md ++++ b/CHANGES.md +@@ -30,6 +30,11 @@ breaking changes, and mappings for the large list of deprecated functions. + + ### Changes between 3.0.6 and 3.0.7 [1 Nov 2022] + ++ * Corrected documentation of X509_VERIFY_PARAM_add0_policy() to mention ++ that it does not enable policy checking. Thanks to David Benjamin for ++ discovering this issue. ++ ([CVE-2023-0466]) ++ + * Fixed an issue where invalid certificate policies in leaf certificates are + silently ignored by OpenSSL and other certificate policy checks are skipped + for that certificate. A malicious CA could use this to deliberately assert +@@ -19430,6 +19435,7 @@ ndif + + + ++[CVE-2023-0466]: https://www.openssl.org/news/vulnerabilities.html#CVE-2023-0466 + [CVE-2023-0465]: https://www.openssl.org/news/vulnerabilities.html#CVE-2023-0465 + [CVE-2023-0464]: https://www.openssl.org/news/vulnerabilities.html#CVE-2023-0464 + [CVE-2022-2274]: https://www.openssl.org/news/vulnerabilities.html#CVE-2022-2274 +diff --git a/NEWS.md b/NEWS.md +index e43a2ad..1b6cc64 100644 +--- a/NEWS.md ++++ b/NEWS.md +@@ -27,6 +27,7 @@ OpenSSL 3.0 + * Limited the number of nodes created in a policy tree ([CVE-2023-0464]) + * Fixed handling of invalid certificate policies in leaf certificates + ([CVE-2023-0465]) ++ * Fixed documentation of X509_VERIFY_PARAM_add0_policy() ([CVE-2023-0466]) + + ### Major changes between OpenSSL 3.0.5 and OpenSSL 3.0.6 [11 Oct 2022] + +@@ -1422,6 +1423,7 @@ OpenSSL 0.9.x + + + ++[CVE-2023-0466]: https://www.openssl.org/news/vulnerabilities.html#CVE-2023-0466 + [CVE-2023-0465]: https://www.openssl.org/news/vulnerabilities.html#CVE-2023-0465 + [CVE-2023-0464]: https://www.openssl.org/news/vulnerabilities.html#CVE-2023-0464 + [CVE-2022-2274]: https://www.openssl.org/news/vulnerabilities.html#CVE-2022-2274 +diff --git a/doc/man3/X509_VERIFY_PARAM_set_flags.pod b/doc/man3/X509_VERIFY_PARAM_set_flags.pod +index 5c0ca30..c3894ff 100644 +--- a/doc/man3/X509_VERIFY_PARAM_set_flags.pod ++++ b/doc/man3/X509_VERIFY_PARAM_set_flags.pod +@@ -97,8 +97,9 @@ B. + X509_VERIFY_PARAM_set_time() sets the verification time in B to + B. Normally the current time is used. + +-X509_VERIFY_PARAM_add0_policy() enables policy checking (it is disabled +-by default) and adds B to the acceptable policy set. ++X509_VERIFY_PARAM_add0_policy() adds B to the acceptable policy set. ++Contrary to preexisting documentation of this function it does not enable ++policy checking. + + X509_VERIFY_PARAM_set1_policies() enables policy checking (it is disabled + by default) and sets the acceptable policy set to B. Any existing +@@ -198,6 +199,10 @@ L. + X509_VERIFY_PARAM_get1_ip_asc() returns the expected IP address as a string. + The caller is responsible for freeing it. + ++The function X509_VERIFY_PARAM_add0_policy() was historically documented as ++enabling policy checking however the implementation has never done this. ++The documentation was changed to align with the implementation. ++ + X509_VERIFY_PARAM_set1_ip() sets the expected IP address to B. + The B argument is in binary format, in network byte-order and + B must be set to 4 for IPv4 and 16 for IPv6. When an IP +-- +2.31.1 + diff --git a/openssl.spec b/openssl.spec index 46b8102e30d1aa75980309bbddd21862c4bdc682..cb784bec14bee6ac7bce29469893c32a7d633a17 100644 --- a/openssl.spec +++ b/openssl.spec @@ -1,4 +1,4 @@ -%define anolis_release 7 +%define anolis_release 8 %global soversion 3 %define srpmhash() %{lua: @@ -98,6 +98,9 @@ Patch44: 0044-PSS-salt-length-from-provider.patch Patch45: 0045-signature-Clamp-PSS-salt-len-to-MD-len.patch Patch46: 0046-FIPS-RSA-encapsulate.patch Patch47: 0047-provider-improvements.patch +Patch48: 0048-fix-CVE-2023-0464.patch +Patch49: 0049-fix-CVE-2023-0465.patch +Patch50: 0050-fix-CVE-2023-0466.patch BuildRequires: gcc git coreutils perl-interpreter sed zlib-devel /usr/bin/cmp BuildRequires: lksctp-tools-devel @@ -280,6 +283,9 @@ rm -f $RPM_BUILD_ROOT%{_sysconfdir}/pki/tls/{openssl.cnf.dist,ct_log_list.cnf.di %ldconfig_scriptlets libs %changelog +* Sat May 06 2023 happy_orange - 1:3.0.7-8 +- fix CVE-2023-0465 and CVE-2023-0466 + * Tue Mar 28 2023 mgb01105731 - 1:3.0.7-7 - Del Specific Fields