Commit 6bbcf0de96 for openssl.org

commit 6bbcf0de963920bf3d82d35a2f2d9030deb224da
Author: baentsch <57787676+baentsch@users.noreply.github.com>
Date:   Wed Nov 11 18:41:09 2026 +0100

    ssl: do not return groups with min/maxtls=-1 in SSL_CTX_get0_implemented_groups()

    A group registered in a provider with -1 as its min or max TLS version
    was still returned by SSL_CTX_get0_implemented_groups(), which is wrong:
    if an algorithm is registered with min/max TLS version "-1", it cannot
    be used for handshakes, so, arguably, it should not be returned
    in the list of supported tls_groups (per provider-base(7): "A -1
    indicates that the group should not be used in that protocol").

    Skip a group if its mintls or maxtls field is set to -1 during iteration.

    Resolves: https://github.com/openssl/openssl/issues/33387
    Fixes: 4b1c73d2dd74 "ML-KEM hybrids for TLS"
    Reviewed-by: Tomas Mraz <tomas@openssl.foundation>
    Reviewed-by: Matt Caswell <matt@openssl.foundation>
    Reviewed-by: Eugene Syromiatnikov <esyr@openssl.org>
    Reviewed-by: Richard Levitte <levitte@openssl.foundation>
    Reviewed-by: Saša NedvÄ›dický <sashan@openssl.org>
    Merge-date: Sat Nov 21 06:16:35 2026
    Merged-from: https://github.com/openssl/openssl/pull/33676

diff --git a/ssl/t1_lib.c b/ssl/t1_lib.c
index c6559cb76f..b39e636d9e 100644
--- a/ssl/t1_lib.c
+++ b/ssl/t1_lib.c
@@ -1023,6 +1023,8 @@ int tls1_get0_implemented_groups(int min_proto_version, int max_proto_version,
         if (grps->maxtls > 0 && min_proto_version > 0
             && grps->maxtls < min_proto_version)
             continue;
+        if (grps->mintls < 0 || grps->maxtls < 0)
+            continue;

         if ((gix = OPENSSL_malloc(sizeof(*gix))) == NULL)
             goto end;
diff --git a/test/sslapitest.c b/test/sslapitest.c
index 40f70303fb..cec221ac44 100644
--- a/test/sslapitest.c
+++ b/test/sslapitest.c
@@ -14956,6 +14956,50 @@ end:
     return testresult;
 }

+/*
+ * A TLS group registered by a provider with mintls/maxtls == -1 must not be
+ * used for handshakes and must therefore not be reported by
+ * SSL_CTX_get0_implemented_groups(). The tls-provider registers such a group
+ * ("xordisabledgroup") for this test.
+ */
+static int test_disabled_group_not_implemented(void)
+{
+    SSL_CTX *ctx = NULL;
+    STACK_OF(OPENSSL_CSTRING) *groups = NULL;
+    OSSL_PROVIDER *tlsprov = OSSL_PROVIDER_load(libctx, "tls-provider");
+    int i, num, testresult = 0;
+    int found_disabled = 0;
+
+    if (!TEST_ptr(tlsprov))
+        goto end;
+
+    if (!TEST_ptr(groups = sk_OPENSSL_CSTRING_new_null())
+        || !TEST_ptr(ctx = SSL_CTX_new_ex(libctx, NULL, TLS_method())))
+        goto end;
+
+    if (!TEST_true(SSL_CTX_get0_implemented_groups(ctx, 1, groups)))
+        goto end;
+
+    num = sk_OPENSSL_CSTRING_num(groups);
+    for (i = 0; i < num; ++i) {
+        const char *name = sk_OPENSSL_CSTRING_value(groups, i);
+
+        if (strcmp(name, "xordisabledgroup") == 0)
+            found_disabled = 1;
+    }
+
+    if (!TEST_false(found_disabled))
+        goto end;
+
+    testresult = 1;
+
+end:
+    sk_OPENSSL_CSTRING_free(groups);
+    SSL_CTX_free(ctx);
+    OSSL_PROVIDER_unload(tlsprov);
+    return testresult;
+}
+
 /*
  * This function triggers encode, decode and sign functions
  * of the artificial "xorhmacsig" algorithm implemented in tls-provider
@@ -20016,6 +20060,7 @@ int setup_tests(void)
 #endif
 #if !defined(OPENSSL_NO_TLS1_3) || !defined(OPENSSL_NO_DTLS1_3)
     ADD_ALL_TESTS(test_pluggable_group, 4);
+    ADD_TEST(test_disabled_group_not_implemented);
     ADD_ALL_TESTS(test_pluggable_signature, 12);
 #endif
 #if !defined(OPENSSL_NO_TLS1_2) || !defined(OSSL_NO_USABLE_TLS1_3)
diff --git a/test/tls-provider.c b/test/tls-provider.c
index 537ee8efb5..21b4ad577f 100644
--- a/test/tls-provider.c
+++ b/test/tls-provider.c
@@ -198,8 +198,7 @@ static void xor_prov_free_key(const OSSL_DISPATCH *fns, void *key)
 }

 /*
- * We define 2 dummy TLS groups called "xorgroup" and "xorkemgroup" for test
- * purposes
+ * We define dummy TLS groups for test purposes
  */
 struct tls_group_st {
     unsigned int group_id; /* for "tls-group-id", see provider-base(7) */
@@ -275,6 +274,37 @@ static const OSSL_PARAM xor_kemgroup_params[] = {
     OSSL_PARAM_END
 };

+#define XORDISABLEDGROUP_NAME "xordisabledgroup"
+#define XORDISABLEDGROUP_NAME_INTERNAL "xordisabledgroup-int"
+static struct tls_group_st xor_disabledgroup = {
+    0, /* group_id, set by randomize_tls_alg_id() */
+    128, /* secbits */
+    -1, /* mintls */
+    -1, /* maxtls */
+    -1, /* mindtls */
+    -1, /* maxdtls */
+    0 /* is_kem */
+};
+
+static const OSSL_PARAM xor_disabledgroup_params[] = {
+    OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_GROUP_NAME,
+        XORDISABLEDGROUP_NAME, sizeof(XORDISABLEDGROUP_NAME)),
+    OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_GROUP_NAME_INTERNAL,
+        XORDISABLEDGROUP_NAME_INTERNAL,
+        sizeof(XORDISABLEDGROUP_NAME_INTERNAL)),
+    OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_GROUP_ALG, ALGORITHM,
+        sizeof(ALGORITHM)),
+    OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_GROUP_ID, &xor_disabledgroup.group_id),
+    OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_GROUP_SECURITY_BITS,
+        &xor_disabledgroup.secbits),
+    OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MIN_TLS, &xor_disabledgroup.mintls),
+    OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MAX_TLS, &xor_disabledgroup.maxtls),
+    OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MIN_DTLS, &xor_disabledgroup.mindtls),
+    OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MAX_DTLS, &xor_disabledgroup.maxdtls),
+    OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_GROUP_IS_KEM, &xor_disabledgroup.is_kem),
+    OSSL_PARAM_END
+};
+
 #define NUM_DUMMY_GROUPS 50
 static char *dummy_group_names[NUM_DUMMY_GROUPS];

@@ -405,11 +435,12 @@ static int tls_prov_get_capabilities(void *provctx, const char *capability,
     const size_t dummy_name_max_size = strlen(dummy_base) + 3;

     if (strcmp(capability, "TLS-GROUP") == 0) {
-        /* Register our 2 groups */
+        /* Register our dummy groups */
         OPENSSL_assert(xor_group.group_id >= 65024
             && xor_group.group_id < 65279 - NUM_DUMMY_GROUPS);
         ret = cb(xor_group_params, arg);
         ret &= cb(xor_kemgroup_params, arg);
+        ret &= cb(xor_disabledgroup_params, arg);

         /*
          * Now register some dummy groups > GROUPLIST_INCREMENT (== 40) as defined
@@ -3231,6 +3262,7 @@ int tls_provider_init(const OSSL_CORE_HANDLE *handle,
      */
     xor_group.group_id = randomize_tls_alg_id(libctx);
     xor_kemgroup.group_id = randomize_tls_alg_id(libctx);
+    xor_disabledgroup.group_id = randomize_tls_alg_id(libctx);
     xor_sigalg.code_point = randomize_tls_alg_id(libctx);
     xor_sigalg_hash.code_point = randomize_tls_alg_id(libctx);