ssl/t1_lib.c

   1 /*
   2  * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <openssl/objects.h>
  13 #include <openssl/evp.h>
  14 #include <openssl/hmac.h>
  15 #include <openssl/core_names.h>
  16 #include <openssl/ocsp.h>
  17 #include <openssl/conf.h>
  18 #include <openssl/x509v3.h>
  19 #include <openssl/dh.h>
  20 #include <openssl/bn.h>
  21 #include <openssl/provider.h>
  22 #include <openssl/param_build.h>
  23 #include "internal/nelem.h"
  24 #include "internal/sizes.h"
  25 #include "internal/tlsgroups.h"
  26 #include "ssl_local.h"
  27 #include <openssl/ct.h>
  28
  29 static const SIGALG_LOOKUP *find_sig_alg(SSL *s, X509 *x, EVP_PKEY *pkey);
  30 static int tls12_sigalg_allowed(const SSL *s, int op, const SIGALG_LOOKUP *lu);
  31
  32 SSL3_ENC_METHOD const TLSv1_enc_data = {
  33     tls1_enc,
  34     tls1_mac,
  35     tls1_setup_key_block,
  36     tls1_generate_master_secret,
  37     tls1_change_cipher_state,
  38     tls1_final_finish_mac,
  39     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
  40     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
  41     tls1_alert_code,
  42     tls1_export_keying_material,
  43     0,
  44     ssl3_set_handshake_header,
  45     tls_close_construct_packet,
  46     ssl3_handshake_write
  47 };
  48
  49 SSL3_ENC_METHOD const TLSv1_1_enc_data = {
  50     tls1_enc,
  51     tls1_mac,
  52     tls1_setup_key_block,
  53     tls1_generate_master_secret,
  54     tls1_change_cipher_state,
  55     tls1_final_finish_mac,
  56     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
  57     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
  58     tls1_alert_code,
  59     tls1_export_keying_material,
  60     SSL_ENC_FLAG_EXPLICIT_IV,
  61     ssl3_set_handshake_header,
  62     tls_close_construct_packet,
  63     ssl3_handshake_write
  64 };
  65
  66 SSL3_ENC_METHOD const TLSv1_2_enc_data = {
  67     tls1_enc,
  68     tls1_mac,
  69     tls1_setup_key_block,
  70     tls1_generate_master_secret,
  71     tls1_change_cipher_state,
  72     tls1_final_finish_mac,
  73     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
  74     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
  75     tls1_alert_code,
  76     tls1_export_keying_material,
  77     SSL_ENC_FLAG_EXPLICIT_IV | SSL_ENC_FLAG_SIGALGS | SSL_ENC_FLAG_SHA256_PRF
  78         | SSL_ENC_FLAG_TLS1_2_CIPHERS,
  79     ssl3_set_handshake_header,
  80     tls_close_construct_packet,
  81     ssl3_handshake_write
  82 };
  83
  84 SSL3_ENC_METHOD const TLSv1_3_enc_data = {
  85     tls13_enc,
  86     tls1_mac,
  87     tls13_setup_key_block,
  88     tls13_generate_master_secret,
  89     tls13_change_cipher_state,
  90     tls13_final_finish_mac,
  91     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
  92     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
  93     tls13_alert_code,
  94     tls13_export_keying_material,
  95     SSL_ENC_FLAG_SIGALGS | SSL_ENC_FLAG_SHA256_PRF,
  96     ssl3_set_handshake_header,
  97     tls_close_construct_packet,
  98     ssl3_handshake_write
  99 };
 100
 101 long tls1_default_timeout(void)
 102 {
 103     /*
 104      * 2 hours, the 24 hours mentioned in the TLSv1 spec is way too long for
 105      * http, the cache would over fill
 106      */
 107     return (60 * 60 * 2);
 108 }
 109
 110 int tls1_new(SSL *s)
 111 {
 112     if (!ssl3_new(s))
 113         return 0;
 114     if (!s->method->ssl_clear(s))
 115         return 0;
 116
 117     return 1;
 118 }
 119
 120 void tls1_free(SSL *s)
 121 {
 122     OPENSSL_free(s->ext.session_ticket);
 123     ssl3_free(s);
 124 }
 125
 126 int tls1_clear(SSL *s)
 127 {
 128     if (!ssl3_clear(s))
 129         return 0;
 130
 131     if (s->method->version == TLS_ANY_VERSION)
 132         s->version = TLS_MAX_VERSION_INTERNAL;
 133     else
 134         s->version = s->method->version;
 135
 136     return 1;
 137 }
 138
 139 /* Legacy NID to group_id mapping. Only works for groups we know about */
 140 static struct {
 141     int nid;
 142     uint16_t group_id;
 143 } nid_to_group[] = {
 144     {NID_sect163k1, OSSL_TLS_GROUP_ID_sect163k1},
 145     {NID_sect163r1, OSSL_TLS_GROUP_ID_sect163r1},
 146     {NID_sect163r2, OSSL_TLS_GROUP_ID_sect163r2},
 147     {NID_sect193r1, OSSL_TLS_GROUP_ID_sect193r1},
 148     {NID_sect193r2, OSSL_TLS_GROUP_ID_sect193r2},
 149     {NID_sect233k1, OSSL_TLS_GROUP_ID_sect233k1},
 150     {NID_sect233r1, OSSL_TLS_GROUP_ID_sect233r1},
 151     {NID_sect239k1, OSSL_TLS_GROUP_ID_sect239k1},
 152     {NID_sect283k1, OSSL_TLS_GROUP_ID_sect283k1},
 153     {NID_sect283r1, OSSL_TLS_GROUP_ID_sect283r1},
 154     {NID_sect409k1, OSSL_TLS_GROUP_ID_sect409k1},
 155     {NID_sect409r1, OSSL_TLS_GROUP_ID_sect409r1},
 156     {NID_sect571k1, OSSL_TLS_GROUP_ID_sect571k1},
 157     {NID_sect571r1, OSSL_TLS_GROUP_ID_sect571r1},
 158     {NID_secp160k1, OSSL_TLS_GROUP_ID_secp160k1},
 159     {NID_secp160r1, OSSL_TLS_GROUP_ID_secp160r1},
 160     {NID_secp160r2, OSSL_TLS_GROUP_ID_secp160r2},
 161     {NID_secp192k1, OSSL_TLS_GROUP_ID_secp192k1},
 162     {NID_X9_62_prime192v1, OSSL_TLS_GROUP_ID_secp192r1},
 163     {NID_secp224k1, OSSL_TLS_GROUP_ID_secp224k1},
 164     {NID_secp224r1, OSSL_TLS_GROUP_ID_secp224r1},
 165     {NID_secp256k1, OSSL_TLS_GROUP_ID_secp256k1},
 166     {NID_X9_62_prime256v1, OSSL_TLS_GROUP_ID_secp256r1},
 167     {NID_secp384r1, OSSL_TLS_GROUP_ID_secp384r1},
 168     {NID_secp521r1, OSSL_TLS_GROUP_ID_secp521r1},
 169     {NID_brainpoolP256r1, OSSL_TLS_GROUP_ID_brainpoolP256r1},
 170     {NID_brainpoolP384r1, OSSL_TLS_GROUP_ID_brainpoolP384r1},
 171     {NID_brainpoolP512r1, OSSL_TLS_GROUP_ID_brainpoolP512r1},
 172     {EVP_PKEY_X25519, OSSL_TLS_GROUP_ID_x25519},
 173     {EVP_PKEY_X448, OSSL_TLS_GROUP_ID_x448},
 174     {NID_id_tc26_gost_3410_2012_256_paramSetA, OSSL_TLS_GROUP_ID_gc256A},
 175     {NID_id_tc26_gost_3410_2012_256_paramSetB, OSSL_TLS_GROUP_ID_gc256B},
 176     {NID_id_tc26_gost_3410_2012_256_paramSetC, OSSL_TLS_GROUP_ID_gc256C},
 177     {NID_id_tc26_gost_3410_2012_256_paramSetD, OSSL_TLS_GROUP_ID_gc256D},
 178     {NID_id_tc26_gost_3410_2012_512_paramSetA, OSSL_TLS_GROUP_ID_gc512A},
 179     {NID_id_tc26_gost_3410_2012_512_paramSetB, OSSL_TLS_GROUP_ID_gc512B},
 180     {NID_id_tc26_gost_3410_2012_512_paramSetC, OSSL_TLS_GROUP_ID_gc512C},
 181     {NID_ffdhe2048, OSSL_TLS_GROUP_ID_ffdhe2048},
 182     {NID_ffdhe3072, OSSL_TLS_GROUP_ID_ffdhe3072},
 183     {NID_ffdhe4096, OSSL_TLS_GROUP_ID_ffdhe4096},
 184     {NID_ffdhe6144, OSSL_TLS_GROUP_ID_ffdhe6144},
 185     {NID_ffdhe8192, OSSL_TLS_GROUP_ID_ffdhe8192}
 186 };
 187
 188 static const unsigned char ecformats_default[] = {
 189     TLSEXT_ECPOINTFORMAT_uncompressed,
 190     TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime,
 191     TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2
 192 };
 193
 194 /* The default curves */
 195 static const uint16_t supported_groups_default[] = {
 196     OSSL_TLS_GROUP_ID_x25519,        /* X25519 (29) */
 197     OSSL_TLS_GROUP_ID_secp256r1,     /* secp256r1 (23) */
 198     OSSL_TLS_GROUP_ID_x448,          /* X448 (30) */
 199     OSSL_TLS_GROUP_ID_secp521r1,     /* secp521r1 (25) */
 200     OSSL_TLS_GROUP_ID_secp384r1,     /* secp384r1 (24) */
 201     OSSL_TLS_GROUP_ID_gc256A,        /* GC256A (34) */
 202     OSSL_TLS_GROUP_ID_gc256B,        /* GC256B (35) */
 203     OSSL_TLS_GROUP_ID_gc256C,        /* GC256C (36) */
 204     OSSL_TLS_GROUP_ID_gc256D,        /* GC256D (37) */
 205     OSSL_TLS_GROUP_ID_gc512A,        /* GC512A (38) */
 206     OSSL_TLS_GROUP_ID_gc512B,        /* GC512B (39) */
 207     OSSL_TLS_GROUP_ID_gc512C,        /* GC512C (40) */
 208     OSSL_TLS_GROUP_ID_ffdhe2048,     /* ffdhe2048 (0x100) */
 209     OSSL_TLS_GROUP_ID_ffdhe3072,     /* ffdhe3072 (0x101) */
 210     OSSL_TLS_GROUP_ID_ffdhe4096,     /* ffdhe4096 (0x102) */
 211     OSSL_TLS_GROUP_ID_ffdhe6144,     /* ffdhe6144 (0x103) */
 212     OSSL_TLS_GROUP_ID_ffdhe8192,     /* ffdhe8192 (0x104) */
 213 };
 214
 215 static const uint16_t suiteb_curves[] = {
 216     OSSL_TLS_GROUP_ID_secp256r1,
 217     OSSL_TLS_GROUP_ID_secp384r1,
 218 };
 219
 220 struct provider_group_data_st {
 221     SSL_CTX *ctx;
 222     OSSL_PROVIDER *provider;
 223 };
 224
 225 #define TLS_GROUP_LIST_MALLOC_BLOCK_SIZE        10
 226 static OSSL_CALLBACK add_provider_groups;
 227 static int add_provider_groups(const OSSL_PARAM params[], void *data)
 228 {
 229     struct provider_group_data_st *pgd = data;
 230     SSL_CTX *ctx = pgd->ctx;
 231     OSSL_PROVIDER *provider = pgd->provider;
 232     const OSSL_PARAM *p;
 233     TLS_GROUP_INFO *ginf = NULL;
 234     EVP_KEYMGMT *keymgmt;
 235     unsigned int gid;
 236     unsigned int is_kem = 0;
 237     int ret = 0;
 238
 239     if (ctx->group_list_max_len == ctx->group_list_len) {
 240         TLS_GROUP_INFO *tmp = NULL;
 241
 242         if (ctx->group_list_max_len == 0)
 243             tmp = OPENSSL_malloc(sizeof(TLS_GROUP_INFO)
 244                                  * TLS_GROUP_LIST_MALLOC_BLOCK_SIZE);
 245         else
 246             tmp = OPENSSL_realloc(ctx->group_list,
 247                                   (ctx->group_list_max_len
 248                                    + TLS_GROUP_LIST_MALLOC_BLOCK_SIZE)
 249                                   * sizeof(TLS_GROUP_INFO));
 250         if (tmp == NULL) {
 251             ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
 252             return 0;
 253         }
 254         ctx->group_list = tmp;
 255         memset(tmp + ctx->group_list_max_len,
 256                0,
 257                sizeof(TLS_GROUP_INFO) * TLS_GROUP_LIST_MALLOC_BLOCK_SIZE);
 258         ctx->group_list_max_len += TLS_GROUP_LIST_MALLOC_BLOCK_SIZE;
 259     }
 260
 261     ginf = &ctx->group_list[ctx->group_list_len];
 262
 263     p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_NAME);
 264     if (p == NULL || p->data_type != OSSL_PARAM_UTF8_STRING) {
 265         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
 266         goto err;
 267     }
 268     ginf->tlsname = OPENSSL_strdup(p->data);
 269     if (ginf->tlsname == NULL) {
 270         ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
 271         goto err;
 272     }
 273
 274     p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_NAME_INTERNAL);
 275     if (p == NULL || p->data_type != OSSL_PARAM_UTF8_STRING) {
 276         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
 277         goto err;
 278     }
 279     ginf->realname = OPENSSL_strdup(p->data);
 280     if (ginf->realname == NULL) {
 281         ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
 282         goto err;
 283     }
 284
 285     p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_ID);
 286     if (p == NULL || !OSSL_PARAM_get_uint(p, &gid) || gid > UINT16_MAX) {
 287         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
 288         goto err;
 289     }
 290     ginf->group_id = (uint16_t)gid;
 291
 292     p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_ALG);
 293     if (p == NULL || p->data_type != OSSL_PARAM_UTF8_STRING) {
 294         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
 295         goto err;
 296     }
 297     ginf->algorithm = OPENSSL_strdup(p->data);
 298     if (ginf->algorithm == NULL) {
 299         ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
 300         goto err;
 301     }
 302
 303     p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_SECURITY_BITS);
 304     if (p == NULL || !OSSL_PARAM_get_uint(p, &ginf->secbits)) {
 305         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
 306         goto err;
 307     }
 308
 309     p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_IS_KEM);
 310     if (p != NULL && (!OSSL_PARAM_get_uint(p, &is_kem) || is_kem > 1)) {
 311         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
 312         goto err;
 313     }
 314     ginf->is_kem = 1 & is_kem;
 315
 316     p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_MIN_TLS);
 317     if (p == NULL || !OSSL_PARAM_get_int(p, &ginf->mintls)) {
 318         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
 319         goto err;
 320     }
 321
 322     p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_MAX_TLS);
 323     if (p == NULL || !OSSL_PARAM_get_int(p, &ginf->maxtls)) {
 324         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
 325         goto err;
 326     }
 327
 328     p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_MIN_DTLS);
 329     if (p == NULL || !OSSL_PARAM_get_int(p, &ginf->mindtls)) {
 330         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
 331         goto err;
 332     }
 333
 334     p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_MAX_DTLS);
 335     if (p == NULL || !OSSL_PARAM_get_int(p, &ginf->maxdtls)) {
 336         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
 337         goto err;
 338     }
 339     /*
 340      * Now check that the algorithm is actually usable for our property query
 341      * string. Regardless of the result we still return success because we have
 342      * successfully processed this group, even though we may decide not to use
 343      * it.
 344      */
 345     ret = 1;
 346     keymgmt = EVP_KEYMGMT_fetch(ctx->libctx, ginf->algorithm, ctx->propq);
 347     if (keymgmt != NULL) {
 348         /*
 349          * We have successfully fetched the algorithm - however if the provider
 350          * doesn't match this one then we ignore it.
 351          *
 352          * Note: We're cheating a little here. Technically if the same algorithm
 353          * is available from more than one provider then it is undefined which
 354          * implementation you will get back. Theoretically this could be
 355          * different every time...we assume here that you'll always get the
 356          * same one back if you repeat the exact same fetch. Is this a reasonable
 357          * assumption to make (in which case perhaps we should document this
 358          * behaviour)?
 359          */
 360         if (EVP_KEYMGMT_get0_provider(keymgmt) == provider) {
 361             /* We have a match - so we will use this group */
 362             ctx->group_list_len++;
 363             ginf = NULL;
 364         }
 365         EVP_KEYMGMT_free(keymgmt);
 366     }
 367  err:
 368     if (ginf != NULL) {
 369         OPENSSL_free(ginf->tlsname);
 370         OPENSSL_free(ginf->realname);
 371         OPENSSL_free(ginf->algorithm);
 372         ginf->tlsname = ginf->realname = NULL;
 373     }
 374     return ret;
 375 }
 376
 377 static int discover_provider_groups(OSSL_PROVIDER *provider, void *vctx)
 378 {
 379     struct provider_group_data_st pgd;
 380
 381     pgd.ctx = vctx;
 382     pgd.provider = provider;
 383     return OSSL_PROVIDER_get_capabilities(provider, "TLS-GROUP",
 384                                           add_provider_groups, &pgd);
 385 }
 386
 387 int ssl_load_groups(SSL_CTX *ctx)
 388 {
 389     size_t i, j, num_deflt_grps = 0;
 390     uint16_t tmp_supp_groups[OSSL_NELEM(supported_groups_default)];
 391
 392     if (!OSSL_PROVIDER_do_all(ctx->libctx, discover_provider_groups, ctx))
 393         return 0;
 394
 395     for (i = 0; i < OSSL_NELEM(supported_groups_default); i++) {
 396         for (j = 0; j < ctx->group_list_len; j++) {
 397             if (ctx->group_list[j].group_id == supported_groups_default[i]) {
 398                 tmp_supp_groups[num_deflt_grps++] = ctx->group_list[j].group_id;
 399                 break;
 400             }
 401         }
 402     }
 403
 404     if (num_deflt_grps == 0)
 405         return 1;
 406
 407     ctx->ext.supported_groups_default
 408         = OPENSSL_malloc(sizeof(uint16_t) * num_deflt_grps);
 409
 410     if (ctx->ext.supported_groups_default == NULL) {
 411         ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
 412         return 0;
 413     }
 414
 415     memcpy(ctx->ext.supported_groups_default,
 416            tmp_supp_groups,
 417            num_deflt_grps * sizeof(tmp_supp_groups[0]));
 418     ctx->ext.supported_groups_default_len = num_deflt_grps;
 419
 420     return 1;
 421 }
 422
 423 static uint16_t tls1_group_name2id(SSL_CTX *ctx, const char *name)
 424 {
 425     size_t i;
 426
 427     for (i = 0; i < ctx->group_list_len; i++) {
 428         if (strcmp(ctx->group_list[i].tlsname, name) == 0
 429                 || strcmp(ctx->group_list[i].realname, name) == 0)
 430             return ctx->group_list[i].group_id;
 431     }
 432
 433     return 0;
 434 }
 435
 436 uint16_t ssl_group_id_internal_to_tls13(uint16_t curve_id)
 437 {
 438     switch(curve_id) {
 439     case OSSL_TLS_GROUP_ID_brainpoolP256r1:
 440         return OSSL_TLS_GROUP_ID_brainpoolP256r1_tls13;
 441     case OSSL_TLS_GROUP_ID_brainpoolP384r1:
 442         return OSSL_TLS_GROUP_ID_brainpoolP384r1_tls13;
 443     case OSSL_TLS_GROUP_ID_brainpoolP512r1:
 444         return OSSL_TLS_GROUP_ID_brainpoolP512r1_tls13;
 445     case OSSL_TLS_GROUP_ID_brainpoolP256r1_tls13:
 446     case OSSL_TLS_GROUP_ID_brainpoolP384r1_tls13:
 447     case OSSL_TLS_GROUP_ID_brainpoolP512r1_tls13:
 448         return 0;
 449     default:
 450         return curve_id;
 451     }
 452 }
 453
 454 uint16_t ssl_group_id_tls13_to_internal(uint16_t curve_id)
 455 {
 456     switch(curve_id) {
 457     case OSSL_TLS_GROUP_ID_brainpoolP256r1:
 458     case OSSL_TLS_GROUP_ID_brainpoolP384r1:
 459     case OSSL_TLS_GROUP_ID_brainpoolP512r1:
 460         return 0;
 461     case OSSL_TLS_GROUP_ID_brainpoolP256r1_tls13:
 462         return OSSL_TLS_GROUP_ID_brainpoolP256r1;
 463     case OSSL_TLS_GROUP_ID_brainpoolP384r1_tls13:
 464         return OSSL_TLS_GROUP_ID_brainpoolP384r1;
 465     case OSSL_TLS_GROUP_ID_brainpoolP512r1_tls13:
 466         return OSSL_TLS_GROUP_ID_brainpoolP512r1;
 467     default:
 468         return curve_id;
 469     }
 470 }
 471
 472 const TLS_GROUP_INFO *tls1_group_id_lookup(SSL_CTX *ctx, uint16_t group_id)
 473 {
 474     size_t i;
 475
 476     for (i = 0; i < ctx->group_list_len; i++) {
 477         if (ctx->group_list[i].group_id == group_id)
 478             return &ctx->group_list[i];
 479     }
 480
 481     return NULL;
 482 }
 483
 484 int tls1_group_id2nid(uint16_t group_id, int include_unknown)
 485 {
 486     size_t i;
 487
 488     if (group_id == 0)
 489         return NID_undef;
 490
 491     /*
 492      * Return well known Group NIDs - for backwards compatibility. This won't
 493      * work for groups we don't know about.
 494      */
 495     for (i = 0; i < OSSL_NELEM(nid_to_group); i++)
 496     {
 497         if (nid_to_group[i].group_id == group_id)
 498             return nid_to_group[i].nid;
 499     }
 500     if (!include_unknown)
 501         return NID_undef;
 502     return TLSEXT_nid_unknown | (int)group_id;
 503 }
 504
 505 uint16_t tls1_nid2group_id(int nid)
 506 {
 507     size_t i;
 508
 509     /*
 510      * Return well known Group ids - for backwards compatibility. This won't
 511      * work for groups we don't know about.
 512      */
 513     for (i = 0; i < OSSL_NELEM(nid_to_group); i++)
 514     {
 515         if (nid_to_group[i].nid == nid)
 516             return nid_to_group[i].group_id;
 517     }
 518
 519     return 0;
 520 }
 521
 522 /*
 523  * Set *pgroups to the supported groups list and *pgroupslen to
 524  * the number of groups supported.
 525  */
 526 void tls1_get_supported_groups(SSL *s, const uint16_t **pgroups,
 527                                size_t *pgroupslen)
 528 {
 529     /* For Suite B mode only include P-256, P-384 */
 530     switch (tls1_suiteb(s)) {
 531     case SSL_CERT_FLAG_SUITEB_128_LOS:
 532         *pgroups = suiteb_curves;
 533         *pgroupslen = OSSL_NELEM(suiteb_curves);
 534         break;
 535
 536     case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY:
 537         *pgroups = suiteb_curves;
 538         *pgroupslen = 1;
 539         break;
 540
 541     case SSL_CERT_FLAG_SUITEB_192_LOS:
 542         *pgroups = suiteb_curves + 1;
 543         *pgroupslen = 1;
 544         break;
 545
 546     default:
 547         if (s->ext.supportedgroups == NULL) {
 548             *pgroups = s->ctx->ext.supported_groups_default;
 549             *pgroupslen = s->ctx->ext.supported_groups_default_len;
 550         } else {
 551             *pgroups = s->ext.supportedgroups;
 552             *pgroupslen = s->ext.supportedgroups_len;
 553         }
 554         break;
 555     }
 556 }
 557
 558 int tls_valid_group(SSL *s, uint16_t group_id, int minversion, int maxversion,
 559                     int isec, int *okfortls13)
 560 {
 561     const TLS_GROUP_INFO *ginfo = tls1_group_id_lookup(s->ctx, group_id);
 562     int ret;
 563
 564     if (okfortls13 != NULL)
 565         *okfortls13 = 0;
 566
 567     if (ginfo == NULL)
 568         return 0;
 569
 570     if (SSL_IS_DTLS(s)) {
 571         if (ginfo->mindtls < 0 || ginfo->maxdtls < 0)
 572             return 0;
 573         if (ginfo->maxdtls == 0)
 574             ret = 1;
 575         else
 576             ret = DTLS_VERSION_LE(minversion, ginfo->maxdtls);
 577         if (ginfo->mindtls > 0)
 578             ret &= DTLS_VERSION_GE(maxversion, ginfo->mindtls);
 579     } else {
 580         if (ginfo->mintls < 0 || ginfo->maxtls < 0)
 581             return 0;
 582         if (ginfo->maxtls == 0)
 583             ret = 1;
 584         else
 585             ret = (minversion <= ginfo->maxtls);
 586         if (ginfo->mintls > 0)
 587             ret &= (maxversion >= ginfo->mintls);
 588         if (ret && okfortls13 != NULL && maxversion == TLS1_3_VERSION)
 589             *okfortls13 = (ginfo->maxtls == 0)
 590                           || (ginfo->maxtls >= TLS1_3_VERSION);
 591     }
 592     ret &= !isec
 593            || strcmp(ginfo->algorithm, "EC") == 0
 594            || strcmp(ginfo->algorithm, "X25519") == 0
 595            || strcmp(ginfo->algorithm, "X448") == 0;
 596
 597     return ret;
 598 }
 599
 600 /* See if group is allowed by security callback */
 601 int tls_group_allowed(SSL *s, uint16_t group, int op)
 602 {
 603     const TLS_GROUP_INFO *ginfo = tls1_group_id_lookup(s->ctx, group);
 604     unsigned char gtmp[2];
 605
 606     if (ginfo == NULL)
 607         return 0;
 608
 609     gtmp[0] = group >> 8;
 610     gtmp[1] = group & 0xff;
 611     return ssl_security(s, op, ginfo->secbits,
 612                         tls1_group_id2nid(ginfo->group_id, 0), (void *)gtmp);
 613 }
 614
 615 /* Return 1 if "id" is in "list" */
 616 static int tls1_in_list(uint16_t id, const uint16_t *list, size_t listlen)
 617 {
 618     size_t i;
 619     for (i = 0; i < listlen; i++)
 620         if (list[i] == id)
 621             return 1;
 622     return 0;
 623 }
 624
 625 /*-
 626  * For nmatch >= 0, return the id of the |nmatch|th shared group or 0
 627  * if there is no match.
 628  * For nmatch == -1, return number of matches
 629  * For nmatch == -2, return the id of the group to use for
 630  * a tmp key, or 0 if there is no match.
 631  */
 632 uint16_t tls1_shared_group(SSL *s, int nmatch)
 633 {
 634     const uint16_t *pref, *supp;
 635     size_t num_pref, num_supp, i;
 636     int k;
 637
 638     /* Can't do anything on client side */
 639     if (s->server == 0)
 640         return 0;
 641     if (nmatch == -2) {
 642         if (tls1_suiteb(s)) {
 643             /*
 644              * For Suite B ciphersuite determines curve: we already know
 645              * these are acceptable due to previous checks.
 646              */
 647             unsigned long cid = s->s3.tmp.new_cipher->id;
 648
 649             if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)
 650                 return OSSL_TLS_GROUP_ID_secp256r1;
 651             if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384)
 652                 return OSSL_TLS_GROUP_ID_secp384r1;
 653             /* Should never happen */
 654             return 0;
 655         }
 656         /* If not Suite B just return first preference shared curve */
 657         nmatch = 0;
 658     }
 659     /*
 660      * If server preference set, our groups are the preference order
 661      * otherwise peer decides.
 662      */
 663     if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE) {
 664         tls1_get_supported_groups(s, &pref, &num_pref);
 665         tls1_get_peer_groups(s, &supp, &num_supp);
 666     } else {
 667         tls1_get_peer_groups(s, &pref, &num_pref);
 668         tls1_get_supported_groups(s, &supp, &num_supp);
 669     }
 670
 671     for (k = 0, i = 0; i < num_pref; i++) {
 672         uint16_t id = pref[i];
 673         uint16_t cid = id;
 674
 675         if (SSL_IS_TLS13(s)) {
 676             if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE)
 677                 cid = ssl_group_id_internal_to_tls13(id);
 678             else
 679                 cid = id = ssl_group_id_tls13_to_internal(id);
 680         }
 681         if (!tls1_in_list(cid, supp, num_supp)
 682                 || !tls_group_allowed(s, id, SSL_SECOP_CURVE_SHARED))
 683             continue;
 684         if (nmatch == k)
 685             return id;
 686          k++;
 687     }
 688     if (nmatch == -1)
 689         return k;
 690     /* Out of range (nmatch > k). */
 691     return 0;
 692 }
 693
 694 int tls1_set_groups(uint16_t **pext, size_t *pextlen,
 695                     int *groups, size_t ngroups)
 696 {
 697     uint16_t *glist;
 698     size_t i;
 699     /*
 700      * Bitmap of groups included to detect duplicates: two variables are added
 701      * to detect duplicates as some values are more than 32.
 702      */
 703     unsigned long *dup_list = NULL;
 704     unsigned long dup_list_egrp = 0;
 705     unsigned long dup_list_dhgrp = 0;
 706
 707     if (ngroups == 0) {
 708         ERR_raise(ERR_LIB_SSL, SSL_R_BAD_LENGTH);
 709         return 0;
 710     }
 711     if ((glist = OPENSSL_malloc(ngroups * sizeof(*glist))) == NULL) {
 712         ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
 713         return 0;
 714     }
 715     for (i = 0; i < ngroups; i++) {
 716         unsigned long idmask;
 717         uint16_t id;
 718         id = tls1_nid2group_id(groups[i]);
 719         if ((id & 0x00FF) >= (sizeof(unsigned long) * 8))
 720             goto err;
 721         idmask = 1L << (id & 0x00FF);
 722         dup_list = (id < 0x100) ? &dup_list_egrp : &dup_list_dhgrp;
 723         if (!id || ((*dup_list) & idmask))
 724             goto err;
 725         *dup_list |= idmask;
 726         glist[i] = id;
 727     }
 728     OPENSSL_free(*pext);
 729     *pext = glist;
 730     *pextlen = ngroups;
 731     return 1;
 732 err:
 733     OPENSSL_free(glist);
 734     return 0;
 735 }
 736
 737 # define GROUPLIST_INCREMENT   40
 738 # define GROUP_NAME_BUFFER_LENGTH 64
 739 typedef struct {
 740     SSL_CTX *ctx;
 741     size_t gidcnt;
 742     size_t gidmax;
 743     uint16_t *gid_arr;
 744 } gid_cb_st;
 745
 746 static int gid_cb(const char *elem, int len, void *arg)
 747 {
 748     gid_cb_st *garg = arg;
 749     size_t i;
 750     uint16_t gid = 0;
 751     char etmp[GROUP_NAME_BUFFER_LENGTH];
 752
 753     if (elem == NULL)
 754         return 0;
 755     if (garg->gidcnt == garg->gidmax) {
 756         uint16_t *tmp =
 757             OPENSSL_realloc(garg->gid_arr, garg->gidmax + GROUPLIST_INCREMENT);
 758         if (tmp == NULL)
 759             return 0;
 760         garg->gidmax += GROUPLIST_INCREMENT;
 761         garg->gid_arr = tmp;
 762     }
 763     if (len > (int)(sizeof(etmp) - 1))
 764         return 0;
 765     memcpy(etmp, elem, len);
 766     etmp[len] = 0;
 767
 768     gid = tls1_group_name2id(garg->ctx, etmp);
 769     if (gid == 0)
 770         return 0;
 771     for (i = 0; i < garg->gidcnt; i++)
 772         if (garg->gid_arr[i] == gid)
 773             return 0;
 774     garg->gid_arr[garg->gidcnt++] = gid;
 775     return 1;
 776 }
 777
 778 /* Set groups based on a colon separated list */
 779 int tls1_set_groups_list(SSL_CTX *ctx, uint16_t **pext, size_t *pextlen,
 780                          const char *str)
 781 {
 782     gid_cb_st gcb;
 783     uint16_t *tmparr;
 784     int ret = 0;
 785
 786     gcb.gidcnt = 0;
 787     gcb.gidmax = GROUPLIST_INCREMENT;
 788     gcb.gid_arr = OPENSSL_malloc(gcb.gidmax * sizeof(*gcb.gid_arr));
 789     if (gcb.gid_arr == NULL)
 790         return 0;
 791     gcb.ctx = ctx;
 792     if (!CONF_parse_list(str, ':', 1, gid_cb, &gcb))
 793         goto end;
 794     if (pext == NULL) {
 795         ret = 1;
 796         goto end;
 797     }
 798
 799     /*
 800      * gid_cb ensurse there are no duplicates so we can just go ahead and set
 801      * the result
 802      */
 803     tmparr = OPENSSL_memdup(gcb.gid_arr, gcb.gidcnt * sizeof(*tmparr));
 804     if (tmparr == NULL)
 805         goto end;
 806     *pext = tmparr;
 807     *pextlen = gcb.gidcnt;
 808     ret = 1;
 809  end:
 810     OPENSSL_free(gcb.gid_arr);
 811     return ret;
 812 }
 813
 814 /* Check a group id matches preferences */
 815 int tls1_check_group_id(SSL *s, uint16_t group_id, int check_own_groups)
 816     {
 817     const uint16_t *groups;
 818     size_t groups_len;
 819
 820     if (group_id == 0)
 821         return 0;
 822
 823     /* Check for Suite B compliance */
 824     if (tls1_suiteb(s) && s->s3.tmp.new_cipher != NULL) {
 825         unsigned long cid = s->s3.tmp.new_cipher->id;
 826
 827         if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256) {
 828             if (group_id != OSSL_TLS_GROUP_ID_secp256r1)
 829                 return 0;
 830         } else if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384) {
 831             if (group_id != OSSL_TLS_GROUP_ID_secp384r1)
 832                 return 0;
 833         } else {
 834             /* Should never happen */
 835             return 0;
 836         }
 837     }
 838
 839     if (check_own_groups) {
 840         /* Check group is one of our preferences */
 841         tls1_get_supported_groups(s, &groups, &groups_len);
 842         if (!tls1_in_list(group_id, groups, groups_len))
 843             return 0;
 844     }
 845
 846     if (!tls_group_allowed(s, group_id, SSL_SECOP_CURVE_CHECK))
 847         return 0;
 848
 849     /* For clients, nothing more to check */
 850     if (!s->server)
 851         return 1;
 852
 853     /* Check group is one of peers preferences */
 854     tls1_get_peer_groups(s, &groups, &groups_len);
 855
 856     /*
 857      * RFC 4492 does not require the supported elliptic curves extension
 858      * so if it is not sent we can just choose any curve.
 859      * It is invalid to send an empty list in the supported groups
 860      * extension, so groups_len == 0 always means no extension.
 861      */
 862     if (groups_len == 0)
 863             return 1;
 864     return tls1_in_list(group_id, groups, groups_len);
 865 }
 866
 867 void tls1_get_formatlist(SSL *s, const unsigned char **pformats,
 868                          size_t *num_formats)
 869 {
 870     /*
 871      * If we have a custom point format list use it otherwise use default
 872      */
 873     if (s->ext.ecpointformats) {
 874         *pformats = s->ext.ecpointformats;
 875         *num_formats = s->ext.ecpointformats_len;
 876     } else {
 877         *pformats = ecformats_default;
 878         /* For Suite B we don't support char2 fields */
 879         if (tls1_suiteb(s))
 880             *num_formats = sizeof(ecformats_default) - 1;
 881         else
 882             *num_formats = sizeof(ecformats_default);
 883     }
 884 }
 885
 886 /* Check a key is compatible with compression extension */
 887 static int tls1_check_pkey_comp(SSL *s, EVP_PKEY *pkey)
 888 {
 889     unsigned char comp_id;
 890     size_t i;
 891     int point_conv;
 892
 893     /* If not an EC key nothing to check */
 894     if (!EVP_PKEY_is_a(pkey, "EC"))
 895         return 1;
 896
 897
 898     /* Get required compression id */
 899     point_conv = EVP_PKEY_get_ec_point_conv_form(pkey);
 900     if (point_conv == 0)
 901         return 0;
 902     if (point_conv == POINT_CONVERSION_UNCOMPRESSED) {
 903             comp_id = TLSEXT_ECPOINTFORMAT_uncompressed;
 904     } else if (SSL_IS_TLS13(s)) {
 905         /*
 906          * ec_point_formats extension is not used in TLSv1.3 so we ignore
 907          * this check.
 908          */
 909         return 1;
 910     } else {
 911         int field_type = EVP_PKEY_get_field_type(pkey);
 912
 913         if (field_type == NID_X9_62_prime_field)
 914             comp_id = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime;
 915         else if (field_type == NID_X9_62_characteristic_two_field)
 916             comp_id = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2;
 917         else
 918             return 0;
 919     }
 920     /*
 921      * If point formats extension present check it, otherwise everything is
 922      * supported (see RFC4492).
 923      */
 924     if (s->ext.peer_ecpointformats == NULL)
 925         return 1;
 926
 927     for (i = 0; i < s->ext.peer_ecpointformats_len; i++) {
 928         if (s->ext.peer_ecpointformats[i] == comp_id)
 929             return 1;
 930     }
 931     return 0;
 932 }
 933
 934 /* Return group id of a key */
 935 static uint16_t tls1_get_group_id(EVP_PKEY *pkey)
 936 {
 937     int curve_nid = ssl_get_EC_curve_nid(pkey);
 938
 939     if (curve_nid == NID_undef)
 940         return 0;
 941     return tls1_nid2group_id(curve_nid);
 942 }
 943
 944 /*
 945  * Check cert parameters compatible with extensions: currently just checks EC
 946  * certificates have compatible curves and compression.
 947  */
 948 static int tls1_check_cert_param(SSL *s, X509 *x, int check_ee_md)
 949 {
 950     uint16_t group_id;
 951     EVP_PKEY *pkey;
 952     pkey = X509_get0_pubkey(x);
 953     if (pkey == NULL)
 954         return 0;
 955     /* If not EC nothing to do */
 956     if (!EVP_PKEY_is_a(pkey, "EC"))
 957         return 1;
 958     /* Check compression */
 959     if (!tls1_check_pkey_comp(s, pkey))
 960         return 0;
 961     group_id = tls1_get_group_id(pkey);
 962     /*
 963      * For a server we allow the certificate to not be in our list of supported
 964      * groups.
 965      */
 966     if (!tls1_check_group_id(s, group_id, !s->server))
 967         return 0;
 968     /*
 969      * Special case for suite B. We *MUST* sign using SHA256+P-256 or
 970      * SHA384+P-384.
 971      */
 972     if (check_ee_md && tls1_suiteb(s)) {
 973         int check_md;
 974         size_t i;
 975
 976         /* Check to see we have necessary signing algorithm */
 977         if (group_id == OSSL_TLS_GROUP_ID_secp256r1)
 978             check_md = NID_ecdsa_with_SHA256;
 979         else if (group_id == OSSL_TLS_GROUP_ID_secp384r1)
 980             check_md = NID_ecdsa_with_SHA384;
 981         else
 982             return 0;           /* Should never happen */
 983         for (i = 0; i < s->shared_sigalgslen; i++) {
 984             if (check_md == s->shared_sigalgs[i]->sigandhash)
 985                 return 1;;
 986         }
 987         return 0;
 988     }
 989     return 1;
 990 }
 991
 992 /*
 993  * tls1_check_ec_tmp_key - Check EC temporary key compatibility
 994  * @s: SSL connection
 995  * @cid: Cipher ID we're considering using
 996  *
 997  * Checks that the kECDHE cipher suite we're considering using
 998  * is compatible with the client extensions.
 999  *
1000  * Returns 0 when the cipher can't be used or 1 when it can.
1001  */
1002 int tls1_check_ec_tmp_key(SSL *s, unsigned long cid)
1003 {
1004     /* If not Suite B just need a shared group */
1005     if (!tls1_suiteb(s))
1006         return tls1_shared_group(s, 0) != 0;
1007     /*
1008      * If Suite B, AES128 MUST use P-256 and AES256 MUST use P-384, no other
1009      * curves permitted.
1010      */
1011     if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)
1012         return tls1_check_group_id(s, OSSL_TLS_GROUP_ID_secp256r1, 1);
1013     if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384)
1014         return tls1_check_group_id(s, OSSL_TLS_GROUP_ID_secp384r1, 1);
1015
1016     return 0;
1017 }
1018
1019 /* Default sigalg schemes */
1020 static const uint16_t tls12_sigalgs[] = {
1021     TLSEXT_SIGALG_ecdsa_secp256r1_sha256,
1022     TLSEXT_SIGALG_ecdsa_secp384r1_sha384,
1023     TLSEXT_SIGALG_ecdsa_secp521r1_sha512,
1024     TLSEXT_SIGALG_ed25519,
1025     TLSEXT_SIGALG_ed448,
1026     TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256,
1027     TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384,
1028     TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512,
1029
1030     TLSEXT_SIGALG_rsa_pss_pss_sha256,
1031     TLSEXT_SIGALG_rsa_pss_pss_sha384,
1032     TLSEXT_SIGALG_rsa_pss_pss_sha512,
1033     TLSEXT_SIGALG_rsa_pss_rsae_sha256,
1034     TLSEXT_SIGALG_rsa_pss_rsae_sha384,
1035     TLSEXT_SIGALG_rsa_pss_rsae_sha512,
1036
1037     TLSEXT_SIGALG_rsa_pkcs1_sha256,
1038     TLSEXT_SIGALG_rsa_pkcs1_sha384,
1039     TLSEXT_SIGALG_rsa_pkcs1_sha512,
1040
1041     TLSEXT_SIGALG_ecdsa_sha224,
1042     TLSEXT_SIGALG_ecdsa_sha1,
1043
1044     TLSEXT_SIGALG_rsa_pkcs1_sha224,
1045     TLSEXT_SIGALG_rsa_pkcs1_sha1,
1046
1047     TLSEXT_SIGALG_dsa_sha224,
1048     TLSEXT_SIGALG_dsa_sha1,
1049
1050     TLSEXT_SIGALG_dsa_sha256,
1051     TLSEXT_SIGALG_dsa_sha384,
1052     TLSEXT_SIGALG_dsa_sha512,
1053
1054 #ifndef OPENSSL_NO_GOST
1055     TLSEXT_SIGALG_gostr34102012_256_intrinsic,
1056     TLSEXT_SIGALG_gostr34102012_512_intrinsic,
1057     TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256,
1058     TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512,
1059     TLSEXT_SIGALG_gostr34102001_gostr3411,
1060 #endif
1061 };
1062
1063
1064 static const uint16_t suiteb_sigalgs[] = {
1065     TLSEXT_SIGALG_ecdsa_secp256r1_sha256,
1066     TLSEXT_SIGALG_ecdsa_secp384r1_sha384
1067 };
1068
1069 static const SIGALG_LOOKUP sigalg_lookup_tbl[] = {
1070     {"ecdsa_secp256r1_sha256", TLSEXT_SIGALG_ecdsa_secp256r1_sha256,
1071      NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
1072      NID_ecdsa_with_SHA256, NID_X9_62_prime256v1, 1},
1073     {"ecdsa_secp384r1_sha384", TLSEXT_SIGALG_ecdsa_secp384r1_sha384,
1074      NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
1075      NID_ecdsa_with_SHA384, NID_secp384r1, 1},
1076     {"ecdsa_secp521r1_sha512", TLSEXT_SIGALG_ecdsa_secp521r1_sha512,
1077      NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
1078      NID_ecdsa_with_SHA512, NID_secp521r1, 1},
1079     {"ed25519", TLSEXT_SIGALG_ed25519,
1080      NID_undef, -1, EVP_PKEY_ED25519, SSL_PKEY_ED25519,
1081      NID_undef, NID_undef, 1},
1082     {"ed448", TLSEXT_SIGALG_ed448,
1083      NID_undef, -1, EVP_PKEY_ED448, SSL_PKEY_ED448,
1084      NID_undef, NID_undef, 1},
1085     {NULL, TLSEXT_SIGALG_ecdsa_sha224,
1086      NID_sha224, SSL_MD_SHA224_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
1087      NID_ecdsa_with_SHA224, NID_undef, 1},
1088     {NULL, TLSEXT_SIGALG_ecdsa_sha1,
1089      NID_sha1, SSL_MD_SHA1_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
1090      NID_ecdsa_with_SHA1, NID_undef, 1},
1091     {"ecdsa_brainpoolP256r1_sha256", TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256,
1092      NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
1093      NID_ecdsa_with_SHA256, NID_brainpoolP256r1, 1},
1094     {"ecdsa_brainpoolP384r1_sha384", TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384,
1095      NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
1096      NID_ecdsa_with_SHA384, NID_brainpoolP384r1, 1},
1097     {"ecdsa_brainpoolP512r1_sha512", TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512,
1098      NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
1099      NID_ecdsa_with_SHA512, NID_brainpoolP512r1, 1},
1100     {"rsa_pss_rsae_sha256", TLSEXT_SIGALG_rsa_pss_rsae_sha256,
1101      NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA,
1102      NID_undef, NID_undef, 1},
1103     {"rsa_pss_rsae_sha384", TLSEXT_SIGALG_rsa_pss_rsae_sha384,
1104      NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA,
1105      NID_undef, NID_undef, 1},
1106     {"rsa_pss_rsae_sha512", TLSEXT_SIGALG_rsa_pss_rsae_sha512,
1107      NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA,
1108      NID_undef, NID_undef, 1},
1109     {"rsa_pss_pss_sha256", TLSEXT_SIGALG_rsa_pss_pss_sha256,
1110      NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA_PSS_SIGN,
1111      NID_undef, NID_undef, 1},
1112     {"rsa_pss_pss_sha384", TLSEXT_SIGALG_rsa_pss_pss_sha384,
1113      NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA_PSS_SIGN,
1114      NID_undef, NID_undef, 1},
1115     {"rsa_pss_pss_sha512", TLSEXT_SIGALG_rsa_pss_pss_sha512,
1116      NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA_PSS_SIGN,
1117      NID_undef, NID_undef, 1},
1118     {"rsa_pkcs1_sha256", TLSEXT_SIGALG_rsa_pkcs1_sha256,
1119      NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,
1120      NID_sha256WithRSAEncryption, NID_undef, 1},
1121     {"rsa_pkcs1_sha384", TLSEXT_SIGALG_rsa_pkcs1_sha384,
1122      NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,
1123      NID_sha384WithRSAEncryption, NID_undef, 1},
1124     {"rsa_pkcs1_sha512", TLSEXT_SIGALG_rsa_pkcs1_sha512,
1125      NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,
1126      NID_sha512WithRSAEncryption, NID_undef, 1},
1127     {"rsa_pkcs1_sha224", TLSEXT_SIGALG_rsa_pkcs1_sha224,
1128      NID_sha224, SSL_MD_SHA224_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,
1129      NID_sha224WithRSAEncryption, NID_undef, 1},
1130     {"rsa_pkcs1_sha1", TLSEXT_SIGALG_rsa_pkcs1_sha1,
1131      NID_sha1, SSL_MD_SHA1_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,
1132      NID_sha1WithRSAEncryption, NID_undef, 1},
1133     {NULL, TLSEXT_SIGALG_dsa_sha256,
1134      NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,
1135      NID_dsa_with_SHA256, NID_undef, 1},
1136     {NULL, TLSEXT_SIGALG_dsa_sha384,
1137      NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,
1138      NID_undef, NID_undef, 1},
1139     {NULL, TLSEXT_SIGALG_dsa_sha512,
1140      NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,
1141      NID_undef, NID_undef, 1},
1142     {NULL, TLSEXT_SIGALG_dsa_sha224,
1143      NID_sha224, SSL_MD_SHA224_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,
1144      NID_undef, NID_undef, 1},
1145     {NULL, TLSEXT_SIGALG_dsa_sha1,
1146      NID_sha1, SSL_MD_SHA1_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,
1147      NID_dsaWithSHA1, NID_undef, 1},
1148 #ifndef OPENSSL_NO_GOST
1149     {NULL, TLSEXT_SIGALG_gostr34102012_256_intrinsic,
1150      NID_id_GostR3411_2012_256, SSL_MD_GOST12_256_IDX,
1151      NID_id_GostR3410_2012_256, SSL_PKEY_GOST12_256,
1152      NID_undef, NID_undef, 1},
1153     {NULL, TLSEXT_SIGALG_gostr34102012_512_intrinsic,
1154      NID_id_GostR3411_2012_512, SSL_MD_GOST12_512_IDX,
1155      NID_id_GostR3410_2012_512, SSL_PKEY_GOST12_512,
1156      NID_undef, NID_undef, 1},
1157     {NULL, TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256,
1158      NID_id_GostR3411_2012_256, SSL_MD_GOST12_256_IDX,
1159      NID_id_GostR3410_2012_256, SSL_PKEY_GOST12_256,
1160      NID_undef, NID_undef, 1},
1161     {NULL, TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512,
1162      NID_id_GostR3411_2012_512, SSL_MD_GOST12_512_IDX,
1163      NID_id_GostR3410_2012_512, SSL_PKEY_GOST12_512,
1164      NID_undef, NID_undef, 1},
1165     {NULL, TLSEXT_SIGALG_gostr34102001_gostr3411,
1166      NID_id_GostR3411_94, SSL_MD_GOST94_IDX,
1167      NID_id_GostR3410_2001, SSL_PKEY_GOST01,
1168      NID_undef, NID_undef, 1}
1169 #endif
1170 };
1171 /* Legacy sigalgs for TLS < 1.2 RSA TLS signatures */
1172 static const SIGALG_LOOKUP legacy_rsa_sigalg = {
1173     "rsa_pkcs1_md5_sha1", 0,
1174      NID_md5_sha1, SSL_MD_MD5_SHA1_IDX,
1175      EVP_PKEY_RSA, SSL_PKEY_RSA,
1176      NID_undef, NID_undef, 1
1177 };
1178
1179 /*
1180  * Default signature algorithm values used if signature algorithms not present.
1181  * From RFC5246. Note: order must match certificate index order.
1182  */
1183 static const uint16_t tls_default_sigalg[] = {
1184     TLSEXT_SIGALG_rsa_pkcs1_sha1, /* SSL_PKEY_RSA */
1185     0, /* SSL_PKEY_RSA_PSS_SIGN */
1186     TLSEXT_SIGALG_dsa_sha1, /* SSL_PKEY_DSA_SIGN */
1187     TLSEXT_SIGALG_ecdsa_sha1, /* SSL_PKEY_ECC */
1188     TLSEXT_SIGALG_gostr34102001_gostr3411, /* SSL_PKEY_GOST01 */
1189     TLSEXT_SIGALG_gostr34102012_256_intrinsic, /* SSL_PKEY_GOST12_256 */
1190     TLSEXT_SIGALG_gostr34102012_512_intrinsic, /* SSL_PKEY_GOST12_512 */
1191     0, /* SSL_PKEY_ED25519 */
1192     0, /* SSL_PKEY_ED448 */
1193 };
1194
1195 int ssl_setup_sig_algs(SSL_CTX *ctx)
1196 {
1197     size_t i;
1198     const SIGALG_LOOKUP *lu;
1199     SIGALG_LOOKUP *cache
1200         = OPENSSL_malloc(sizeof(*lu) * OSSL_NELEM(sigalg_lookup_tbl));
1201     EVP_PKEY *tmpkey = EVP_PKEY_new();
1202     int ret = 0;
1203
1204     if (cache == NULL || tmpkey == NULL)
1205         goto err;
1206
1207     ERR_set_mark();
1208     for (i = 0, lu = sigalg_lookup_tbl;
1209          i < OSSL_NELEM(sigalg_lookup_tbl); lu++, i++) {
1210         EVP_PKEY_CTX *pctx;
1211
1212         cache[i] = *lu;
1213
1214         /*
1215          * Check hash is available.
1216          * This test is not perfect. A provider could have support
1217          * for a signature scheme, but not a particular hash. However the hash
1218          * could be available from some other loaded provider. In that case it
1219          * could be that the signature is available, and the hash is available
1220          * independently - but not as a combination. We ignore this for now.
1221          */
1222         if (lu->hash != NID_undef
1223                 && ctx->ssl_digest_methods[lu->hash_idx] == NULL) {
1224             cache[i].enabled = 0;
1225             continue;
1226         }
1227
1228         if (!EVP_PKEY_set_type(tmpkey, lu->sig)) {
1229             cache[i].enabled = 0;
1230             continue;
1231         }
1232         pctx = EVP_PKEY_CTX_new_from_pkey(ctx->libctx, tmpkey, ctx->propq);
1233         /* If unable to create pctx we assume the sig algorithm is unavailable */
1234         if (pctx == NULL)
1235             cache[i].enabled = 0;
1236         EVP_PKEY_CTX_free(pctx);
1237     }
1238     ERR_pop_to_mark();
1239     ctx->sigalg_lookup_cache = cache;
1240     cache = NULL;
1241
1242     ret = 1;
1243  err:
1244     OPENSSL_free(cache);
1245     EVP_PKEY_free(tmpkey);
1246     return ret;
1247 }
1248
1249 /* Lookup TLS signature algorithm */
1250 static const SIGALG_LOOKUP *tls1_lookup_sigalg(const SSL *s, uint16_t sigalg)
1251 {
1252     size_t i;
1253     const SIGALG_LOOKUP *lu;
1254
1255     for (i = 0, lu = s->ctx->sigalg_lookup_cache;
1256          /* cache should have the same number of elements as sigalg_lookup_tbl */
1257          i < OSSL_NELEM(sigalg_lookup_tbl);
1258          lu++, i++) {
1259         if (lu->sigalg == sigalg) {
1260             if (!lu->enabled)
1261                 return NULL;
1262             return lu;
1263         }
1264     }
1265     return NULL;
1266 }
1267 /* Lookup hash: return 0 if invalid or not enabled */
1268 int tls1_lookup_md(SSL_CTX *ctx, const SIGALG_LOOKUP *lu, const EVP_MD **pmd)
1269 {
1270     const EVP_MD *md;
1271     if (lu == NULL)
1272         return 0;
1273     /* lu->hash == NID_undef means no associated digest */
1274     if (lu->hash == NID_undef) {
1275         md = NULL;
1276     } else {
1277         md = ssl_md(ctx, lu->hash_idx);
1278         if (md == NULL)
1279             return 0;
1280     }
1281     if (pmd)
1282         *pmd = md;
1283     return 1;
1284 }
1285
1286 /*
1287  * Check if key is large enough to generate RSA-PSS signature.
1288  *
1289  * The key must greater than or equal to 2 * hash length + 2.
1290  * SHA512 has a hash length of 64 bytes, which is incompatible
1291  * with a 128 byte (1024 bit) key.
1292  */
1293 #define RSA_PSS_MINIMUM_KEY_SIZE(md) (2 * EVP_MD_get_size(md) + 2)
1294 static int rsa_pss_check_min_key_size(SSL_CTX *ctx, const EVP_PKEY *pkey,
1295                                       const SIGALG_LOOKUP *lu)
1296 {
1297     const EVP_MD *md;
1298
1299     if (pkey == NULL)
1300         return 0;
1301     if (!tls1_lookup_md(ctx, lu, &md) || md == NULL)
1302         return 0;
1303     if (EVP_PKEY_get_size(pkey) < RSA_PSS_MINIMUM_KEY_SIZE(md))
1304         return 0;
1305     return 1;
1306 }
1307
1308 /*
1309  * Returns a signature algorithm when the peer did not send a list of supported
1310  * signature algorithms. The signature algorithm is fixed for the certificate
1311  * type. |idx| is a certificate type index (SSL_PKEY_*). When |idx| is -1 the
1312  * certificate type from |s| will be used.
1313  * Returns the signature algorithm to use, or NULL on error.
1314  */
1315 static const SIGALG_LOOKUP *tls1_get_legacy_sigalg(const SSL *s, int idx)
1316 {
1317     if (idx == -1) {
1318         if (s->server) {
1319             size_t i;
1320
1321             /* Work out index corresponding to ciphersuite */
1322             for (i = 0; i < SSL_PKEY_NUM; i++) {
1323                 const SSL_CERT_LOOKUP *clu = ssl_cert_lookup_by_idx(i);
1324
1325                 if (clu == NULL)
1326                     continue;
1327                 if (clu->amask & s->s3.tmp.new_cipher->algorithm_auth) {
1328                     idx = i;
1329                     break;
1330                 }
1331             }
1332
1333             /*
1334              * Some GOST ciphersuites allow more than one signature algorithms
1335              * */
1336             if (idx == SSL_PKEY_GOST01 && s->s3.tmp.new_cipher->algorithm_auth != SSL_aGOST01) {
1337                 int real_idx;
1338
1339                 for (real_idx = SSL_PKEY_GOST12_512; real_idx >= SSL_PKEY_GOST01;
1340                      real_idx--) {
1341                     if (s->cert->pkeys[real_idx].privatekey != NULL) {
1342                         idx = real_idx;
1343                         break;
1344                     }
1345                 }
1346             }
1347             /*
1348              * As both SSL_PKEY_GOST12_512 and SSL_PKEY_GOST12_256 indices can be used
1349              * with new (aGOST12-only) ciphersuites, we should find out which one is available really.
1350              */
1351             else if (idx == SSL_PKEY_GOST12_256) {
1352                 int real_idx;
1353
1354                 for (real_idx = SSL_PKEY_GOST12_512; real_idx >= SSL_PKEY_GOST12_256;
1355                      real_idx--) {
1356                      if (s->cert->pkeys[real_idx].privatekey != NULL) {
1357                          idx = real_idx;
1358                          break;
1359                      }
1360                 }
1361             }
1362         } else {
1363             idx = s->cert->key - s->cert->pkeys;
1364         }
1365     }
1366     if (idx < 0 || idx >= (int)OSSL_NELEM(tls_default_sigalg))
1367         return NULL;
1368     if (SSL_USE_SIGALGS(s) || idx != SSL_PKEY_RSA) {
1369         const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(s, tls_default_sigalg[idx]);
1370
1371         if (lu == NULL)
1372             return NULL;
1373         if (!tls1_lookup_md(s->ctx, lu, NULL))
1374             return NULL;
1375         if (!tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SUPPORTED, lu))
1376             return NULL;
1377         return lu;
1378     }
1379     if (!tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SUPPORTED, &legacy_rsa_sigalg))
1380         return NULL;
1381     return &legacy_rsa_sigalg;
1382 }
1383 /* Set peer sigalg based key type */
1384 int tls1_set_peer_legacy_sigalg(SSL *s, const EVP_PKEY *pkey)
1385 {
1386     size_t idx;
1387     const SIGALG_LOOKUP *lu;
1388
1389     if (ssl_cert_lookup_by_pkey(pkey, &idx) == NULL)
1390         return 0;
1391     lu = tls1_get_legacy_sigalg(s, idx);
1392     if (lu == NULL)
1393         return 0;
1394     s->s3.tmp.peer_sigalg = lu;
1395     return 1;
1396 }
1397
1398 size_t tls12_get_psigalgs(SSL *s, int sent, const uint16_t **psigs)
1399 {
1400     /*
1401      * If Suite B mode use Suite B sigalgs only, ignore any other
1402      * preferences.
1403      */
1404     switch (tls1_suiteb(s)) {
1405     case SSL_CERT_FLAG_SUITEB_128_LOS:
1406         *psigs = suiteb_sigalgs;
1407         return OSSL_NELEM(suiteb_sigalgs);
1408
1409     case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY:
1410         *psigs = suiteb_sigalgs;
1411         return 1;
1412
1413     case SSL_CERT_FLAG_SUITEB_192_LOS:
1414         *psigs = suiteb_sigalgs + 1;
1415         return 1;
1416     }
1417     /*
1418      *  We use client_sigalgs (if not NULL) if we're a server
1419      *  and sending a certificate request or if we're a client and
1420      *  determining which shared algorithm to use.
1421      */
1422     if ((s->server == sent) && s->cert->client_sigalgs != NULL) {
1423         *psigs = s->cert->client_sigalgs;
1424         return s->cert->client_sigalgslen;
1425     } else if (s->cert->conf_sigalgs) {
1426         *psigs = s->cert->conf_sigalgs;
1427         return s->cert->conf_sigalgslen;
1428     } else {
1429         *psigs = tls12_sigalgs;
1430         return OSSL_NELEM(tls12_sigalgs);
1431     }
1432 }
1433
1434 /*
1435  * Called by servers only. Checks that we have a sig alg that supports the
1436  * specified EC curve.
1437  */
1438 int tls_check_sigalg_curve(const SSL *s, int curve)
1439 {
1440    const uint16_t *sigs;
1441    size_t siglen, i;
1442
1443     if (s->cert->conf_sigalgs) {
1444         sigs = s->cert->conf_sigalgs;
1445         siglen = s->cert->conf_sigalgslen;
1446     } else {
1447         sigs = tls12_sigalgs;
1448         siglen = OSSL_NELEM(tls12_sigalgs);
1449     }
1450
1451     for (i = 0; i < siglen; i++) {
1452         const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(s, sigs[i]);
1453
1454         if (lu == NULL)
1455             continue;
1456         if (lu->sig == EVP_PKEY_EC
1457                 && lu->curve != NID_undef
1458                 && curve == lu->curve)
1459             return 1;
1460     }
1461
1462     return 0;
1463 }
1464
1465 /*
1466  * Return the number of security bits for the signature algorithm, or 0 on
1467  * error.
1468  */
1469 static int sigalg_security_bits(SSL_CTX *ctx, const SIGALG_LOOKUP *lu)
1470 {
1471     const EVP_MD *md = NULL;
1472     int secbits = 0;
1473
1474     if (!tls1_lookup_md(ctx, lu, &md))
1475         return 0;
1476     if (md != NULL)
1477     {
1478         int md_type = EVP_MD_get_type(md);
1479
1480         /* Security bits: half digest bits */
1481         secbits = EVP_MD_get_size(md) * 4;
1482         /*
1483          * SHA1 and MD5 are known to be broken. Reduce security bits so that
1484          * they're no longer accepted at security level 1. The real values don't
1485          * really matter as long as they're lower than 80, which is our
1486          * security level 1.
1487          * https://eprint.iacr.org/2020/014 puts a chosen-prefix attack for
1488          * SHA1 at 2^63.4 and MD5+SHA1 at 2^67.2
1489          * https://documents.epfl.ch/users/l/le/lenstra/public/papers/lat.pdf
1490          * puts a chosen-prefix attack for MD5 at 2^39.
1491          */
1492         if (md_type == NID_sha1)
1493             secbits = 64;
1494         else if (md_type == NID_md5_sha1)
1495             secbits = 67;
1496         else if (md_type == NID_md5)
1497             secbits = 39;
1498     } else {
1499         /* Values from https://tools.ietf.org/html/rfc8032#section-8.5 */
1500         if (lu->sigalg == TLSEXT_SIGALG_ed25519)
1501             secbits = 128;
1502         else if (lu->sigalg == TLSEXT_SIGALG_ed448)
1503             secbits = 224;
1504     }
1505     return secbits;
1506 }
1507
1508 /*
1509  * Check signature algorithm is consistent with sent supported signature
1510  * algorithms and if so set relevant digest and signature scheme in
1511  * s.
1512  */
1513 int tls12_check_peer_sigalg(SSL *s, uint16_t sig, EVP_PKEY *pkey)
1514 {
1515     const uint16_t *sent_sigs;
1516     const EVP_MD *md = NULL;
1517     char sigalgstr[2];
1518     size_t sent_sigslen, i, cidx;
1519     int pkeyid = -1;
1520     const SIGALG_LOOKUP *lu;
1521     int secbits = 0;
1522
1523     pkeyid = EVP_PKEY_get_id(pkey);
1524     /* Should never happen */
1525     if (pkeyid == -1)
1526         return -1;
1527     if (SSL_IS_TLS13(s)) {
1528         /* Disallow DSA for TLS 1.3 */
1529         if (pkeyid == EVP_PKEY_DSA) {
1530             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_SIGNATURE_TYPE);
1531             return 0;
1532         }
1533         /* Only allow PSS for TLS 1.3 */
1534         if (pkeyid == EVP_PKEY_RSA)
1535             pkeyid = EVP_PKEY_RSA_PSS;
1536     }
1537     lu = tls1_lookup_sigalg(s, sig);
1538     /*
1539      * Check sigalgs is known. Disallow SHA1/SHA224 with TLS 1.3. Check key type
1540      * is consistent with signature: RSA keys can be used for RSA-PSS
1541      */
1542     if (lu == NULL
1543         || (SSL_IS_TLS13(s) && (lu->hash == NID_sha1 || lu->hash == NID_sha224))
1544         || (pkeyid != lu->sig
1545         && (lu->sig != EVP_PKEY_RSA_PSS || pkeyid != EVP_PKEY_RSA))) {
1546         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_SIGNATURE_TYPE);
1547         return 0;
1548     }
1549     /* Check the sigalg is consistent with the key OID */
1550     if (!ssl_cert_lookup_by_nid(EVP_PKEY_get_id(pkey), &cidx)
1551             || lu->sig_idx != (int)cidx) {
1552         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_SIGNATURE_TYPE);
1553         return 0;
1554     }
1555
1556     if (pkeyid == EVP_PKEY_EC) {
1557
1558         /* Check point compression is permitted */
1559         if (!tls1_check_pkey_comp(s, pkey)) {
1560             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
1561                      SSL_R_ILLEGAL_POINT_COMPRESSION);
1562             return 0;
1563         }
1564
1565         /* For TLS 1.3 or Suite B check curve matches signature algorithm */
1566         if (SSL_IS_TLS13(s) || tls1_suiteb(s)) {
1567             int curve = ssl_get_EC_curve_nid(pkey);
1568
1569             if (lu->curve != NID_undef && curve != lu->curve) {
1570                 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CURVE);
1571                 return 0;
1572             }
1573         }
1574         if (!SSL_IS_TLS13(s)) {
1575             /* Check curve matches extensions */
1576             if (!tls1_check_group_id(s, tls1_get_group_id(pkey), 1)) {
1577                 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CURVE);
1578                 return 0;
1579             }
1580             if (tls1_suiteb(s)) {
1581                 /* Check sigalg matches a permissible Suite B value */
1582                 if (sig != TLSEXT_SIGALG_ecdsa_secp256r1_sha256
1583                     && sig != TLSEXT_SIGALG_ecdsa_secp384r1_sha384) {
1584                     SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
1585                              SSL_R_WRONG_SIGNATURE_TYPE);
1586                     return 0;
1587                 }
1588             }
1589         }
1590     } else if (tls1_suiteb(s)) {
1591         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_WRONG_SIGNATURE_TYPE);
1592         return 0;
1593     }
1594
1595     /* Check signature matches a type we sent */
1596     sent_sigslen = tls12_get_psigalgs(s, 1, &sent_sigs);
1597     for (i = 0; i < sent_sigslen; i++, sent_sigs++) {
1598         if (sig == *sent_sigs)
1599             break;
1600     }
1601     /* Allow fallback to SHA1 if not strict mode */
1602     if (i == sent_sigslen && (lu->hash != NID_sha1
1603         || s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)) {
1604         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_WRONG_SIGNATURE_TYPE);
1605         return 0;
1606     }
1607     if (!tls1_lookup_md(s->ctx, lu, &md)) {
1608         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_UNKNOWN_DIGEST);
1609         return 0;
1610     }
1611     /*
1612      * Make sure security callback allows algorithm. For historical
1613      * reasons we have to pass the sigalg as a two byte char array.
1614      */
1615     sigalgstr[0] = (sig >> 8) & 0xff;
1616     sigalgstr[1] = sig & 0xff;
1617     secbits = sigalg_security_bits(s->ctx, lu);
1618     if (secbits == 0 ||
1619         !ssl_security(s, SSL_SECOP_SIGALG_CHECK, secbits,
1620                       md != NULL ? EVP_MD_get_type(md) : NID_undef,
1621                       (void *)sigalgstr)) {
1622         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_WRONG_SIGNATURE_TYPE);
1623         return 0;
1624     }
1625     /* Store the sigalg the peer uses */
1626     s->s3.tmp.peer_sigalg = lu;
1627     return 1;
1628 }
1629
1630 int SSL_get_peer_signature_type_nid(const SSL *s, int *pnid)
1631 {
1632     if (s->s3.tmp.peer_sigalg == NULL)
1633         return 0;
1634     *pnid = s->s3.tmp.peer_sigalg->sig;
1635     return 1;
1636 }
1637
1638 int SSL_get_signature_type_nid(const SSL *s, int *pnid)
1639 {
1640     if (s->s3.tmp.sigalg == NULL)
1641         return 0;
1642     *pnid = s->s3.tmp.sigalg->sig;
1643     return 1;
1644 }
1645
1646 /*
1647  * Set a mask of disabled algorithms: an algorithm is disabled if it isn't
1648  * supported, doesn't appear in supported signature algorithms, isn't supported
1649  * by the enabled protocol versions or by the security level.
1650  *
1651  * This function should only be used for checking which ciphers are supported
1652  * by the client.
1653  *
1654  * Call ssl_cipher_disabled() to check that it's enabled or not.
1655  */
1656 int ssl_set_client_disabled(SSL *s)
1657 {
1658     s->s3.tmp.mask_a = 0;
1659     s->s3.tmp.mask_k = 0;
1660     ssl_set_sig_mask(&s->s3.tmp.mask_a, s, SSL_SECOP_SIGALG_MASK);
1661     if (ssl_get_min_max_version(s, &s->s3.tmp.min_ver,
1662                                 &s->s3.tmp.max_ver, NULL) != 0)
1663         return 0;
1664 #ifndef OPENSSL_NO_PSK
1665     /* with PSK there must be client callback set */
1666     if (!s->psk_client_callback) {
1667         s->s3.tmp.mask_a |= SSL_aPSK;
1668         s->s3.tmp.mask_k |= SSL_PSK;
1669     }
1670 #endif                          /* OPENSSL_NO_PSK */
1671 #ifndef OPENSSL_NO_SRP
1672     if (!(s->srp_ctx.srp_Mask & SSL_kSRP)) {
1673         s->s3.tmp.mask_a |= SSL_aSRP;
1674         s->s3.tmp.mask_k |= SSL_kSRP;
1675     }
1676 #endif
1677     return 1;
1678 }
1679
1680 /*
1681  * ssl_cipher_disabled - check that a cipher is disabled or not
1682  * @s: SSL connection that you want to use the cipher on
1683  * @c: cipher to check
1684  * @op: Security check that you want to do
1685  * @ecdhe: If set to 1 then TLSv1 ECDHE ciphers are also allowed in SSLv3
1686  *
1687  * Returns 1 when it's disabled, 0 when enabled.
1688  */
1689 int ssl_cipher_disabled(const SSL *s, const SSL_CIPHER *c, int op, int ecdhe)
1690 {
1691     if (c->algorithm_mkey & s->s3.tmp.mask_k
1692         || c->algorithm_auth & s->s3.tmp.mask_a)
1693         return 1;
1694     if (s->s3.tmp.max_ver == 0)
1695         return 1;
1696     if (!SSL_IS_DTLS(s)) {
1697         int min_tls = c->min_tls;
1698
1699         /*
1700          * For historical reasons we will allow ECHDE to be selected by a server
1701          * in SSLv3 if we are a client
1702          */
1703         if (min_tls == TLS1_VERSION && ecdhe
1704                 && (c->algorithm_mkey & (SSL_kECDHE | SSL_kECDHEPSK)) != 0)
1705             min_tls = SSL3_VERSION;
1706
1707         if ((min_tls > s->s3.tmp.max_ver) || (c->max_tls < s->s3.tmp.min_ver))
1708             return 1;
1709     }
1710     if (SSL_IS_DTLS(s) && (DTLS_VERSION_GT(c->min_dtls, s->s3.tmp.max_ver)
1711                            || DTLS_VERSION_LT(c->max_dtls, s->s3.tmp.min_ver)))
1712         return 1;
1713
1714     return !ssl_security(s, op, c->strength_bits, 0, (void *)c);
1715 }
1716
1717 int tls_use_ticket(SSL *s)
1718 {
1719     if ((s->options & SSL_OP_NO_TICKET))
1720         return 0;
1721     return ssl_security(s, SSL_SECOP_TICKET, 0, 0, NULL);
1722 }
1723
1724 int tls1_set_server_sigalgs(SSL *s)
1725 {
1726     size_t i;
1727
1728     /* Clear any shared signature algorithms */
1729     OPENSSL_free(s->shared_sigalgs);
1730     s->shared_sigalgs = NULL;
1731     s->shared_sigalgslen = 0;
1732     /* Clear certificate validity flags */
1733     for (i = 0; i < SSL_PKEY_NUM; i++)
1734         s->s3.tmp.valid_flags[i] = 0;
1735     /*
1736      * If peer sent no signature algorithms check to see if we support
1737      * the default algorithm for each certificate type
1738      */
1739     if (s->s3.tmp.peer_cert_sigalgs == NULL
1740             && s->s3.tmp.peer_sigalgs == NULL) {
1741         const uint16_t *sent_sigs;
1742         size_t sent_sigslen = tls12_get_psigalgs(s, 1, &sent_sigs);
1743
1744         for (i = 0; i < SSL_PKEY_NUM; i++) {
1745             const SIGALG_LOOKUP *lu = tls1_get_legacy_sigalg(s, i);
1746             size_t j;
1747
1748             if (lu == NULL)
1749                 continue;
1750             /* Check default matches a type we sent */
1751             for (j = 0; j < sent_sigslen; j++) {
1752                 if (lu->sigalg == sent_sigs[j]) {
1753                         s->s3.tmp.valid_flags[i] = CERT_PKEY_SIGN;
1754                         break;
1755                 }
1756             }
1757         }
1758         return 1;
1759     }
1760
1761     if (!tls1_process_sigalgs(s)) {
1762         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
1763         return 0;
1764     }
1765     if (s->shared_sigalgs != NULL)
1766         return 1;
1767
1768     /* Fatal error if no shared signature algorithms */
1769     SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
1770              SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS);
1771     return 0;
1772 }
1773
1774 /*-
1775  * Gets the ticket information supplied by the client if any.
1776  *
1777  *   hello: The parsed ClientHello data
1778  *   ret: (output) on return, if a ticket was decrypted, then this is set to
1779  *       point to the resulting session.
1780  */
1781 SSL_TICKET_STATUS tls_get_ticket_from_client(SSL *s, CLIENTHELLO_MSG *hello,
1782                                              SSL_SESSION **ret)
1783 {
1784     size_t size;
1785     RAW_EXTENSION *ticketext;
1786
1787     *ret = NULL;
1788     s->ext.ticket_expected = 0;
1789
1790     /*
1791      * If tickets disabled or not supported by the protocol version
1792      * (e.g. TLSv1.3) behave as if no ticket present to permit stateful
1793      * resumption.
1794      */
1795     if (s->version <= SSL3_VERSION || !tls_use_ticket(s))
1796         return SSL_TICKET_NONE;
1797
1798     ticketext = &hello->pre_proc_exts[TLSEXT_IDX_session_ticket];
1799     if (!ticketext->present)
1800         return SSL_TICKET_NONE;
1801
1802     size = PACKET_remaining(&ticketext->data);
1803
1804     return tls_decrypt_ticket(s, PACKET_data(&ticketext->data), size,
1805                               hello->session_id, hello->session_id_len, ret);
1806 }
1807
1808 /*-
1809  * tls_decrypt_ticket attempts to decrypt a session ticket.
1810  *
1811  * If s->tls_session_secret_cb is set and we're not doing TLSv1.3 then we are
1812  * expecting a pre-shared key ciphersuite, in which case we have no use for
1813  * session tickets and one will never be decrypted, nor will
1814  * s->ext.ticket_expected be set to 1.
1815  *
1816  * Side effects:
1817  *   Sets s->ext.ticket_expected to 1 if the server will have to issue
1818  *   a new session ticket to the client because the client indicated support
1819  *   (and s->tls_session_secret_cb is NULL) but the client either doesn't have
1820  *   a session ticket or we couldn't use the one it gave us, or if
1821  *   s->ctx->ext.ticket_key_cb asked to renew the client's ticket.
1822  *   Otherwise, s->ext.ticket_expected is set to 0.
1823  *
1824  *   etick: points to the body of the session ticket extension.
1825  *   eticklen: the length of the session tickets extension.
1826  *   sess_id: points at the session ID.
1827  *   sesslen: the length of the session ID.
1828  *   psess: (output) on return, if a ticket was decrypted, then this is set to
1829  *       point to the resulting session.
1830  */
1831 SSL_TICKET_STATUS tls_decrypt_ticket(SSL *s, const unsigned char *etick,
1832                                      size_t eticklen, const unsigned char *sess_id,
1833                                      size_t sesslen, SSL_SESSION **psess)
1834 {
1835     SSL_SESSION *sess = NULL;
1836     unsigned char *sdec;
1837     const unsigned char *p;
1838     int slen, renew_ticket = 0, declen;
1839     SSL_TICKET_STATUS ret = SSL_TICKET_FATAL_ERR_OTHER;
1840     size_t mlen;
1841     unsigned char tick_hmac[EVP_MAX_MD_SIZE];
1842     SSL_HMAC *hctx = NULL;
1843     EVP_CIPHER_CTX *ctx = NULL;
1844     SSL_CTX *tctx = s->session_ctx;
1845
1846     if (eticklen == 0) {
1847         /*
1848          * The client will accept a ticket but doesn't currently have
1849          * one (TLSv1.2 and below), or treated as a fatal error in TLSv1.3
1850          */
1851         ret = SSL_TICKET_EMPTY;
1852         goto end;
1853     }
1854     if (!SSL_IS_TLS13(s) && s->ext.session_secret_cb) {
1855         /*
1856          * Indicate that the ticket couldn't be decrypted rather than
1857          * generating the session from ticket now, trigger
1858          * abbreviated handshake based on external mechanism to
1859          * calculate the master secret later.
1860          */
1861         ret = SSL_TICKET_NO_DECRYPT;
1862         goto end;
1863     }
1864
1865     /* Need at least keyname + iv */
1866     if (eticklen < TLSEXT_KEYNAME_LENGTH + EVP_MAX_IV_LENGTH) {
1867         ret = SSL_TICKET_NO_DECRYPT;
1868         goto end;
1869     }
1870
1871     /* Initialize session ticket encryption and HMAC contexts */
1872     hctx = ssl_hmac_new(tctx);
1873     if (hctx == NULL) {
1874         ret = SSL_TICKET_FATAL_ERR_MALLOC;
1875         goto end;
1876     }
1877     ctx = EVP_CIPHER_CTX_new();
1878     if (ctx == NULL) {
1879         ret = SSL_TICKET_FATAL_ERR_MALLOC;
1880         goto end;
1881     }
1882 #ifndef OPENSSL_NO_DEPRECATED_3_0
1883     if (tctx->ext.ticket_key_evp_cb != NULL || tctx->ext.ticket_key_cb != NULL)
1884 #else
1885     if (tctx->ext.ticket_key_evp_cb != NULL)
1886 #endif
1887     {
1888         unsigned char *nctick = (unsigned char *)etick;
1889         int rv = 0;
1890
1891         if (tctx->ext.ticket_key_evp_cb != NULL)
1892             rv = tctx->ext.ticket_key_evp_cb(s, nctick,
1893                                              nctick + TLSEXT_KEYNAME_LENGTH,
1894                                              ctx,
1895                                              ssl_hmac_get0_EVP_MAC_CTX(hctx),
1896                                              0);
1897 #ifndef OPENSSL_NO_DEPRECATED_3_0
1898         else if (tctx->ext.ticket_key_cb != NULL)
1899             /* if 0 is returned, write an empty ticket */
1900             rv = tctx->ext.ticket_key_cb(s, nctick,
1901                                          nctick + TLSEXT_KEYNAME_LENGTH,
1902                                          ctx, ssl_hmac_get0_HMAC_CTX(hctx), 0);
1903 #endif
1904         if (rv < 0) {
1905             ret = SSL_TICKET_FATAL_ERR_OTHER;
1906             goto end;
1907         }
1908         if (rv == 0) {
1909             ret = SSL_TICKET_NO_DECRYPT;
1910             goto end;
1911         }
1912         if (rv == 2)
1913             renew_ticket = 1;
1914     } else {
1915         EVP_CIPHER *aes256cbc = NULL;
1916
1917         /* Check key name matches */
1918         if (memcmp(etick, tctx->ext.tick_key_name,
1919                    TLSEXT_KEYNAME_LENGTH) != 0) {
1920             ret = SSL_TICKET_NO_DECRYPT;
1921             goto end;
1922         }
1923
1924         aes256cbc = EVP_CIPHER_fetch(s->ctx->libctx, "AES-256-CBC",
1925                                      s->ctx->propq);
1926         if (aes256cbc == NULL
1927             || ssl_hmac_init(hctx, tctx->ext.secure->tick_hmac_key,
1928                              sizeof(tctx->ext.secure->tick_hmac_key),
1929                              "SHA256") <= 0
1930             || EVP_DecryptInit_ex(ctx, aes256cbc, NULL,
1931                                   tctx->ext.secure->tick_aes_key,
1932                                   etick + TLSEXT_KEYNAME_LENGTH) <= 0) {
1933             EVP_CIPHER_free(aes256cbc);
1934             ret = SSL_TICKET_FATAL_ERR_OTHER;
1935             goto end;
1936         }
1937         EVP_CIPHER_free(aes256cbc);
1938         if (SSL_IS_TLS13(s))
1939             renew_ticket = 1;
1940     }
1941     /*
1942      * Attempt to process session ticket, first conduct sanity and integrity
1943      * checks on ticket.
1944      */
1945     mlen = ssl_hmac_size(hctx);
1946     if (mlen == 0) {
1947         ret = SSL_TICKET_FATAL_ERR_OTHER;
1948         goto end;
1949     }
1950
1951     /* Sanity check ticket length: must exceed keyname + IV + HMAC */
1952     if (eticklen <=
1953         TLSEXT_KEYNAME_LENGTH + EVP_CIPHER_CTX_get_iv_length(ctx) + mlen) {
1954         ret = SSL_TICKET_NO_DECRYPT;
1955         goto end;
1956     }
1957     eticklen -= mlen;
1958     /* Check HMAC of encrypted ticket */
1959     if (ssl_hmac_update(hctx, etick, eticklen) <= 0
1960         || ssl_hmac_final(hctx, tick_hmac, NULL, sizeof(tick_hmac)) <= 0) {
1961         ret = SSL_TICKET_FATAL_ERR_OTHER;
1962         goto end;
1963     }
1964
1965     if (CRYPTO_memcmp(tick_hmac, etick + eticklen, mlen)) {
1966         ret = SSL_TICKET_NO_DECRYPT;
1967         goto end;
1968     }
1969     /* Attempt to decrypt session data */
1970     /* Move p after IV to start of encrypted ticket, update length */
1971     p = etick + TLSEXT_KEYNAME_LENGTH + EVP_CIPHER_CTX_get_iv_length(ctx);
1972     eticklen -= TLSEXT_KEYNAME_LENGTH + EVP_CIPHER_CTX_get_iv_length(ctx);
1973     sdec = OPENSSL_malloc(eticklen);
1974     if (sdec == NULL || EVP_DecryptUpdate(ctx, sdec, &slen, p,
1975                                           (int)eticklen) <= 0) {
1976         OPENSSL_free(sdec);
1977         ret = SSL_TICKET_FATAL_ERR_OTHER;
1978         goto end;
1979     }
1980     if (EVP_DecryptFinal(ctx, sdec + slen, &declen) <= 0) {
1981         OPENSSL_free(sdec);
1982         ret = SSL_TICKET_NO_DECRYPT;
1983         goto end;
1984     }
1985     slen += declen;
1986     p = sdec;
1987
1988     sess = d2i_SSL_SESSION(NULL, &p, slen);
1989     slen -= p - sdec;
1990     OPENSSL_free(sdec);
1991     if (sess) {
1992         /* Some additional consistency checks */
1993         if (slen != 0) {
1994             SSL_SESSION_free(sess);
1995             sess = NULL;
1996             ret = SSL_TICKET_NO_DECRYPT;
1997             goto end;
1998         }
1999         /*
2000          * The session ID, if non-empty, is used by some clients to detect
2001          * that the ticket has been accepted. So we copy it to the session
2002          * structure. If it is empty set length to zero as required by
2003          * standard.
2004          */
2005         if (sesslen) {
2006             memcpy(sess->session_id, sess_id, sesslen);
2007             sess->session_id_length = sesslen;
2008         }
2009         if (renew_ticket)
2010             ret = SSL_TICKET_SUCCESS_RENEW;
2011         else
2012             ret = SSL_TICKET_SUCCESS;
2013         goto end;
2014     }
2015     ERR_clear_error();
2016     /*
2017      * For session parse failure, indicate that we need to send a new ticket.
2018      */
2019     ret = SSL_TICKET_NO_DECRYPT;
2020
2021  end:
2022     EVP_CIPHER_CTX_free(ctx);
2023     ssl_hmac_free(hctx);
2024
2025     /*
2026      * If set, the decrypt_ticket_cb() is called unless a fatal error was
2027      * detected above. The callback is responsible for checking |ret| before it
2028      * performs any action
2029      */
2030     if (s->session_ctx->decrypt_ticket_cb != NULL
2031             && (ret == SSL_TICKET_EMPTY
2032                 || ret == SSL_TICKET_NO_DECRYPT
2033                 || ret == SSL_TICKET_SUCCESS
2034                 || ret == SSL_TICKET_SUCCESS_RENEW)) {
2035         size_t keyname_len = eticklen;
2036         int retcb;
2037
2038         if (keyname_len > TLSEXT_KEYNAME_LENGTH)
2039             keyname_len = TLSEXT_KEYNAME_LENGTH;
2040         retcb = s->session_ctx->decrypt_ticket_cb(s, sess, etick, keyname_len,
2041                                                   ret,
2042                                                   s->session_ctx->ticket_cb_data);
2043         switch (retcb) {
2044         case SSL_TICKET_RETURN_ABORT:
2045             ret = SSL_TICKET_FATAL_ERR_OTHER;
2046             break;
2047
2048         case SSL_TICKET_RETURN_IGNORE:
2049             ret = SSL_TICKET_NONE;
2050             SSL_SESSION_free(sess);
2051             sess = NULL;
2052             break;
2053
2054         case SSL_TICKET_RETURN_IGNORE_RENEW:
2055             if (ret != SSL_TICKET_EMPTY && ret != SSL_TICKET_NO_DECRYPT)
2056                 ret = SSL_TICKET_NO_DECRYPT;
2057             /* else the value of |ret| will already do the right thing */
2058             SSL_SESSION_free(sess);
2059             sess = NULL;
2060             break;
2061
2062         case SSL_TICKET_RETURN_USE:
2063         case SSL_TICKET_RETURN_USE_RENEW:
2064             if (ret != SSL_TICKET_SUCCESS
2065                     && ret != SSL_TICKET_SUCCESS_RENEW)
2066                 ret = SSL_TICKET_FATAL_ERR_OTHER;
2067             else if (retcb == SSL_TICKET_RETURN_USE)
2068                 ret = SSL_TICKET_SUCCESS;
2069             else
2070                 ret = SSL_TICKET_SUCCESS_RENEW;
2071             break;
2072
2073         default:
2074             ret = SSL_TICKET_FATAL_ERR_OTHER;
2075         }
2076     }
2077
2078     if (s->ext.session_secret_cb == NULL || SSL_IS_TLS13(s)) {
2079         switch (ret) {
2080         case SSL_TICKET_NO_DECRYPT:
2081         case SSL_TICKET_SUCCESS_RENEW:
2082         case SSL_TICKET_EMPTY:
2083             s->ext.ticket_expected = 1;
2084         }
2085     }
2086
2087     *psess = sess;
2088
2089     return ret;
2090 }
2091
2092 /* Check to see if a signature algorithm is allowed */
2093 static int tls12_sigalg_allowed(const SSL *s, int op, const SIGALG_LOOKUP *lu)
2094 {
2095     unsigned char sigalgstr[2];
2096     int secbits;
2097
2098     if (lu == NULL || !lu->enabled)
2099         return 0;
2100     /* DSA is not allowed in TLS 1.3 */
2101     if (SSL_IS_TLS13(s) && lu->sig == EVP_PKEY_DSA)
2102         return 0;
2103     /*
2104      * At some point we should fully axe DSA/etc. in ClientHello as per TLS 1.3
2105      * spec
2106      */
2107     if (!s->server && !SSL_IS_DTLS(s) && s->s3.tmp.min_ver >= TLS1_3_VERSION
2108         && (lu->sig == EVP_PKEY_DSA || lu->hash_idx == SSL_MD_SHA1_IDX
2109             || lu->hash_idx == SSL_MD_MD5_IDX
2110             || lu->hash_idx == SSL_MD_SHA224_IDX))
2111         return 0;
2112
2113     /* See if public key algorithm allowed */
2114     if (ssl_cert_is_disabled(s->ctx, lu->sig_idx))
2115         return 0;
2116
2117     if (lu->sig == NID_id_GostR3410_2012_256
2118             || lu->sig == NID_id_GostR3410_2012_512
2119             || lu->sig == NID_id_GostR3410_2001) {
2120         /* We never allow GOST sig algs on the server with TLSv1.3 */
2121         if (s->server && SSL_IS_TLS13(s))
2122             return 0;
2123         if (!s->server
2124                 && s->method->version == TLS_ANY_VERSION
2125                 && s->s3.tmp.max_ver >= TLS1_3_VERSION) {
2126             int i, num;
2127             STACK_OF(SSL_CIPHER) *sk;
2128
2129             /*
2130              * We're a client that could negotiate TLSv1.3. We only allow GOST
2131              * sig algs if we could negotiate TLSv1.2 or below and we have GOST
2132              * ciphersuites enabled.
2133              */
2134
2135             if (s->s3.tmp.min_ver >= TLS1_3_VERSION)
2136                 return 0;
2137
2138             sk = SSL_get_ciphers(s);
2139             num = sk != NULL ? sk_SSL_CIPHER_num(sk) : 0;
2140             for (i = 0; i < num; i++) {
2141                 const SSL_CIPHER *c;
2142
2143                 c = sk_SSL_CIPHER_value(sk, i);
2144                 /* Skip disabled ciphers */
2145                 if (ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_SUPPORTED, 0))
2146                     continue;
2147
2148                 if ((c->algorithm_mkey & (SSL_kGOST | SSL_kGOST18)) != 0)
2149                     break;
2150             }
2151             if (i == num)
2152                 return 0;
2153         }
2154     }
2155
2156     /* Finally see if security callback allows it */
2157     secbits = sigalg_security_bits(s->ctx, lu);
2158     sigalgstr[0] = (lu->sigalg >> 8) & 0xff;
2159     sigalgstr[1] = lu->sigalg & 0xff;
2160     return ssl_security(s, op, secbits, lu->hash, (void *)sigalgstr);
2161 }
2162
2163 /*
2164  * Get a mask of disabled public key algorithms based on supported signature
2165  * algorithms. For example if no signature algorithm supports RSA then RSA is
2166  * disabled.
2167  */
2168
2169 void ssl_set_sig_mask(uint32_t *pmask_a, SSL *s, int op)
2170 {
2171     const uint16_t *sigalgs;
2172     size_t i, sigalgslen;
2173     uint32_t disabled_mask = SSL_aRSA | SSL_aDSS | SSL_aECDSA;
2174     /*
2175      * Go through all signature algorithms seeing if we support any
2176      * in disabled_mask.
2177      */
2178     sigalgslen = tls12_get_psigalgs(s, 1, &sigalgs);
2179     for (i = 0; i < sigalgslen; i++, sigalgs++) {
2180         const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(s, *sigalgs);
2181         const SSL_CERT_LOOKUP *clu;
2182
2183         if (lu == NULL)
2184             continue;
2185
2186         clu = ssl_cert_lookup_by_idx(lu->sig_idx);
2187         if (clu == NULL)
2188                 continue;
2189
2190         /* If algorithm is disabled see if we can enable it */
2191         if ((clu->amask & disabled_mask) != 0
2192                 && tls12_sigalg_allowed(s, op, lu))
2193             disabled_mask &= ~clu->amask;
2194     }
2195     *pmask_a |= disabled_mask;
2196 }
2197
2198 int tls12_copy_sigalgs(SSL *s, WPACKET *pkt,
2199                        const uint16_t *psig, size_t psiglen)
2200 {
2201     size_t i;
2202     int rv = 0;
2203
2204     for (i = 0; i < psiglen; i++, psig++) {
2205         const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(s, *psig);
2206
2207         if (lu == NULL
2208                 || !tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SUPPORTED, lu))
2209             continue;
2210         if (!WPACKET_put_bytes_u16(pkt, *psig))
2211             return 0;
2212         /*
2213          * If TLS 1.3 must have at least one valid TLS 1.3 message
2214          * signing algorithm: i.e. neither RSA nor SHA1/SHA224
2215          */
2216         if (rv == 0 && (!SSL_IS_TLS13(s)
2217             || (lu->sig != EVP_PKEY_RSA
2218                 && lu->hash != NID_sha1
2219                 && lu->hash != NID_sha224)))
2220             rv = 1;
2221     }
2222     if (rv == 0)
2223         ERR_raise(ERR_LIB_SSL, SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM);
2224     return rv;
2225 }
2226
2227 /* Given preference and allowed sigalgs set shared sigalgs */
2228 static size_t tls12_shared_sigalgs(SSL *s, const SIGALG_LOOKUP **shsig,
2229                                    const uint16_t *pref, size_t preflen,
2230                                    const uint16_t *allow, size_t allowlen)
2231 {
2232     const uint16_t *ptmp, *atmp;
2233     size_t i, j, nmatch = 0;
2234     for (i = 0, ptmp = pref; i < preflen; i++, ptmp++) {
2235         const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(s, *ptmp);
2236
2237         /* Skip disabled hashes or signature algorithms */
2238         if (lu == NULL
2239                 || !tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SHARED, lu))
2240             continue;
2241         for (j = 0, atmp = allow; j < allowlen; j++, atmp++) {
2242             if (*ptmp == *atmp) {
2243                 nmatch++;
2244                 if (shsig)
2245                     *shsig++ = lu;
2246                 break;
2247             }
2248         }
2249     }
2250     return nmatch;
2251 }
2252
2253 /* Set shared signature algorithms for SSL structures */
2254 static int tls1_set_shared_sigalgs(SSL *s)
2255 {
2256     const uint16_t *pref, *allow, *conf;
2257     size_t preflen, allowlen, conflen;
2258     size_t nmatch;
2259     const SIGALG_LOOKUP **salgs = NULL;
2260     CERT *c = s->cert;
2261     unsigned int is_suiteb = tls1_suiteb(s);
2262
2263     OPENSSL_free(s->shared_sigalgs);
2264     s->shared_sigalgs = NULL;
2265     s->shared_sigalgslen = 0;
2266     /* If client use client signature algorithms if not NULL */
2267     if (!s->server && c->client_sigalgs && !is_suiteb) {
2268         conf = c->client_sigalgs;
2269         conflen = c->client_sigalgslen;
2270     } else if (c->conf_sigalgs && !is_suiteb) {
2271         conf = c->conf_sigalgs;
2272         conflen = c->conf_sigalgslen;
2273     } else
2274         conflen = tls12_get_psigalgs(s, 0, &conf);
2275     if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE || is_suiteb) {
2276         pref = conf;
2277         preflen = conflen;
2278         allow = s->s3.tmp.peer_sigalgs;
2279         allowlen = s->s3.tmp.peer_sigalgslen;
2280     } else {
2281         allow = conf;
2282         allowlen = conflen;
2283         pref = s->s3.tmp.peer_sigalgs;
2284         preflen = s->s3.tmp.peer_sigalgslen;
2285     }
2286     nmatch = tls12_shared_sigalgs(s, NULL, pref, preflen, allow, allowlen);
2287     if (nmatch) {
2288         if ((salgs = OPENSSL_malloc(nmatch * sizeof(*salgs))) == NULL) {
2289             ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
2290             return 0;
2291         }
2292         nmatch = tls12_shared_sigalgs(s, salgs, pref, preflen, allow, allowlen);
2293     } else {
2294         salgs = NULL;
2295     }
2296     s->shared_sigalgs = salgs;
2297     s->shared_sigalgslen = nmatch;
2298     return 1;
2299 }
2300
2301 int tls1_save_u16(PACKET *pkt, uint16_t **pdest, size_t *pdestlen)
2302 {
2303     unsigned int stmp;
2304     size_t size, i;
2305     uint16_t *buf;
2306
2307     size = PACKET_remaining(pkt);
2308
2309     /* Invalid data length */
2310     if (size == 0 || (size & 1) != 0)
2311         return 0;
2312
2313     size >>= 1;
2314
2315     if ((buf = OPENSSL_malloc(size * sizeof(*buf))) == NULL)  {
2316         ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
2317         return 0;
2318     }
2319     for (i = 0; i < size && PACKET_get_net_2(pkt, &stmp); i++)
2320         buf[i] = stmp;
2321
2322     if (i != size) {
2323         OPENSSL_free(buf);
2324         return 0;
2325     }
2326
2327     OPENSSL_free(*pdest);
2328     *pdest = buf;
2329     *pdestlen = size;
2330
2331     return 1;
2332 }
2333
2334 int tls1_save_sigalgs(SSL *s, PACKET *pkt, int cert)
2335 {
2336     /* Extension ignored for inappropriate versions */
2337     if (!SSL_USE_SIGALGS(s))
2338         return 1;
2339     /* Should never happen */
2340     if (s->cert == NULL)
2341         return 0;
2342
2343     if (cert)
2344         return tls1_save_u16(pkt, &s->s3.tmp.peer_cert_sigalgs,
2345                              &s->s3.tmp.peer_cert_sigalgslen);
2346     else
2347         return tls1_save_u16(pkt, &s->s3.tmp.peer_sigalgs,
2348                              &s->s3.tmp.peer_sigalgslen);
2349
2350 }
2351
2352 /* Set preferred digest for each key type */
2353
2354 int tls1_process_sigalgs(SSL *s)
2355 {
2356     size_t i;
2357     uint32_t *pvalid = s->s3.tmp.valid_flags;
2358
2359     if (!tls1_set_shared_sigalgs(s))
2360         return 0;
2361
2362     for (i = 0; i < SSL_PKEY_NUM; i++)
2363         pvalid[i] = 0;
2364
2365     for (i = 0; i < s->shared_sigalgslen; i++) {
2366         const SIGALG_LOOKUP *sigptr = s->shared_sigalgs[i];
2367         int idx = sigptr->sig_idx;
2368
2369         /* Ignore PKCS1 based sig algs in TLSv1.3 */
2370         if (SSL_IS_TLS13(s) && sigptr->sig == EVP_PKEY_RSA)
2371             continue;
2372         /* If not disabled indicate we can explicitly sign */
2373         if (pvalid[idx] == 0 && !ssl_cert_is_disabled(s->ctx, idx))
2374             pvalid[idx] = CERT_PKEY_EXPLICIT_SIGN | CERT_PKEY_SIGN;
2375     }
2376     return 1;
2377 }
2378
2379 int SSL_get_sigalgs(SSL *s, int idx,
2380                     int *psign, int *phash, int *psignhash,
2381                     unsigned char *rsig, unsigned char *rhash)
2382 {
2383     uint16_t *psig = s->s3.tmp.peer_sigalgs;
2384     size_t numsigalgs = s->s3.tmp.peer_sigalgslen;
2385     if (psig == NULL || numsigalgs > INT_MAX)
2386         return 0;
2387     if (idx >= 0) {
2388         const SIGALG_LOOKUP *lu;
2389
2390         if (idx >= (int)numsigalgs)
2391             return 0;
2392         psig += idx;
2393         if (rhash != NULL)
2394             *rhash = (unsigned char)((*psig >> 8) & 0xff);
2395         if (rsig != NULL)
2396             *rsig = (unsigned char)(*psig & 0xff);
2397         lu = tls1_lookup_sigalg(s, *psig);
2398         if (psign != NULL)
2399             *psign = lu != NULL ? lu->sig : NID_undef;
2400         if (phash != NULL)
2401             *phash = lu != NULL ? lu->hash : NID_undef;
2402         if (psignhash != NULL)
2403             *psignhash = lu != NULL ? lu->sigandhash : NID_undef;
2404     }
2405     return (int)numsigalgs;
2406 }
2407
2408 int SSL_get_shared_sigalgs(SSL *s, int idx,
2409                            int *psign, int *phash, int *psignhash,
2410                            unsigned char *rsig, unsigned char *rhash)
2411 {
2412     const SIGALG_LOOKUP *shsigalgs;
2413     if (s->shared_sigalgs == NULL
2414         || idx < 0
2415         || idx >= (int)s->shared_sigalgslen
2416         || s->shared_sigalgslen > INT_MAX)
2417         return 0;
2418     shsigalgs = s->shared_sigalgs[idx];
2419     if (phash != NULL)
2420         *phash = shsigalgs->hash;
2421     if (psign != NULL)
2422         *psign = shsigalgs->sig;
2423     if (psignhash != NULL)
2424         *psignhash = shsigalgs->sigandhash;
2425     if (rsig != NULL)
2426         *rsig = (unsigned char)(shsigalgs->sigalg & 0xff);
2427     if (rhash != NULL)
2428         *rhash = (unsigned char)((shsigalgs->sigalg >> 8) & 0xff);
2429     return (int)s->shared_sigalgslen;
2430 }
2431
2432 /* Maximum possible number of unique entries in sigalgs array */
2433 #define TLS_MAX_SIGALGCNT (OSSL_NELEM(sigalg_lookup_tbl) * 2)
2434
2435 typedef struct {
2436     size_t sigalgcnt;
2437     /* TLSEXT_SIGALG_XXX values */
2438     uint16_t sigalgs[TLS_MAX_SIGALGCNT];
2439 } sig_cb_st;
2440
2441 static void get_sigorhash(int *psig, int *phash, const char *str)
2442 {
2443     if (strcmp(str, "RSA") == 0) {
2444         *psig = EVP_PKEY_RSA;
2445     } else if (strcmp(str, "RSA-PSS") == 0 || strcmp(str, "PSS") == 0) {
2446         *psig = EVP_PKEY_RSA_PSS;
2447     } else if (strcmp(str, "DSA") == 0) {
2448         *psig = EVP_PKEY_DSA;
2449     } else if (strcmp(str, "ECDSA") == 0) {
2450         *psig = EVP_PKEY_EC;
2451     } else {
2452         *phash = OBJ_sn2nid(str);
2453         if (*phash == NID_undef)
2454             *phash = OBJ_ln2nid(str);
2455     }
2456 }
2457 /* Maximum length of a signature algorithm string component */
2458 #define TLS_MAX_SIGSTRING_LEN   40
2459
2460 static int sig_cb(const char *elem, int len, void *arg)
2461 {
2462     sig_cb_st *sarg = arg;
2463     size_t i;
2464     const SIGALG_LOOKUP *s;
2465     char etmp[TLS_MAX_SIGSTRING_LEN], *p;
2466     int sig_alg = NID_undef, hash_alg = NID_undef;
2467     if (elem == NULL)
2468         return 0;
2469     if (sarg->sigalgcnt == TLS_MAX_SIGALGCNT)
2470         return 0;
2471     if (len > (int)(sizeof(etmp) - 1))
2472         return 0;
2473     memcpy(etmp, elem, len);
2474     etmp[len] = 0;
2475     p = strchr(etmp, '+');
2476     /*
2477      * We only allow SignatureSchemes listed in the sigalg_lookup_tbl;
2478      * if there's no '+' in the provided name, look for the new-style combined
2479      * name.  If not, match both sig+hash to find the needed SIGALG_LOOKUP.
2480      * Just sig+hash is not unique since TLS 1.3 adds rsa_pss_pss_* and
2481      * rsa_pss_rsae_* that differ only by public key OID; in such cases
2482      * we will pick the _rsae_ variant, by virtue of them appearing earlier
2483      * in the table.
2484      */
2485     if (p == NULL) {
2486         for (i = 0, s = sigalg_lookup_tbl; i < OSSL_NELEM(sigalg_lookup_tbl);
2487              i++, s++) {
2488             if (s->name != NULL && strcmp(etmp, s->name) == 0) {
2489                 sarg->sigalgs[sarg->sigalgcnt++] = s->sigalg;
2490                 break;
2491             }
2492         }
2493         if (i == OSSL_NELEM(sigalg_lookup_tbl))
2494             return 0;
2495     } else {
2496         *p = 0;
2497         p++;
2498         if (*p == 0)
2499             return 0;
2500         get_sigorhash(&sig_alg, &hash_alg, etmp);
2501         get_sigorhash(&sig_alg, &hash_alg, p);
2502         if (sig_alg == NID_undef || hash_alg == NID_undef)
2503             return 0;
2504         for (i = 0, s = sigalg_lookup_tbl; i < OSSL_NELEM(sigalg_lookup_tbl);
2505              i++, s++) {
2506             if (s->hash == hash_alg && s->sig == sig_alg) {
2507                 sarg->sigalgs[sarg->sigalgcnt++] = s->sigalg;
2508                 break;
2509             }
2510         }
2511         if (i == OSSL_NELEM(sigalg_lookup_tbl))
2512             return 0;
2513     }
2514
2515     /* Reject duplicates */
2516     for (i = 0; i < sarg->sigalgcnt - 1; i++) {
2517         if (sarg->sigalgs[i] == sarg->sigalgs[sarg->sigalgcnt - 1]) {
2518             sarg->sigalgcnt--;
2519             return 0;
2520         }
2521     }
2522     return 1;
2523 }
2524
2525 /*
2526  * Set supported signature algorithms based on a colon separated list of the
2527  * form sig+hash e.g. RSA+SHA512:DSA+SHA512
2528  */
2529 int tls1_set_sigalgs_list(CERT *c, const char *str, int client)
2530 {
2531     sig_cb_st sig;
2532     sig.sigalgcnt = 0;
2533     if (!CONF_parse_list(str, ':', 1, sig_cb, &sig))
2534         return 0;
2535     if (c == NULL)
2536         return 1;
2537     return tls1_set_raw_sigalgs(c, sig.sigalgs, sig.sigalgcnt, client);
2538 }
2539
2540 int tls1_set_raw_sigalgs(CERT *c, const uint16_t *psigs, size_t salglen,
2541                      int client)
2542 {
2543     uint16_t *sigalgs;
2544
2545     if ((sigalgs = OPENSSL_malloc(salglen * sizeof(*sigalgs))) == NULL) {
2546         ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
2547         return 0;
2548     }
2549     memcpy(sigalgs, psigs, salglen * sizeof(*sigalgs));
2550
2551     if (client) {
2552         OPENSSL_free(c->client_sigalgs);
2553         c->client_sigalgs = sigalgs;
2554         c->client_sigalgslen = salglen;
2555     } else {
2556         OPENSSL_free(c->conf_sigalgs);
2557         c->conf_sigalgs = sigalgs;
2558         c->conf_sigalgslen = salglen;
2559     }
2560
2561     return 1;
2562 }
2563
2564 int tls1_set_sigalgs(CERT *c, const int *psig_nids, size_t salglen, int client)
2565 {
2566     uint16_t *sigalgs, *sptr;
2567     size_t i;
2568
2569     if (salglen & 1)
2570         return 0;
2571     if ((sigalgs = OPENSSL_malloc((salglen / 2) * sizeof(*sigalgs))) == NULL) {
2572         ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
2573         return 0;
2574     }
2575     for (i = 0, sptr = sigalgs; i < salglen; i += 2) {
2576         size_t j;
2577         const SIGALG_LOOKUP *curr;
2578         int md_id = *psig_nids++;
2579         int sig_id = *psig_nids++;
2580
2581         for (j = 0, curr = sigalg_lookup_tbl; j < OSSL_NELEM(sigalg_lookup_tbl);
2582              j++, curr++) {
2583             if (curr->hash == md_id && curr->sig == sig_id) {
2584                 *sptr++ = curr->sigalg;
2585                 break;
2586             }
2587         }
2588
2589         if (j == OSSL_NELEM(sigalg_lookup_tbl))
2590             goto err;
2591     }
2592
2593     if (client) {
2594         OPENSSL_free(c->client_sigalgs);
2595         c->client_sigalgs = sigalgs;
2596         c->client_sigalgslen = salglen / 2;
2597     } else {
2598         OPENSSL_free(c->conf_sigalgs);
2599         c->conf_sigalgs = sigalgs;
2600         c->conf_sigalgslen = salglen / 2;
2601     }
2602
2603     return 1;
2604
2605  err:
2606     OPENSSL_free(sigalgs);
2607     return 0;
2608 }
2609
2610 static int tls1_check_sig_alg(SSL *s, X509 *x, int default_nid)
2611 {
2612     int sig_nid, use_pc_sigalgs = 0;
2613     size_t i;
2614     const SIGALG_LOOKUP *sigalg;
2615     size_t sigalgslen;
2616     if (default_nid == -1)
2617         return 1;
2618     sig_nid = X509_get_signature_nid(x);
2619     if (default_nid)
2620         return sig_nid == default_nid ? 1 : 0;
2621
2622     if (SSL_IS_TLS13(s) && s->s3.tmp.peer_cert_sigalgs != NULL) {
2623         /*
2624          * If we're in TLSv1.3 then we only get here if we're checking the
2625          * chain. If the peer has specified peer_cert_sigalgs then we use them
2626          * otherwise we default to normal sigalgs.
2627          */
2628         sigalgslen = s->s3.tmp.peer_cert_sigalgslen;
2629         use_pc_sigalgs = 1;
2630     } else {
2631         sigalgslen = s->shared_sigalgslen;
2632     }
2633     for (i = 0; i < sigalgslen; i++) {
2634         sigalg = use_pc_sigalgs
2635                  ? tls1_lookup_sigalg(s, s->s3.tmp.peer_cert_sigalgs[i])
2636                  : s->shared_sigalgs[i];
2637         if (sigalg != NULL && sig_nid == sigalg->sigandhash)
2638             return 1;
2639     }
2640     return 0;
2641 }
2642
2643 /* Check to see if a certificate issuer name matches list of CA names */
2644 static int ssl_check_ca_name(STACK_OF(X509_NAME) *names, X509 *x)
2645 {
2646     const X509_NAME *nm;
2647     int i;
2648     nm = X509_get_issuer_name(x);
2649     for (i = 0; i < sk_X509_NAME_num(names); i++) {
2650         if (!X509_NAME_cmp(nm, sk_X509_NAME_value(names, i)))
2651             return 1;
2652     }
2653     return 0;
2654 }
2655
2656 /*
2657  * Check certificate chain is consistent with TLS extensions and is usable by
2658  * server. This servers two purposes: it allows users to check chains before
2659  * passing them to the server and it allows the server to check chains before
2660  * attempting to use them.
2661  */
2662
2663 /* Flags which need to be set for a certificate when strict mode not set */
2664
2665 #define CERT_PKEY_VALID_FLAGS \
2666         (CERT_PKEY_EE_SIGNATURE|CERT_PKEY_EE_PARAM)
2667 /* Strict mode flags */
2668 #define CERT_PKEY_STRICT_FLAGS \
2669          (CERT_PKEY_VALID_FLAGS|CERT_PKEY_CA_SIGNATURE|CERT_PKEY_CA_PARAM \
2670          | CERT_PKEY_ISSUER_NAME|CERT_PKEY_CERT_TYPE)
2671
2672 int tls1_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain,
2673                      int idx)
2674 {
2675     int i;
2676     int rv = 0;
2677     int check_flags = 0, strict_mode;
2678     CERT_PKEY *cpk = NULL;
2679     CERT *c = s->cert;
2680     uint32_t *pvalid;
2681     unsigned int suiteb_flags = tls1_suiteb(s);
2682     /* idx == -1 means checking server chains */
2683     if (idx != -1) {
2684         /* idx == -2 means checking client certificate chains */
2685         if (idx == -2) {
2686             cpk = c->key;
2687             idx = (int)(cpk - c->pkeys);
2688         } else
2689             cpk = c->pkeys + idx;
2690         pvalid = s->s3.tmp.valid_flags + idx;
2691         x = cpk->x509;
2692         pk = cpk->privatekey;
2693         chain = cpk->chain;
2694         strict_mode = c->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT;
2695         /* If no cert or key, forget it */
2696         if (!x || !pk)
2697             goto end;
2698     } else {
2699         size_t certidx;
2700
2701         if (!x || !pk)
2702             return 0;
2703
2704         if (ssl_cert_lookup_by_pkey(pk, &certidx) == NULL)
2705             return 0;
2706         idx = certidx;
2707         pvalid = s->s3.tmp.valid_flags + idx;
2708
2709         if (c->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)
2710             check_flags = CERT_PKEY_STRICT_FLAGS;
2711         else
2712             check_flags = CERT_PKEY_VALID_FLAGS;
2713         strict_mode = 1;
2714     }
2715
2716     if (suiteb_flags) {
2717         int ok;
2718         if (check_flags)
2719             check_flags |= CERT_PKEY_SUITEB;
2720         ok = X509_chain_check_suiteb(NULL, x, chain, suiteb_flags);
2721         if (ok == X509_V_OK)
2722             rv |= CERT_PKEY_SUITEB;
2723         else if (!check_flags)
2724             goto end;
2725     }
2726
2727     /*
2728      * Check all signature algorithms are consistent with signature
2729      * algorithms extension if TLS 1.2 or later and strict mode.
2730      */
2731     if (TLS1_get_version(s) >= TLS1_2_VERSION && strict_mode) {
2732         int default_nid;
2733         int rsign = 0;
2734         if (s->s3.tmp.peer_cert_sigalgs != NULL
2735                 || s->s3.tmp.peer_sigalgs != NULL) {
2736             default_nid = 0;
2737         /* If no sigalgs extension use defaults from RFC5246 */
2738         } else {
2739             switch (idx) {
2740             case SSL_PKEY_RSA:
2741                 rsign = EVP_PKEY_RSA;
2742                 default_nid = NID_sha1WithRSAEncryption;
2743                 break;
2744
2745             case SSL_PKEY_DSA_SIGN:
2746                 rsign = EVP_PKEY_DSA;
2747                 default_nid = NID_dsaWithSHA1;
2748                 break;
2749
2750             case SSL_PKEY_ECC:
2751                 rsign = EVP_PKEY_EC;
2752                 default_nid = NID_ecdsa_with_SHA1;
2753                 break;
2754
2755             case SSL_PKEY_GOST01:
2756                 rsign = NID_id_GostR3410_2001;
2757                 default_nid = NID_id_GostR3411_94_with_GostR3410_2001;
2758                 break;
2759
2760             case SSL_PKEY_GOST12_256:
2761                 rsign = NID_id_GostR3410_2012_256;
2762                 default_nid = NID_id_tc26_signwithdigest_gost3410_2012_256;
2763                 break;
2764
2765             case SSL_PKEY_GOST12_512:
2766                 rsign = NID_id_GostR3410_2012_512;
2767                 default_nid = NID_id_tc26_signwithdigest_gost3410_2012_512;
2768                 break;
2769
2770             default:
2771                 default_nid = -1;
2772                 break;
2773             }
2774         }
2775         /*
2776          * If peer sent no signature algorithms extension and we have set
2777          * preferred signature algorithms check we support sha1.
2778          */
2779         if (default_nid > 0 && c->conf_sigalgs) {
2780             size_t j;
2781             const uint16_t *p = c->conf_sigalgs;
2782             for (j = 0; j < c->conf_sigalgslen; j++, p++) {
2783                 const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(s, *p);
2784
2785                 if (lu != NULL && lu->hash == NID_sha1 && lu->sig == rsign)
2786                     break;
2787             }
2788             if (j == c->conf_sigalgslen) {
2789                 if (check_flags)
2790                     goto skip_sigs;
2791                 else
2792                     goto end;
2793             }
2794         }
2795         /* Check signature algorithm of each cert in chain */
2796         if (SSL_IS_TLS13(s)) {
2797             /*
2798              * We only get here if the application has called SSL_check_chain(),
2799              * so check_flags is always set.
2800              */
2801             if (find_sig_alg(s, x, pk) != NULL)
2802                 rv |= CERT_PKEY_EE_SIGNATURE;
2803         } else if (!tls1_check_sig_alg(s, x, default_nid)) {
2804             if (!check_flags)
2805                 goto end;
2806         } else
2807             rv |= CERT_PKEY_EE_SIGNATURE;
2808         rv |= CERT_PKEY_CA_SIGNATURE;
2809         for (i = 0; i < sk_X509_num(chain); i++) {
2810             if (!tls1_check_sig_alg(s, sk_X509_value(chain, i), default_nid)) {
2811                 if (check_flags) {
2812                     rv &= ~CERT_PKEY_CA_SIGNATURE;
2813                     break;
2814                 } else
2815                     goto end;
2816             }
2817         }
2818     }
2819     /* Else not TLS 1.2, so mark EE and CA signing algorithms OK */
2820     else if (check_flags)
2821         rv |= CERT_PKEY_EE_SIGNATURE | CERT_PKEY_CA_SIGNATURE;
2822  skip_sigs:
2823     /* Check cert parameters are consistent */
2824     if (tls1_check_cert_param(s, x, 1))
2825         rv |= CERT_PKEY_EE_PARAM;
2826     else if (!check_flags)
2827         goto end;
2828     if (!s->server)
2829         rv |= CERT_PKEY_CA_PARAM;
2830     /* In strict mode check rest of chain too */
2831     else if (strict_mode) {
2832         rv |= CERT_PKEY_CA_PARAM;
2833         for (i = 0; i < sk_X509_num(chain); i++) {
2834             X509 *ca = sk_X509_value(chain, i);
2835             if (!tls1_check_cert_param(s, ca, 0)) {
2836                 if (check_flags) {
2837                     rv &= ~CERT_PKEY_CA_PARAM;
2838                     break;
2839                 } else
2840                     goto end;
2841             }
2842         }
2843     }
2844     if (!s->server && strict_mode) {
2845         STACK_OF(X509_NAME) *ca_dn;
2846         int check_type = 0;
2847
2848         if (EVP_PKEY_is_a(pk, "RSA"))
2849             check_type = TLS_CT_RSA_SIGN;
2850         else if (EVP_PKEY_is_a(pk, "DSA"))
2851             check_type = TLS_CT_DSS_SIGN;
2852         else if (EVP_PKEY_is_a(pk, "EC"))
2853             check_type = TLS_CT_ECDSA_SIGN;
2854
2855         if (check_type) {
2856             const uint8_t *ctypes = s->s3.tmp.ctype;
2857             size_t j;
2858
2859             for (j = 0; j < s->s3.tmp.ctype_len; j++, ctypes++) {
2860                 if (*ctypes == check_type) {
2861                     rv |= CERT_PKEY_CERT_TYPE;
2862                     break;
2863                 }
2864             }
2865             if (!(rv & CERT_PKEY_CERT_TYPE) && !check_flags)
2866                 goto end;
2867         } else {
2868             rv |= CERT_PKEY_CERT_TYPE;
2869         }
2870
2871         ca_dn = s->s3.tmp.peer_ca_names;
2872
2873         if (!sk_X509_NAME_num(ca_dn))
2874             rv |= CERT_PKEY_ISSUER_NAME;
2875
2876         if (!(rv & CERT_PKEY_ISSUER_NAME)) {
2877             if (ssl_check_ca_name(ca_dn, x))
2878                 rv |= CERT_PKEY_ISSUER_NAME;
2879         }
2880         if (!(rv & CERT_PKEY_ISSUER_NAME)) {
2881             for (i = 0; i < sk_X509_num(chain); i++) {
2882                 X509 *xtmp = sk_X509_value(chain, i);
2883                 if (ssl_check_ca_name(ca_dn, xtmp)) {
2884                     rv |= CERT_PKEY_ISSUER_NAME;
2885                     break;
2886                 }
2887             }
2888         }
2889         if (!check_flags && !(rv & CERT_PKEY_ISSUER_NAME))
2890             goto end;
2891     } else
2892         rv |= CERT_PKEY_ISSUER_NAME | CERT_PKEY_CERT_TYPE;
2893
2894     if (!check_flags || (rv & check_flags) == check_flags)
2895         rv |= CERT_PKEY_VALID;
2896
2897  end:
2898
2899     if (TLS1_get_version(s) >= TLS1_2_VERSION)
2900         rv |= *pvalid & (CERT_PKEY_EXPLICIT_SIGN | CERT_PKEY_SIGN);
2901     else
2902         rv |= CERT_PKEY_SIGN | CERT_PKEY_EXPLICIT_SIGN;
2903
2904     /*
2905      * When checking a CERT_PKEY structure all flags are irrelevant if the
2906      * chain is invalid.
2907      */
2908     if (!check_flags) {
2909         if (rv & CERT_PKEY_VALID) {
2910             *pvalid = rv;
2911         } else {
2912             /* Preserve sign and explicit sign flag, clear rest */
2913             *pvalid &= CERT_PKEY_EXPLICIT_SIGN | CERT_PKEY_SIGN;
2914             return 0;
2915         }
2916     }
2917     return rv;
2918 }
2919
2920 /* Set validity of certificates in an SSL structure */
2921 void tls1_set_cert_validity(SSL *s)
2922 {
2923     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_RSA);
2924     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_RSA_PSS_SIGN);
2925     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_DSA_SIGN);
2926     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_ECC);
2927     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_GOST01);
2928     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_GOST12_256);
2929     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_GOST12_512);
2930     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_ED25519);
2931     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_ED448);
2932 }
2933
2934 /* User level utility function to check a chain is suitable */
2935 int SSL_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain)
2936 {
2937     return tls1_check_chain(s, x, pk, chain, -1);
2938 }
2939
2940 EVP_PKEY *ssl_get_auto_dh(SSL *s)
2941 {
2942     EVP_PKEY *dhp = NULL;
2943     BIGNUM *p;
2944     int dh_secbits = 80, sec_level_bits;
2945     EVP_PKEY_CTX *pctx = NULL;
2946     OSSL_PARAM_BLD *tmpl = NULL;
2947     OSSL_PARAM *params = NULL;
2948
2949     if (s->cert->dh_tmp_auto != 2) {
2950         if (s->s3.tmp.new_cipher->algorithm_auth & (SSL_aNULL | SSL_aPSK)) {
2951             if (s->s3.tmp.new_cipher->strength_bits == 256)
2952                 dh_secbits = 128;
2953             else
2954                 dh_secbits = 80;
2955         } else {
2956             if (s->s3.tmp.cert == NULL)
2957                 return NULL;
2958             dh_secbits = EVP_PKEY_get_security_bits(s->s3.tmp.cert->privatekey);
2959         }
2960     }
2961
2962     /* Do not pick a prime that is too weak for the current security level */
2963     sec_level_bits = ssl_get_security_level_bits(s, NULL, NULL);
2964     if (dh_secbits < sec_level_bits)
2965         dh_secbits = sec_level_bits;
2966
2967     if (dh_secbits >= 192)
2968         p = BN_get_rfc3526_prime_8192(NULL);
2969     else if (dh_secbits >= 152)
2970         p = BN_get_rfc3526_prime_4096(NULL);
2971     else if (dh_secbits >= 128)
2972         p = BN_get_rfc3526_prime_3072(NULL);
2973     else if (dh_secbits >= 112)
2974         p = BN_get_rfc3526_prime_2048(NULL);
2975     else
2976         p = BN_get_rfc2409_prime_1024(NULL);
2977     if (p == NULL)
2978         goto err;
2979
2980     pctx = EVP_PKEY_CTX_new_from_name(s->ctx->libctx, "DH", s->ctx->propq);
2981     if (pctx == NULL
2982             || EVP_PKEY_fromdata_init(pctx) != 1)
2983         goto err;
2984
2985     tmpl = OSSL_PARAM_BLD_new();
2986     if (tmpl == NULL
2987             || !OSSL_PARAM_BLD_push_BN(tmpl, OSSL_PKEY_PARAM_FFC_P, p)
2988             || !OSSL_PARAM_BLD_push_uint(tmpl, OSSL_PKEY_PARAM_FFC_G, 2))
2989         goto err;
2990
2991     params = OSSL_PARAM_BLD_to_param(tmpl);
2992     if (params == NULL
2993             || EVP_PKEY_fromdata(pctx, &dhp, EVP_PKEY_KEY_PARAMETERS, params) != 1)
2994         goto err;
2995
2996 err:
2997     OSSL_PARAM_free(params);
2998     OSSL_PARAM_BLD_free(tmpl);
2999     EVP_PKEY_CTX_free(pctx);
3000     BN_free(p);
3001     return dhp;
3002 }
3003
3004 static int ssl_security_cert_key(SSL *s, SSL_CTX *ctx, X509 *x, int op)
3005 {
3006     int secbits = -1;
3007     EVP_PKEY *pkey = X509_get0_pubkey(x);
3008     if (pkey) {
3009         /*
3010          * If no parameters this will return -1 and fail using the default
3011          * security callback for any non-zero security level. This will
3012          * reject keys which omit parameters but this only affects DSA and
3013          * omission of parameters is never (?) done in practice.
3014          */
3015         secbits = EVP_PKEY_get_security_bits(pkey);
3016     }
3017     if (s)
3018         return ssl_security(s, op, secbits, 0, x);
3019     else
3020         return ssl_ctx_security(ctx, op, secbits, 0, x);
3021 }
3022
3023 static int ssl_security_cert_sig(SSL *s, SSL_CTX *ctx, X509 *x, int op)
3024 {
3025     /* Lookup signature algorithm digest */
3026     int secbits, nid, pknid;
3027     /* Don't check signature if self signed */
3028     if ((X509_get_extension_flags(x) & EXFLAG_SS) != 0)
3029         return 1;
3030     if (!X509_get_signature_info(x, &nid, &pknid, &secbits, NULL))
3031         secbits = -1;
3032     /* If digest NID not defined use signature NID */
3033     if (nid == NID_undef)
3034         nid = pknid;
3035     if (s)
3036         return ssl_security(s, op, secbits, nid, x);
3037     else
3038         return ssl_ctx_security(ctx, op, secbits, nid, x);
3039 }
3040
3041 int ssl_security_cert(SSL *s, SSL_CTX *ctx, X509 *x, int vfy, int is_ee)
3042 {
3043     if (vfy)
3044         vfy = SSL_SECOP_PEER;
3045     if (is_ee) {
3046         if (!ssl_security_cert_key(s, ctx, x, SSL_SECOP_EE_KEY | vfy))
3047             return SSL_R_EE_KEY_TOO_SMALL;
3048     } else {
3049         if (!ssl_security_cert_key(s, ctx, x, SSL_SECOP_CA_KEY | vfy))
3050             return SSL_R_CA_KEY_TOO_SMALL;
3051     }
3052     if (!ssl_security_cert_sig(s, ctx, x, SSL_SECOP_CA_MD | vfy))
3053         return SSL_R_CA_MD_TOO_WEAK;
3054     return 1;
3055 }
3056
3057 /*
3058  * Check security of a chain, if |sk| includes the end entity certificate then
3059  * |x| is NULL. If |vfy| is 1 then we are verifying a peer chain and not sending
3060  * one to the peer. Return values: 1 if ok otherwise error code to use
3061  */
3062
3063 int ssl_security_cert_chain(SSL *s, STACK_OF(X509) *sk, X509 *x, int vfy)
3064 {
3065     int rv, start_idx, i;
3066     if (x == NULL) {
3067         x = sk_X509_value(sk, 0);
3068         start_idx = 1;
3069     } else
3070         start_idx = 0;
3071
3072     rv = ssl_security_cert(s, NULL, x, vfy, 1);
3073     if (rv != 1)
3074         return rv;
3075
3076     for (i = start_idx; i < sk_X509_num(sk); i++) {
3077         x = sk_X509_value(sk, i);
3078         rv = ssl_security_cert(s, NULL, x, vfy, 0);
3079         if (rv != 1)
3080             return rv;
3081     }
3082     return 1;
3083 }
3084
3085 /*
3086  * For TLS 1.2 servers check if we have a certificate which can be used
3087  * with the signature algorithm "lu" and return index of certificate.
3088  */
3089
3090 static int tls12_get_cert_sigalg_idx(const SSL *s, const SIGALG_LOOKUP *lu)
3091 {
3092     int sig_idx = lu->sig_idx;
3093     const SSL_CERT_LOOKUP *clu = ssl_cert_lookup_by_idx(sig_idx);
3094
3095     /* If not recognised or not supported by cipher mask it is not suitable */
3096     if (clu == NULL
3097             || (clu->amask & s->s3.tmp.new_cipher->algorithm_auth) == 0
3098             || (clu->nid == EVP_PKEY_RSA_PSS
3099                 && (s->s3.tmp.new_cipher->algorithm_mkey & SSL_kRSA) != 0))
3100         return -1;
3101
3102     return s->s3.tmp.valid_flags[sig_idx] & CERT_PKEY_VALID ? sig_idx : -1;
3103 }
3104
3105 /*
3106  * Checks the given cert against signature_algorithm_cert restrictions sent by
3107  * the peer (if any) as well as whether the hash from the sigalg is usable with
3108  * the key.
3109  * Returns true if the cert is usable and false otherwise.
3110  */
3111 static int check_cert_usable(SSL *s, const SIGALG_LOOKUP *sig, X509 *x,
3112                              EVP_PKEY *pkey)
3113 {
3114     const SIGALG_LOOKUP *lu;
3115     int mdnid, pknid, supported;
3116     size_t i;
3117     const char *mdname = NULL;
3118
3119     /*
3120      * If the given EVP_PKEY cannot support signing with this digest,
3121      * the answer is simply 'no'.
3122      */
3123     if (sig->hash != NID_undef)
3124         mdname = OBJ_nid2sn(sig->hash);
3125     supported = EVP_PKEY_digestsign_supports_digest(pkey, s->ctx->libctx,
3126                                                     mdname,
3127                                                     s->ctx->propq);
3128     if (supported <= 0)
3129         return 0;
3130
3131     /*
3132      * The TLS 1.3 signature_algorithms_cert extension places restrictions
3133      * on the sigalg with which the certificate was signed (by its issuer).
3134      */
3135     if (s->s3.tmp.peer_cert_sigalgs != NULL) {
3136         if (!X509_get_signature_info(x, &mdnid, &pknid, NULL, NULL))
3137             return 0;
3138         for (i = 0; i < s->s3.tmp.peer_cert_sigalgslen; i++) {
3139             lu = tls1_lookup_sigalg(s, s->s3.tmp.peer_cert_sigalgs[i]);
3140             if (lu == NULL)
3141                 continue;
3142
3143             /*
3144              * This does not differentiate between the
3145              * rsa_pss_pss_* and rsa_pss_rsae_* schemes since we do not
3146              * have a chain here that lets us look at the key OID in the
3147              * signing certificate.
3148              */
3149             if (mdnid == lu->hash && pknid == lu->sig)
3150                 return 1;
3151         }
3152         return 0;
3153     }
3154
3155     /*
3156      * Without signat_algorithms_cert, any certificate for which we have
3157      * a viable public key is permitted.
3158      */
3159     return 1;
3160 }
3161
3162 /*
3163  * Returns true if |s| has a usable certificate configured for use
3164  * with signature scheme |sig|.
3165  * "Usable" includes a check for presence as well as applying
3166  * the signature_algorithm_cert restrictions sent by the peer (if any).
3167  * Returns false if no usable certificate is found.
3168  */
3169 static int has_usable_cert(SSL *s, const SIGALG_LOOKUP *sig, int idx)
3170 {
3171     /* TLS 1.2 callers can override sig->sig_idx, but not TLS 1.3 callers. */
3172     if (idx == -1)
3173         idx = sig->sig_idx;
3174     if (!ssl_has_cert(s, idx))
3175         return 0;
3176
3177     return check_cert_usable(s, sig, s->cert->pkeys[idx].x509,
3178                              s->cert->pkeys[idx].privatekey);
3179 }
3180
3181 /*
3182  * Returns true if the supplied cert |x| and key |pkey| is usable with the
3183  * specified signature scheme |sig|, or false otherwise.
3184  */
3185 static int is_cert_usable(SSL *s, const SIGALG_LOOKUP *sig, X509 *x,
3186                           EVP_PKEY *pkey)
3187 {
3188     size_t idx;
3189
3190     if (ssl_cert_lookup_by_pkey(pkey, &idx) == NULL)
3191         return 0;
3192
3193     /* Check the key is consistent with the sig alg */
3194     if ((int)idx != sig->sig_idx)
3195         return 0;
3196
3197     return check_cert_usable(s, sig, x, pkey);
3198 }
3199
3200 /*
3201  * Find a signature scheme that works with the supplied certificate |x| and key
3202  * |pkey|. |x| and |pkey| may be NULL in which case we additionally look at our
3203  * available certs/keys to find one that works.
3204  */
3205 static const SIGALG_LOOKUP *find_sig_alg(SSL *s, X509 *x, EVP_PKEY *pkey)
3206 {
3207     const SIGALG_LOOKUP *lu = NULL;
3208     size_t i;
3209     int curve = -1;
3210     EVP_PKEY *tmppkey;
3211
3212     /* Look for a shared sigalgs matching possible certificates */
3213     for (i = 0; i < s->shared_sigalgslen; i++) {
3214         lu = s->shared_sigalgs[i];
3215
3216         /* Skip SHA1, SHA224, DSA and RSA if not PSS */
3217         if (lu->hash == NID_sha1
3218             || lu->hash == NID_sha224
3219             || lu->sig == EVP_PKEY_DSA
3220             || lu->sig == EVP_PKEY_RSA)
3221             continue;
3222         /* Check that we have a cert, and signature_algorithms_cert */
3223         if (!tls1_lookup_md(s->ctx, lu, NULL))
3224             continue;
3225         if ((pkey == NULL && !has_usable_cert(s, lu, -1))
3226                 || (pkey != NULL && !is_cert_usable(s, lu, x, pkey)))
3227             continue;
3228
3229         tmppkey = (pkey != NULL) ? pkey
3230                                  : s->cert->pkeys[lu->sig_idx].privatekey;
3231
3232         if (lu->sig == EVP_PKEY_EC) {
3233             if (curve == -1)
3234                 curve = ssl_get_EC_curve_nid(tmppkey);
3235             if (lu->curve != NID_undef && curve != lu->curve)
3236                 continue;
3237         } else if (lu->sig == EVP_PKEY_RSA_PSS) {
3238             /* validate that key is large enough for the signature algorithm */
3239             if (!rsa_pss_check_min_key_size(s->ctx, tmppkey, lu))
3240                 continue;
3241         }
3242         break;
3243     }
3244
3245     if (i == s->shared_sigalgslen)
3246         return NULL;
3247
3248     return lu;
3249 }
3250
3251 /*
3252  * Choose an appropriate signature algorithm based on available certificates
3253  * Sets chosen certificate and signature algorithm.
3254  *
3255  * For servers if we fail to find a required certificate it is a fatal error,
3256  * an appropriate error code is set and a TLS alert is sent.
3257  *
3258  * For clients fatalerrs is set to 0. If a certificate is not suitable it is not
3259  * a fatal error: we will either try another certificate or not present one
3260  * to the server. In this case no error is set.
3261  */
3262 int tls_choose_sigalg(SSL *s, int fatalerrs)
3263 {
3264     const SIGALG_LOOKUP *lu = NULL;
3265     int sig_idx = -1;
3266
3267     s->s3.tmp.cert = NULL;
3268     s->s3.tmp.sigalg = NULL;
3269
3270     if (SSL_IS_TLS13(s)) {
3271         lu = find_sig_alg(s, NULL, NULL);
3272         if (lu == NULL) {
3273             if (!fatalerrs)
3274                 return 1;
3275             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
3276                      SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM);
3277             return 0;
3278         }
3279     } else {
3280         /* If ciphersuite doesn't require a cert nothing to do */
3281         if (!(s->s3.tmp.new_cipher->algorithm_auth & SSL_aCERT))
3282             return 1;
3283         if (!s->server && !ssl_has_cert(s, s->cert->key - s->cert->pkeys))
3284                 return 1;
3285
3286         if (SSL_USE_SIGALGS(s)) {
3287             size_t i;
3288             if (s->s3.tmp.peer_sigalgs != NULL) {
3289                 int curve = -1;
3290
3291                 /* For Suite B need to match signature algorithm to curve */
3292                 if (tls1_suiteb(s))
3293                     curve = ssl_get_EC_curve_nid(s->cert->pkeys[SSL_PKEY_ECC]
3294                                                  .privatekey);
3295
3296                 /*
3297                  * Find highest preference signature algorithm matching
3298                  * cert type
3299                  */
3300                 for (i = 0; i < s->shared_sigalgslen; i++) {
3301                     lu = s->shared_sigalgs[i];
3302
3303                     if (s->server) {
3304                         if ((sig_idx = tls12_get_cert_sigalg_idx(s, lu)) == -1)
3305                             continue;
3306                     } else {
3307                         int cc_idx = s->cert->key - s->cert->pkeys;
3308
3309                         sig_idx = lu->sig_idx;
3310                         if (cc_idx != sig_idx)
3311                             continue;
3312                     }
3313                     /* Check that we have a cert, and sig_algs_cert */
3314                     if (!has_usable_cert(s, lu, sig_idx))
3315                         continue;
3316                     if (lu->sig == EVP_PKEY_RSA_PSS) {
3317                         /* validate that key is large enough for the signature algorithm */
3318                         EVP_PKEY *pkey = s->cert->pkeys[sig_idx].privatekey;
3319
3320                         if (!rsa_pss_check_min_key_size(s->ctx, pkey, lu))
3321                             continue;
3322                     }
3323                     if (curve == -1 || lu->curve == curve)
3324                         break;
3325                 }
3326 #ifndef OPENSSL_NO_GOST
3327                 /*
3328                  * Some Windows-based implementations do not send GOST algorithms indication
3329                  * in supported_algorithms extension, so when we have GOST-based ciphersuite,
3330                  * we have to assume GOST support.
3331                  */
3332                 if (i == s->shared_sigalgslen && s->s3.tmp.new_cipher->algorithm_auth & (SSL_aGOST01 | SSL_aGOST12)) {
3333                   if ((lu = tls1_get_legacy_sigalg(s, -1)) == NULL) {
3334                     if (!fatalerrs)
3335                       return 1;
3336                     SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
3337                              SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM);
3338                     return 0;
3339                   } else {
3340                     i = 0;
3341                     sig_idx = lu->sig_idx;
3342                   }
3343                 }
3344 #endif
3345                 if (i == s->shared_sigalgslen) {
3346                     if (!fatalerrs)
3347                         return 1;
3348                     SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
3349                              SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM);
3350                     return 0;
3351                 }
3352             } else {
3353                 /*
3354                  * If we have no sigalg use defaults
3355                  */
3356                 const uint16_t *sent_sigs;
3357                 size_t sent_sigslen;
3358
3359                 if ((lu = tls1_get_legacy_sigalg(s, -1)) == NULL) {
3360                     if (!fatalerrs)
3361                         return 1;
3362                     SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
3363                              SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM);
3364                     return 0;
3365                 }
3366
3367                 /* Check signature matches a type we sent */
3368                 sent_sigslen = tls12_get_psigalgs(s, 1, &sent_sigs);
3369                 for (i = 0; i < sent_sigslen; i++, sent_sigs++) {
3370                     if (lu->sigalg == *sent_sigs
3371                             && has_usable_cert(s, lu, lu->sig_idx))
3372                         break;
3373                 }
3374                 if (i == sent_sigslen) {
3375                     if (!fatalerrs)
3376                         return 1;
3377                     SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
3378                              SSL_R_WRONG_SIGNATURE_TYPE);
3379                     return 0;
3380                 }
3381             }
3382         } else {
3383             if ((lu = tls1_get_legacy_sigalg(s, -1)) == NULL) {
3384                 if (!fatalerrs)
3385                     return 1;
3386                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
3387                          SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM);
3388                 return 0;
3389             }
3390         }
3391     }
3392     if (sig_idx == -1)
3393         sig_idx = lu->sig_idx;
3394     s->s3.tmp.cert = &s->cert->pkeys[sig_idx];
3395     s->cert->key = s->s3.tmp.cert;
3396     s->s3.tmp.sigalg = lu;
3397     return 1;
3398 }
3399
3400 int SSL_CTX_set_tlsext_max_fragment_length(SSL_CTX *ctx, uint8_t mode)
3401 {
3402     if (mode != TLSEXT_max_fragment_length_DISABLED
3403             && !IS_MAX_FRAGMENT_LENGTH_EXT_VALID(mode)) {
3404         ERR_raise(ERR_LIB_SSL, SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH);
3405         return 0;
3406     }
3407
3408     ctx->ext.max_fragment_len_mode = mode;
3409     return 1;
3410 }
3411
3412 int SSL_set_tlsext_max_fragment_length(SSL *ssl, uint8_t mode)
3413 {
3414     if (mode != TLSEXT_max_fragment_length_DISABLED
3415             && !IS_MAX_FRAGMENT_LENGTH_EXT_VALID(mode)) {
3416         ERR_raise(ERR_LIB_SSL, SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH);
3417         return 0;
3418     }
3419
3420     ssl->ext.max_fragment_len_mode = mode;
3421     return 1;
3422 }
3423
3424 uint8_t SSL_SESSION_get_max_fragment_length(const SSL_SESSION *session)
3425 {
3426     return session->ext.max_fragment_len_mode;
3427 }
3428
3429 /*
3430  * Helper functions for HMAC access with legacy support included.
3431  */
3432 SSL_HMAC *ssl_hmac_new(const SSL_CTX *ctx)
3433 {
3434     SSL_HMAC *ret = OPENSSL_zalloc(sizeof(*ret));
3435     EVP_MAC *mac = NULL;
3436
3437     if (ret == NULL)
3438         return NULL;
3439 #ifndef OPENSSL_NO_DEPRECATED_3_0
3440     if (ctx->ext.ticket_key_evp_cb == NULL
3441             && ctx->ext.ticket_key_cb != NULL) {
3442         if (!ssl_hmac_old_new(ret))
3443             goto err;
3444         return ret;
3445     }
3446 #endif
3447     mac = EVP_MAC_fetch(ctx->libctx, "HMAC", ctx->propq);
3448     if (mac == NULL || (ret->ctx = EVP_MAC_CTX_new(mac)) == NULL)
3449         goto err;
3450     EVP_MAC_free(mac);
3451     return ret;
3452  err:
3453     EVP_MAC_CTX_free(ret->ctx);
3454     EVP_MAC_free(mac);
3455     OPENSSL_free(ret);
3456     return NULL;
3457 }
3458
3459 void ssl_hmac_free(SSL_HMAC *ctx)
3460 {
3461     if (ctx != NULL) {
3462         EVP_MAC_CTX_free(ctx->ctx);
3463 #ifndef OPENSSL_NO_DEPRECATED_3_0
3464         ssl_hmac_old_free(ctx);
3465 #endif
3466         OPENSSL_free(ctx);
3467     }
3468 }
3469
3470 EVP_MAC_CTX *ssl_hmac_get0_EVP_MAC_CTX(SSL_HMAC *ctx)
3471 {
3472     return ctx->ctx;
3473 }
3474
3475 int ssl_hmac_init(SSL_HMAC *ctx, void *key, size_t len, char *md)
3476 {
3477     OSSL_PARAM params[2], *p = params;
3478
3479     if (ctx->ctx != NULL) {
3480         *p++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST, md, 0);
3481         *p = OSSL_PARAM_construct_end();
3482         if (EVP_MAC_init(ctx->ctx, key, len, params))
3483             return 1;
3484     }
3485 #ifndef OPENSSL_NO_DEPRECATED_3_0
3486     if (ctx->old_ctx != NULL)
3487         return ssl_hmac_old_init(ctx, key, len, md);
3488 #endif
3489     return 0;
3490 }
3491
3492 int ssl_hmac_update(SSL_HMAC *ctx, const unsigned char *data, size_t len)
3493 {
3494     if (ctx->ctx != NULL)
3495         return EVP_MAC_update(ctx->ctx, data, len);
3496 #ifndef OPENSSL_NO_DEPRECATED_3_0
3497     if (ctx->old_ctx != NULL)
3498         return ssl_hmac_old_update(ctx, data, len);
3499 #endif
3500     return 0;
3501 }
3502
3503 int ssl_hmac_final(SSL_HMAC *ctx, unsigned char *md, size_t *len,
3504                    size_t max_size)
3505 {
3506     if (ctx->ctx != NULL)
3507         return EVP_MAC_final(ctx->ctx, md, len, max_size);
3508 #ifndef OPENSSL_NO_DEPRECATED_3_0
3509     if (ctx->old_ctx != NULL)
3510         return ssl_hmac_old_final(ctx, md, len);
3511 #endif
3512     return 0;
3513 }
3514
3515 size_t ssl_hmac_size(const SSL_HMAC *ctx)
3516 {
3517     if (ctx->ctx != NULL)
3518         return EVP_MAC_CTX_get_mac_size(ctx->ctx);
3519 #ifndef OPENSSL_NO_DEPRECATED_3_0
3520     if (ctx->old_ctx != NULL)
3521         return ssl_hmac_old_size(ctx);
3522 #endif
3523     return 0;
3524 }
3525
3526 int ssl_get_EC_curve_nid(const EVP_PKEY *pkey)
3527 {
3528     char gname[OSSL_MAX_NAME_SIZE];
3529
3530     if (EVP_PKEY_get_group_name(pkey, gname, sizeof(gname), NULL) > 0)
3531         return OBJ_txt2nid(gname);
3532
3533     return NID_undef;
3534 }