ssl/t1_lib.c

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