ssl/t1_lib.c

   1 /*
   2  * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <openssl/objects.h>
  13 #include <openssl/evp.h>
  14 #include <openssl/hmac.h>
  15 #include <openssl/ocsp.h>
  16 #include <openssl/conf.h>
  17 #include <openssl/x509v3.h>
  18 #include <openssl/dh.h>
  19 #include <openssl/bn.h>
  20 #include "internal/nelem.h"
  21 #include "ssl_locl.h"
  22 #include <openssl/ct.h>
  23
  24 SSL3_ENC_METHOD const TLSv1_enc_data = {
  25     tls1_enc,
  26     tls1_mac,
  27     tls1_setup_key_block,
  28     tls1_generate_master_secret,
  29     tls1_change_cipher_state,
  30     tls1_final_finish_mac,
  31     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
  32     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
  33     tls1_alert_code,
  34     tls1_export_keying_material,
  35     0,
  36     ssl3_set_handshake_header,
  37     tls_close_construct_packet,
  38     ssl3_handshake_write
  39 };
  40
  41 SSL3_ENC_METHOD const TLSv1_1_enc_data = {
  42     tls1_enc,
  43     tls1_mac,
  44     tls1_setup_key_block,
  45     tls1_generate_master_secret,
  46     tls1_change_cipher_state,
  47     tls1_final_finish_mac,
  48     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
  49     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
  50     tls1_alert_code,
  51     tls1_export_keying_material,
  52     SSL_ENC_FLAG_EXPLICIT_IV,
  53     ssl3_set_handshake_header,
  54     tls_close_construct_packet,
  55     ssl3_handshake_write
  56 };
  57
  58 SSL3_ENC_METHOD const TLSv1_2_enc_data = {
  59     tls1_enc,
  60     tls1_mac,
  61     tls1_setup_key_block,
  62     tls1_generate_master_secret,
  63     tls1_change_cipher_state,
  64     tls1_final_finish_mac,
  65     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
  66     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
  67     tls1_alert_code,
  68     tls1_export_keying_material,
  69     SSL_ENC_FLAG_EXPLICIT_IV | SSL_ENC_FLAG_SIGALGS | SSL_ENC_FLAG_SHA256_PRF
  70         | SSL_ENC_FLAG_TLS1_2_CIPHERS,
  71     ssl3_set_handshake_header,
  72     tls_close_construct_packet,
  73     ssl3_handshake_write
  74 };
  75
  76 SSL3_ENC_METHOD const TLSv1_3_enc_data = {
  77     tls13_enc,
  78     tls1_mac,
  79     tls13_setup_key_block,
  80     tls13_generate_master_secret,
  81     tls13_change_cipher_state,
  82     tls13_final_finish_mac,
  83     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
  84     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
  85     tls13_alert_code,
  86     tls13_export_keying_material,
  87     SSL_ENC_FLAG_SIGALGS | SSL_ENC_FLAG_SHA256_PRF,
  88     ssl3_set_handshake_header,
  89     tls_close_construct_packet,
  90     ssl3_handshake_write
  91 };
  92
  93 long tls1_default_timeout(void)
  94 {
  95     /*
  96      * 2 hours, the 24 hours mentioned in the TLSv1 spec is way too long for
  97      * http, the cache would over fill
  98      */
  99     return (60 * 60 * 2);
 100 }
 101
 102 int tls1_new(SSL *s)
 103 {
 104     if (!ssl3_new(s))
 105         return 0;
 106     if (!s->method->ssl_clear(s))
 107         return 0;
 108
 109     return 1;
 110 }
 111
 112 void tls1_free(SSL *s)
 113 {
 114     OPENSSL_free(s->ext.session_ticket);
 115     ssl3_free(s);
 116 }
 117
 118 int tls1_clear(SSL *s)
 119 {
 120     if (!ssl3_clear(s))
 121         return 0;
 122
 123     if (s->method->version == TLS_ANY_VERSION)
 124         s->version = TLS_MAX_VERSION;
 125     else
 126         s->version = s->method->version;
 127
 128     return 1;
 129 }
 130
 131 #ifndef OPENSSL_NO_EC
 132
 133 /*
 134  * Table of curve information.
 135  * Do not delete entries or reorder this array! It is used as a lookup
 136  * table: the index of each entry is one less than the TLS curve id.
 137  */
 138 static const TLS_GROUP_INFO nid_list[] = {
 139     {NID_sect163k1, 80, TLS_CURVE_CHAR2}, /* sect163k1 (1) */
 140     {NID_sect163r1, 80, TLS_CURVE_CHAR2}, /* sect163r1 (2) */
 141     {NID_sect163r2, 80, TLS_CURVE_CHAR2}, /* sect163r2 (3) */
 142     {NID_sect193r1, 80, TLS_CURVE_CHAR2}, /* sect193r1 (4) */
 143     {NID_sect193r2, 80, TLS_CURVE_CHAR2}, /* sect193r2 (5) */
 144     {NID_sect233k1, 112, TLS_CURVE_CHAR2}, /* sect233k1 (6) */
 145     {NID_sect233r1, 112, TLS_CURVE_CHAR2}, /* sect233r1 (7) */
 146     {NID_sect239k1, 112, TLS_CURVE_CHAR2}, /* sect239k1 (8) */
 147     {NID_sect283k1, 128, TLS_CURVE_CHAR2}, /* sect283k1 (9) */
 148     {NID_sect283r1, 128, TLS_CURVE_CHAR2}, /* sect283r1 (10) */
 149     {NID_sect409k1, 192, TLS_CURVE_CHAR2}, /* sect409k1 (11) */
 150     {NID_sect409r1, 192, TLS_CURVE_CHAR2}, /* sect409r1 (12) */
 151     {NID_sect571k1, 256, TLS_CURVE_CHAR2}, /* sect571k1 (13) */
 152     {NID_sect571r1, 256, TLS_CURVE_CHAR2}, /* sect571r1 (14) */
 153     {NID_secp160k1, 80, TLS_CURVE_PRIME}, /* secp160k1 (15) */
 154     {NID_secp160r1, 80, TLS_CURVE_PRIME}, /* secp160r1 (16) */
 155     {NID_secp160r2, 80, TLS_CURVE_PRIME}, /* secp160r2 (17) */
 156     {NID_secp192k1, 80, TLS_CURVE_PRIME}, /* secp192k1 (18) */
 157     {NID_X9_62_prime192v1, 80, TLS_CURVE_PRIME}, /* secp192r1 (19) */
 158     {NID_secp224k1, 112, TLS_CURVE_PRIME}, /* secp224k1 (20) */
 159     {NID_secp224r1, 112, TLS_CURVE_PRIME}, /* secp224r1 (21) */
 160     {NID_secp256k1, 128, TLS_CURVE_PRIME}, /* secp256k1 (22) */
 161     {NID_X9_62_prime256v1, 128, TLS_CURVE_PRIME}, /* secp256r1 (23) */
 162     {NID_secp384r1, 192, TLS_CURVE_PRIME}, /* secp384r1 (24) */
 163     {NID_secp521r1, 256, TLS_CURVE_PRIME}, /* secp521r1 (25) */
 164     {NID_brainpoolP256r1, 128, TLS_CURVE_PRIME}, /* brainpoolP256r1 (26) */
 165     {NID_brainpoolP384r1, 192, TLS_CURVE_PRIME}, /* brainpoolP384r1 (27) */
 166     {NID_brainpoolP512r1, 256, TLS_CURVE_PRIME}, /* brainpool512r1 (28) */
 167     {EVP_PKEY_X25519, 128, TLS_CURVE_CUSTOM}, /* X25519 (29) */
 168 };
 169
 170 static const unsigned char ecformats_default[] = {
 171     TLSEXT_ECPOINTFORMAT_uncompressed,
 172     TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime,
 173     TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2
 174 };
 175
 176 /* The default curves */
 177 static const uint16_t eccurves_default[] = {
 178     29,                      /* X25519 (29) */
 179     23,                      /* secp256r1 (23) */
 180     25,                      /* secp521r1 (25) */
 181     24,                      /* secp384r1 (24) */
 182 };
 183
 184 static const uint16_t suiteb_curves[] = {
 185     TLSEXT_curve_P_256,
 186     TLSEXT_curve_P_384
 187 };
 188
 189 const TLS_GROUP_INFO *tls1_group_id_lookup(uint16_t group_id)
 190 {
 191     /* ECC curves from RFC 4492 and RFC 7027 */
 192     if (group_id < 1 || group_id > OSSL_NELEM(nid_list))
 193         return NULL;
 194     return &nid_list[group_id - 1];
 195 }
 196
 197 static uint16_t tls1_nid2group_id(int nid)
 198 {
 199     size_t i;
 200     for (i = 0; i < OSSL_NELEM(nid_list); i++) {
 201         if (nid_list[i].nid == nid)
 202             return i + 1;
 203     }
 204     return 0;
 205 }
 206
 207 /*
 208  * Set *pgroups to the supported groups list and *pgroupslen to
 209  * the number of groups supported.
 210  */
 211 void tls1_get_supported_groups(SSL *s, const uint16_t **pgroups,
 212                                size_t *pgroupslen)
 213 {
 214
 215     /* For Suite B mode only include P-256, P-384 */
 216     switch (tls1_suiteb(s)) {
 217     case SSL_CERT_FLAG_SUITEB_128_LOS:
 218         *pgroups = suiteb_curves;
 219         *pgroupslen = OSSL_NELEM(suiteb_curves);
 220         break;
 221
 222     case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY:
 223         *pgroups = suiteb_curves;
 224         *pgroupslen = 1;
 225         break;
 226
 227     case SSL_CERT_FLAG_SUITEB_192_LOS:
 228         *pgroups = suiteb_curves + 1;
 229         *pgroupslen = 1;
 230         break;
 231
 232     default:
 233         if (s->ext.supportedgroups == NULL) {
 234             *pgroups = eccurves_default;
 235             *pgroupslen = OSSL_NELEM(eccurves_default);
 236         } else {
 237             *pgroups = s->ext.supportedgroups;
 238             *pgroupslen = s->ext.supportedgroups_len;
 239         }
 240         break;
 241     }
 242 }
 243
 244 /* See if curve is allowed by security callback */
 245 int tls_curve_allowed(SSL *s, uint16_t curve, int op)
 246 {
 247     const TLS_GROUP_INFO *cinfo = tls1_group_id_lookup(curve);
 248     unsigned char ctmp[2];
 249
 250     if (cinfo == NULL)
 251         return 0;
 252 # ifdef OPENSSL_NO_EC2M
 253     if (cinfo->flags & TLS_CURVE_CHAR2)
 254         return 0;
 255 # endif
 256     ctmp[0] = curve >> 8;
 257     ctmp[1] = curve & 0xff;
 258     return ssl_security(s, op, cinfo->secbits, cinfo->nid, (void *)ctmp);
 259 }
 260
 261 /* Return 1 if "id" is in "list" */
 262 static int tls1_in_list(uint16_t id, const uint16_t *list, size_t listlen)
 263 {
 264     size_t i;
 265     for (i = 0; i < listlen; i++)
 266         if (list[i] == id)
 267             return 1;
 268     return 0;
 269 }
 270
 271 /*-
 272  * For nmatch >= 0, return the id of the |nmatch|th shared group or 0
 273  * if there is no match.
 274  * For nmatch == -1, return number of matches
 275  * For nmatch == -2, return the id of the group to use for
 276  * a tmp key, or 0 if there is no match.
 277  */
 278 uint16_t tls1_shared_group(SSL *s, int nmatch)
 279 {
 280     const uint16_t *pref, *supp;
 281     size_t num_pref, num_supp, i;
 282     int k;
 283
 284     /* Can't do anything on client side */
 285     if (s->server == 0)
 286         return 0;
 287     if (nmatch == -2) {
 288         if (tls1_suiteb(s)) {
 289             /*
 290              * For Suite B ciphersuite determines curve: we already know
 291              * these are acceptable due to previous checks.
 292              */
 293             unsigned long cid = s->s3->tmp.new_cipher->id;
 294
 295             if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)
 296                 return TLSEXT_curve_P_256;
 297             if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384)
 298                 return TLSEXT_curve_P_384;
 299             /* Should never happen */
 300             return 0;
 301         }
 302         /* If not Suite B just return first preference shared curve */
 303         nmatch = 0;
 304     }
 305     /*
 306      * If server preference set, our groups are the preference order
 307      * otherwise peer decides.
 308      */
 309     if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE) {
 310         tls1_get_supported_groups(s, &pref, &num_pref);
 311         tls1_get_peer_groups(s, &supp, &num_supp);
 312     } else {
 313         tls1_get_peer_groups(s, &pref, &num_pref);
 314         tls1_get_supported_groups(s, &supp, &num_supp);
 315     }
 316
 317     for (k = 0, i = 0; i < num_pref; i++) {
 318         uint16_t id = pref[i];
 319
 320         if (!tls1_in_list(id, supp, num_supp)
 321             || !tls_curve_allowed(s, id, SSL_SECOP_CURVE_SHARED))
 322                     continue;
 323         if (nmatch == k)
 324             return id;
 325          k++;
 326     }
 327     if (nmatch == -1)
 328         return k;
 329     /* Out of range (nmatch > k). */
 330     return 0;
 331 }
 332
 333 int tls1_set_groups(uint16_t **pext, size_t *pextlen,
 334                     int *groups, size_t ngroups)
 335 {
 336     uint16_t *glist;
 337     size_t i;
 338     /*
 339      * Bitmap of groups included to detect duplicates: only works while group
 340      * ids < 32
 341      */
 342     unsigned long dup_list = 0;
 343     glist = OPENSSL_malloc(ngroups * sizeof(*glist));
 344     if (glist == NULL)
 345         return 0;
 346     for (i = 0; i < ngroups; i++) {
 347         unsigned long idmask;
 348         uint16_t id;
 349         /* TODO(TLS1.3): Convert for DH groups */
 350         id = tls1_nid2group_id(groups[i]);
 351         idmask = 1L << id;
 352         if (!id || (dup_list & idmask)) {
 353             OPENSSL_free(glist);
 354             return 0;
 355         }
 356         dup_list |= idmask;
 357         glist[i] = id;
 358     }
 359     OPENSSL_free(*pext);
 360     *pext = glist;
 361     *pextlen = ngroups;
 362     return 1;
 363 }
 364
 365 # define MAX_CURVELIST   28
 366
 367 typedef struct {
 368     size_t nidcnt;
 369     int nid_arr[MAX_CURVELIST];
 370 } nid_cb_st;
 371
 372 static int nid_cb(const char *elem, int len, void *arg)
 373 {
 374     nid_cb_st *narg = arg;
 375     size_t i;
 376     int nid;
 377     char etmp[20];
 378     if (elem == NULL)
 379         return 0;
 380     if (narg->nidcnt == MAX_CURVELIST)
 381         return 0;
 382     if (len > (int)(sizeof(etmp) - 1))
 383         return 0;
 384     memcpy(etmp, elem, len);
 385     etmp[len] = 0;
 386     nid = EC_curve_nist2nid(etmp);
 387     if (nid == NID_undef)
 388         nid = OBJ_sn2nid(etmp);
 389     if (nid == NID_undef)
 390         nid = OBJ_ln2nid(etmp);
 391     if (nid == NID_undef)
 392         return 0;
 393     for (i = 0; i < narg->nidcnt; i++)
 394         if (narg->nid_arr[i] == nid)
 395             return 0;
 396     narg->nid_arr[narg->nidcnt++] = nid;
 397     return 1;
 398 }
 399
 400 /* Set groups based on a colon separate list */
 401 int tls1_set_groups_list(uint16_t **pext, size_t *pextlen, const char *str)
 402 {
 403     nid_cb_st ncb;
 404     ncb.nidcnt = 0;
 405     if (!CONF_parse_list(str, ':', 1, nid_cb, &ncb))
 406         return 0;
 407     if (pext == NULL)
 408         return 1;
 409     return tls1_set_groups(pext, pextlen, ncb.nid_arr, ncb.nidcnt);
 410 }
 411 /* Return group id of a key */
 412 static uint16_t tls1_get_group_id(EVP_PKEY *pkey)
 413 {
 414     EC_KEY *ec = EVP_PKEY_get0_EC_KEY(pkey);
 415     const EC_GROUP *grp;
 416
 417     if (ec == NULL)
 418         return 0;
 419     grp = EC_KEY_get0_group(ec);
 420     return tls1_nid2group_id(EC_GROUP_get_curve_name(grp));
 421 }
 422
 423 /* Check a key is compatible with compression extension */
 424 static int tls1_check_pkey_comp(SSL *s, EVP_PKEY *pkey)
 425 {
 426     const EC_KEY *ec;
 427     const EC_GROUP *grp;
 428     unsigned char comp_id;
 429     size_t i;
 430
 431     /* If not an EC key nothing to check */
 432     if (EVP_PKEY_id(pkey) != EVP_PKEY_EC)
 433         return 1;
 434     ec = EVP_PKEY_get0_EC_KEY(pkey);
 435     grp = EC_KEY_get0_group(ec);
 436
 437     /* Get required compression id */
 438     if (EC_KEY_get_conv_form(ec) == POINT_CONVERSION_UNCOMPRESSED) {
 439             comp_id = TLSEXT_ECPOINTFORMAT_uncompressed;
 440     } else if (SSL_IS_TLS13(s)) {
 441             /* Compression not allowed in TLS 1.3 */
 442             return 0;
 443     } else {
 444         int field_type = EC_METHOD_get_field_type(EC_GROUP_method_of(grp));
 445
 446         if (field_type == NID_X9_62_prime_field)
 447             comp_id = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime;
 448         else if (field_type == NID_X9_62_prime_field)
 449             comp_id = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2;
 450         else
 451             return 0;
 452     }
 453     /*
 454      * If point formats extension present check it, otherwise everything is
 455      * supported (see RFC4492).
 456      */
 457     if (s->session->ext.ecpointformats == NULL)
 458         return 1;
 459
 460     for (i = 0; i < s->session->ext.ecpointformats_len; i++) {
 461         if (s->session->ext.ecpointformats[i] == comp_id)
 462             return 1;
 463     }
 464     return 0;
 465 }
 466
 467 /* Check a group id matches preferences */
 468 int tls1_check_group_id(SSL *s, uint16_t group_id)
 469     {
 470     const uint16_t *groups;
 471     size_t groups_len;
 472
 473     if (group_id == 0)
 474         return 0;
 475
 476     /* Check for Suite B compliance */
 477     if (tls1_suiteb(s) && s->s3->tmp.new_cipher != NULL) {
 478         unsigned long cid = s->s3->tmp.new_cipher->id;
 479
 480         if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256) {
 481             if (group_id != TLSEXT_curve_P_256)
 482                 return 0;
 483         } else if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384) {
 484             if (group_id != TLSEXT_curve_P_384)
 485                 return 0;
 486         } else {
 487             /* Should never happen */
 488             return 0;
 489         }
 490     }
 491
 492     /* Check group is one of our preferences */
 493     tls1_get_supported_groups(s, &groups, &groups_len);
 494     if (!tls1_in_list(group_id, groups, groups_len))
 495         return 0;
 496
 497     if (!tls_curve_allowed(s, group_id, SSL_SECOP_CURVE_CHECK))
 498         return 0;
 499
 500     /* For clients, nothing more to check */
 501     if (!s->server)
 502         return 1;
 503
 504     /* Check group is one of peers preferences */
 505     tls1_get_peer_groups(s, &groups, &groups_len);
 506
 507     /*
 508      * RFC 4492 does not require the supported elliptic curves extension
 509      * so if it is not sent we can just choose any curve.
 510      * It is invalid to send an empty list in the supported groups
 511      * extension, so groups_len == 0 always means no extension.
 512      */
 513     if (groups_len == 0)
 514             return 1;
 515     return tls1_in_list(group_id, groups, groups_len);
 516 }
 517
 518 void tls1_get_formatlist(SSL *s, const unsigned char **pformats,
 519                          size_t *num_formats)
 520 {
 521     /*
 522      * If we have a custom point format list use it otherwise use default
 523      */
 524     if (s->ext.ecpointformats) {
 525         *pformats = s->ext.ecpointformats;
 526         *num_formats = s->ext.ecpointformats_len;
 527     } else {
 528         *pformats = ecformats_default;
 529         /* For Suite B we don't support char2 fields */
 530         if (tls1_suiteb(s))
 531             *num_formats = sizeof(ecformats_default) - 1;
 532         else
 533             *num_formats = sizeof(ecformats_default);
 534     }
 535 }
 536
 537 /*
 538  * Check cert parameters compatible with extensions: currently just checks EC
 539  * certificates have compatible curves and compression.
 540  */
 541 static int tls1_check_cert_param(SSL *s, X509 *x, int check_ee_md)
 542 {
 543     uint16_t group_id;
 544     EVP_PKEY *pkey;
 545     pkey = X509_get0_pubkey(x);
 546     if (pkey == NULL)
 547         return 0;
 548     /* If not EC nothing to do */
 549     if (EVP_PKEY_id(pkey) != EVP_PKEY_EC)
 550         return 1;
 551     /* Check compression */
 552     if (!tls1_check_pkey_comp(s, pkey))
 553         return 0;
 554     group_id = tls1_get_group_id(pkey);
 555     if (!tls1_check_group_id(s, group_id))
 556         return 0;
 557     /*
 558      * Special case for suite B. We *MUST* sign using SHA256+P-256 or
 559      * SHA384+P-384.
 560      */
 561     if (check_ee_md && tls1_suiteb(s)) {
 562         int check_md;
 563         size_t i;
 564         CERT *c = s->cert;
 565
 566         /* Check to see we have necessary signing algorithm */
 567         if (group_id == TLSEXT_curve_P_256)
 568             check_md = NID_ecdsa_with_SHA256;
 569         else if (group_id == TLSEXT_curve_P_384)
 570             check_md = NID_ecdsa_with_SHA384;
 571         else
 572             return 0;           /* Should never happen */
 573         for (i = 0; i < c->shared_sigalgslen; i++) {
 574             if (check_md == c->shared_sigalgs[i]->sigandhash)
 575                 return 1;;
 576         }
 577         return 0;
 578     }
 579     return 1;
 580 }
 581
 582 /*
 583  * tls1_check_ec_tmp_key - Check EC temporary key compatibility
 584  * @s: SSL connection
 585  * @cid: Cipher ID we're considering using
 586  *
 587  * Checks that the kECDHE cipher suite we're considering using
 588  * is compatible with the client extensions.
 589  *
 590  * Returns 0 when the cipher can't be used or 1 when it can.
 591  */
 592 int tls1_check_ec_tmp_key(SSL *s, unsigned long cid)
 593 {
 594     /* If not Suite B just need a shared group */
 595     if (!tls1_suiteb(s))
 596         return tls1_shared_group(s, 0) != 0;
 597     /*
 598      * If Suite B, AES128 MUST use P-256 and AES256 MUST use P-384, no other
 599      * curves permitted.
 600      */
 601     if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)
 602         return tls1_check_group_id(s, TLSEXT_curve_P_256);
 603     if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384)
 604         return tls1_check_group_id(s, TLSEXT_curve_P_384);
 605
 606     return 0;
 607 }
 608
 609 #else
 610
 611 static int tls1_check_cert_param(SSL *s, X509 *x, int set_ee_md)
 612 {
 613     return 1;
 614 }
 615
 616 #endif                          /* OPENSSL_NO_EC */
 617
 618 /* Default sigalg schemes */
 619 static const uint16_t tls12_sigalgs[] = {
 620 #ifndef OPENSSL_NO_EC
 621     TLSEXT_SIGALG_ecdsa_secp256r1_sha256,
 622     TLSEXT_SIGALG_ecdsa_secp384r1_sha384,
 623     TLSEXT_SIGALG_ecdsa_secp521r1_sha512,
 624     TLSEXT_SIGALG_ed25519,
 625 #endif
 626
 627     TLSEXT_SIGALG_rsa_pss_sha256,
 628     TLSEXT_SIGALG_rsa_pss_sha384,
 629     TLSEXT_SIGALG_rsa_pss_sha512,
 630
 631     TLSEXT_SIGALG_rsa_pkcs1_sha256,
 632     TLSEXT_SIGALG_rsa_pkcs1_sha384,
 633     TLSEXT_SIGALG_rsa_pkcs1_sha512,
 634
 635 #ifndef OPENSSL_NO_EC
 636     TLSEXT_SIGALG_ecdsa_sha224,
 637     TLSEXT_SIGALG_ecdsa_sha1,
 638 #endif
 639     TLSEXT_SIGALG_rsa_pkcs1_sha224,
 640     TLSEXT_SIGALG_rsa_pkcs1_sha1,
 641 #ifndef OPENSSL_NO_DSA
 642     TLSEXT_SIGALG_dsa_sha224,
 643     TLSEXT_SIGALG_dsa_sha1,
 644
 645     TLSEXT_SIGALG_dsa_sha256,
 646     TLSEXT_SIGALG_dsa_sha384,
 647     TLSEXT_SIGALG_dsa_sha512
 648 #endif
 649 };
 650
 651 #ifndef OPENSSL_NO_EC
 652 static const uint16_t suiteb_sigalgs[] = {
 653     TLSEXT_SIGALG_ecdsa_secp256r1_sha256,
 654     TLSEXT_SIGALG_ecdsa_secp384r1_sha384
 655 };
 656 #endif
 657
 658 static const SIGALG_LOOKUP sigalg_lookup_tbl[] = {
 659 #ifndef OPENSSL_NO_EC
 660     {"ecdsa_secp256r1_sha256", TLSEXT_SIGALG_ecdsa_secp256r1_sha256,
 661      NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
 662      NID_ecdsa_with_SHA256, NID_X9_62_prime256v1},
 663     {"ecdsa_secp384r1_sha384", TLSEXT_SIGALG_ecdsa_secp384r1_sha384,
 664      NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
 665      NID_ecdsa_with_SHA384, NID_secp384r1},
 666     {"ecdsa_secp521r1_sha512", TLSEXT_SIGALG_ecdsa_secp521r1_sha512,
 667      NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
 668      NID_ecdsa_with_SHA512, NID_secp521r1},
 669     {"ed25519", TLSEXT_SIGALG_ed25519,
 670      NID_undef, -1, EVP_PKEY_ED25519, SSL_PKEY_ED25519,
 671      NID_undef, NID_undef},
 672     {NULL, TLSEXT_SIGALG_ecdsa_sha224,
 673      NID_sha224, SSL_MD_SHA224_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
 674      NID_ecdsa_with_SHA224, NID_undef},
 675     {NULL, TLSEXT_SIGALG_ecdsa_sha1,
 676      NID_sha1, SSL_MD_SHA1_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
 677      NID_ecdsa_with_SHA1, NID_undef},
 678 #endif
 679     {"rsa_pss_sha256", TLSEXT_SIGALG_rsa_pss_sha256,
 680      NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA_PSS_SIGN,
 681      NID_undef, NID_undef},
 682     {"rsa_pss_sha384", TLSEXT_SIGALG_rsa_pss_sha384,
 683      NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA_PSS_SIGN,
 684      NID_undef, NID_undef},
 685     {"rsa_pss_sha512", TLSEXT_SIGALG_rsa_pss_sha512,
 686      NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA_PSS_SIGN,
 687      NID_undef, NID_undef},
 688     {"rsa_pkcs1_sha256", TLSEXT_SIGALG_rsa_pkcs1_sha256,
 689      NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,
 690      NID_sha256WithRSAEncryption, NID_undef},
 691     {"rsa_pkcs1_sha384", TLSEXT_SIGALG_rsa_pkcs1_sha384,
 692      NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,
 693      NID_sha384WithRSAEncryption, NID_undef},
 694     {"rsa_pkcs1_sha512", TLSEXT_SIGALG_rsa_pkcs1_sha512,
 695      NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,
 696      NID_sha512WithRSAEncryption, NID_undef},
 697     {"rsa_pkcs1_sha224", TLSEXT_SIGALG_rsa_pkcs1_sha224,
 698      NID_sha224, SSL_MD_SHA224_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,
 699      NID_sha224WithRSAEncryption, NID_undef},
 700     {"rsa_pkcs1_sha1", TLSEXT_SIGALG_rsa_pkcs1_sha1,
 701      NID_sha1, SSL_MD_SHA1_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,
 702      NID_sha1WithRSAEncryption, NID_undef},
 703 #ifndef OPENSSL_NO_DSA
 704     {NULL, TLSEXT_SIGALG_dsa_sha256,
 705      NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,
 706      NID_dsa_with_SHA256, NID_undef},
 707     {NULL, TLSEXT_SIGALG_dsa_sha384,
 708      NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,
 709      NID_undef, NID_undef},
 710     {NULL, TLSEXT_SIGALG_dsa_sha512,
 711      NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,
 712      NID_undef, NID_undef},
 713     {NULL, TLSEXT_SIGALG_dsa_sha224,
 714      NID_sha224, SSL_MD_SHA224_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,
 715      NID_undef, NID_undef},
 716     {NULL, TLSEXT_SIGALG_dsa_sha1,
 717      NID_sha1, SSL_MD_SHA1_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,
 718      NID_dsaWithSHA1, NID_undef},
 719 #endif
 720 #ifndef OPENSSL_NO_GOST
 721     {NULL, TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256,
 722      NID_id_GostR3411_2012_256, SSL_MD_GOST12_256_IDX,
 723      NID_id_GostR3410_2012_256, SSL_PKEY_GOST12_256,
 724      NID_undef, NID_undef},
 725     {NULL, TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512,
 726      NID_id_GostR3411_2012_512, SSL_MD_GOST12_512_IDX,
 727      NID_id_GostR3410_2012_512, SSL_PKEY_GOST12_512,
 728      NID_undef, NID_undef},
 729     {NULL, TLSEXT_SIGALG_gostr34102001_gostr3411,
 730      NID_id_GostR3411_94, SSL_MD_GOST94_IDX,
 731      NID_id_GostR3410_2001, SSL_PKEY_GOST01,
 732      NID_undef, NID_undef}
 733 #endif
 734 };
 735 /* Legacy sigalgs for TLS < 1.2 RSA TLS signatures */
 736 static const SIGALG_LOOKUP legacy_rsa_sigalg = {
 737     "rsa_pkcs1_md5_sha1", 0,
 738      NID_md5_sha1, SSL_MD_MD5_SHA1_IDX,
 739      EVP_PKEY_RSA, SSL_PKEY_RSA,
 740      NID_undef, NID_undef
 741 };
 742
 743 /*
 744  * Default signature algorithm values used if signature algorithms not present.
 745  * From RFC5246. Note: order must match certificate index order.
 746  */
 747 static const uint16_t tls_default_sigalg[] = {
 748     TLSEXT_SIGALG_rsa_pkcs1_sha1, /* SSL_PKEY_RSA */
 749     0, /* SSL_PKEY_RSA_PSS_SIGN */
 750     TLSEXT_SIGALG_dsa_sha1, /* SSL_PKEY_DSA_SIGN */
 751     TLSEXT_SIGALG_ecdsa_sha1, /* SSL_PKEY_ECC */
 752     TLSEXT_SIGALG_gostr34102001_gostr3411, /* SSL_PKEY_GOST01 */
 753     TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256, /* SSL_PKEY_GOST12_256 */
 754     TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512, /* SSL_PKEY_GOST12_512 */
 755     0 /* SSL_PKEY_ED25519 */
 756 };
 757
 758 /* Lookup TLS signature algorithm */
 759 static const SIGALG_LOOKUP *tls1_lookup_sigalg(uint16_t sigalg)
 760 {
 761     size_t i;
 762     const SIGALG_LOOKUP *s;
 763
 764     for (i = 0, s = sigalg_lookup_tbl; i < OSSL_NELEM(sigalg_lookup_tbl);
 765          i++, s++) {
 766         if (s->sigalg == sigalg)
 767             return s;
 768     }
 769     return NULL;
 770 }
 771 /* Lookup hash: return 0 if invalid or not enabled */
 772 int tls1_lookup_md(const SIGALG_LOOKUP *lu, const EVP_MD **pmd)
 773 {
 774     const EVP_MD *md;
 775     if (lu == NULL)
 776         return 0;
 777     /* lu->hash == NID_undef means no associated digest */
 778     if (lu->hash == NID_undef) {
 779         md = NULL;
 780     } else {
 781         md = ssl_md(lu->hash_idx);
 782         if (md == NULL)
 783             return 0;
 784     }
 785     if (pmd)
 786         *pmd = md;
 787     return 1;
 788 }
 789
 790 /*
 791  * Return a signature algorithm for TLS < 1.2 where the signature type
 792  * is fixed by the certificate type.
 793  */
 794 static const SIGALG_LOOKUP *tls1_get_legacy_sigalg(const SSL *s, int idx)
 795 {
 796     if (idx == -1) {
 797         if (s->server) {
 798             size_t i;
 799
 800             /* Work out index corresponding to ciphersuite */
 801             for (i = 0; i < SSL_PKEY_NUM; i++) {
 802                 const SSL_CERT_LOOKUP *clu = ssl_cert_lookup_by_idx(i);
 803
 804                 if (clu->amask & s->s3->tmp.new_cipher->algorithm_auth) {
 805                     idx = i;
 806                     break;
 807                 }
 808             }
 809         } else {
 810             idx = s->cert->key - s->cert->pkeys;
 811         }
 812     }
 813     if (idx < 0 || idx >= (int)OSSL_NELEM(tls_default_sigalg))
 814         return NULL;
 815     if (SSL_USE_SIGALGS(s) || idx != SSL_PKEY_RSA) {
 816         const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(tls_default_sigalg[idx]);
 817
 818         if (!tls1_lookup_md(lu, NULL))
 819             return NULL;
 820         return lu;
 821     }
 822     return &legacy_rsa_sigalg;
 823 }
 824 /* Set peer sigalg based key type */
 825 int tls1_set_peer_legacy_sigalg(SSL *s, const EVP_PKEY *pkey)
 826 {
 827     size_t idx;
 828     const SIGALG_LOOKUP *lu;
 829
 830     if (ssl_cert_lookup_by_pkey(pkey, &idx) == NULL)
 831         return 0;
 832     lu = tls1_get_legacy_sigalg(s, idx);
 833     if (lu == NULL)
 834         return 0;
 835     s->s3->tmp.peer_sigalg = lu;
 836     return 1;
 837 }
 838
 839 size_t tls12_get_psigalgs(SSL *s, int sent, const uint16_t **psigs)
 840 {
 841     /*
 842      * If Suite B mode use Suite B sigalgs only, ignore any other
 843      * preferences.
 844      */
 845 #ifndef OPENSSL_NO_EC
 846     switch (tls1_suiteb(s)) {
 847     case SSL_CERT_FLAG_SUITEB_128_LOS:
 848         *psigs = suiteb_sigalgs;
 849         return OSSL_NELEM(suiteb_sigalgs);
 850
 851     case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY:
 852         *psigs = suiteb_sigalgs;
 853         return 1;
 854
 855     case SSL_CERT_FLAG_SUITEB_192_LOS:
 856         *psigs = suiteb_sigalgs + 1;
 857         return 1;
 858     }
 859 #endif
 860     /*
 861      *  We use client_sigalgs (if not NULL) if we're a server
 862      *  and sending a certificate request or if we're a client and
 863      *  determining which shared algorithm to use.
 864      */
 865     if ((s->server == sent) && s->cert->client_sigalgs != NULL) {
 866         *psigs = s->cert->client_sigalgs;
 867         return s->cert->client_sigalgslen;
 868     } else if (s->cert->conf_sigalgs) {
 869         *psigs = s->cert->conf_sigalgs;
 870         return s->cert->conf_sigalgslen;
 871     } else {
 872         *psigs = tls12_sigalgs;
 873         return OSSL_NELEM(tls12_sigalgs);
 874     }
 875 }
 876
 877 /*
 878  * Check signature algorithm is consistent with sent supported signature
 879  * algorithms and if so set relevant digest and signature scheme in
 880  * s.
 881  */
 882 int tls12_check_peer_sigalg(SSL *s, uint16_t sig, EVP_PKEY *pkey)
 883 {
 884     const uint16_t *sent_sigs;
 885     const EVP_MD *md = NULL;
 886     char sigalgstr[2];
 887     size_t sent_sigslen, i;
 888     int pkeyid = EVP_PKEY_id(pkey);
 889     const SIGALG_LOOKUP *lu;
 890
 891     /* Should never happen */
 892     if (pkeyid == -1)
 893         return -1;
 894     if (SSL_IS_TLS13(s)) {
 895         /* Disallow DSA for TLS 1.3 */
 896         if (pkeyid == EVP_PKEY_DSA) {
 897             SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_SIGNATURE_TYPE);
 898             return 0;
 899         }
 900         /* Only allow PSS for TLS 1.3 */
 901         if (pkeyid == EVP_PKEY_RSA)
 902             pkeyid = EVP_PKEY_RSA_PSS;
 903     }
 904     lu = tls1_lookup_sigalg(sig);
 905     /*
 906      * Check sigalgs is known. Disallow SHA1/SHA224 with TLS 1.3. Check key type
 907      * is consistent with signature: RSA keys can be used for RSA-PSS
 908      */
 909     if (lu == NULL
 910         || (SSL_IS_TLS13(s) && (lu->hash == NID_sha1 || lu->hash == NID_sha224))
 911         || (pkeyid != lu->sig
 912         && (lu->sig != EVP_PKEY_RSA_PSS || pkeyid != EVP_PKEY_RSA))) {
 913         SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_SIGNATURE_TYPE);
 914         return 0;
 915     }
 916 #ifndef OPENSSL_NO_EC
 917     if (pkeyid == EVP_PKEY_EC) {
 918
 919         /* Check point compression is permitted */
 920         if (!tls1_check_pkey_comp(s, pkey)) {
 921             SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG,
 922                    SSL_R_ILLEGAL_POINT_COMPRESSION);
 923             return 0;
 924         }
 925
 926         /* For TLS 1.3 or Suite B check curve matches signature algorithm */
 927         if (SSL_IS_TLS13(s) || tls1_suiteb(s)) {
 928             EC_KEY *ec = EVP_PKEY_get0_EC_KEY(pkey);
 929             int curve = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
 930
 931             if (lu->curve != NID_undef && curve != lu->curve) {
 932                 SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_CURVE);
 933                 return 0;
 934             }
 935         }
 936         if (!SSL_IS_TLS13(s)) {
 937             /* Check curve matches extensions */
 938             if (!tls1_check_group_id(s, tls1_get_group_id(pkey))) {
 939                 SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_CURVE);
 940                 return 0;
 941             }
 942             if (tls1_suiteb(s)) {
 943                 /* Check sigalg matches a permissible Suite B value */
 944                 if (sig != TLSEXT_SIGALG_ecdsa_secp256r1_sha256
 945                     && sig != TLSEXT_SIGALG_ecdsa_secp384r1_sha384) {
 946                     SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG,
 947                            SSL_R_WRONG_SIGNATURE_TYPE);
 948                     return 0;
 949                 }
 950             }
 951         }
 952     } else if (tls1_suiteb(s)) {
 953         return 0;
 954     }
 955 #endif
 956
 957     /* Check signature matches a type we sent */
 958     sent_sigslen = tls12_get_psigalgs(s, 1, &sent_sigs);
 959     for (i = 0; i < sent_sigslen; i++, sent_sigs++) {
 960         if (sig == *sent_sigs)
 961             break;
 962     }
 963     /* Allow fallback to SHA1 if not strict mode */
 964     if (i == sent_sigslen && (lu->hash != NID_sha1
 965         || s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)) {
 966         SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_SIGNATURE_TYPE);
 967         return 0;
 968     }
 969     if (!tls1_lookup_md(lu, &md)) {
 970             SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_UNKNOWN_DIGEST);
 971             return 0;
 972     }
 973     if (md != NULL) {
 974         /*
 975          * Make sure security callback allows algorithm. For historical
 976          * reasons we have to pass the sigalg as a two byte char array.
 977          */
 978         sigalgstr[0] = (sig >> 8) & 0xff;
 979         sigalgstr[1] = sig & 0xff;
 980         if (!ssl_security(s, SSL_SECOP_SIGALG_CHECK,
 981                     EVP_MD_size(md) * 4, EVP_MD_type(md),
 982                     (void *)sigalgstr)) {
 983             SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_SIGNATURE_TYPE);
 984             return 0;
 985         }
 986     }
 987     /* Store the sigalg the peer uses */
 988     s->s3->tmp.peer_sigalg = lu;
 989     return 1;
 990 }
 991
 992 int SSL_get_peer_signature_type_nid(const SSL *s, int *pnid)
 993 {
 994     if (s->s3->tmp.peer_sigalg == NULL)
 995         return 0;
 996     *pnid = s->s3->tmp.peer_sigalg->sig;
 997     return 1;
 998 }
 999
1000 /*
1001  * Set a mask of disabled algorithms: an algorithm is disabled if it isn't
1002  * supported, doesn't appear in supported signature algorithms, isn't supported
1003  * by the enabled protocol versions or by the security level.
1004  *
1005  * This function should only be used for checking which ciphers are supported
1006  * by the client.
1007  *
1008  * Call ssl_cipher_disabled() to check that it's enabled or not.
1009  */
1010 void ssl_set_client_disabled(SSL *s)
1011 {
1012     s->s3->tmp.mask_a = 0;
1013     s->s3->tmp.mask_k = 0;
1014     ssl_set_sig_mask(&s->s3->tmp.mask_a, s, SSL_SECOP_SIGALG_MASK);
1015     ssl_get_min_max_version(s, &s->s3->tmp.min_ver, &s->s3->tmp.max_ver);
1016 #ifndef OPENSSL_NO_PSK
1017     /* with PSK there must be client callback set */
1018     if (!s->psk_client_callback) {
1019         s->s3->tmp.mask_a |= SSL_aPSK;
1020         s->s3->tmp.mask_k |= SSL_PSK;
1021     }
1022 #endif                          /* OPENSSL_NO_PSK */
1023 #ifndef OPENSSL_NO_SRP
1024     if (!(s->srp_ctx.srp_Mask & SSL_kSRP)) {
1025         s->s3->tmp.mask_a |= SSL_aSRP;
1026         s->s3->tmp.mask_k |= SSL_kSRP;
1027     }
1028 #endif
1029 }
1030
1031 /*
1032  * ssl_cipher_disabled - check that a cipher is disabled or not
1033  * @s: SSL connection that you want to use the cipher on
1034  * @c: cipher to check
1035  * @op: Security check that you want to do
1036  * @ecdhe: If set to 1 then TLSv1 ECDHE ciphers are also allowed in SSLv3
1037  *
1038  * Returns 1 when it's disabled, 0 when enabled.
1039  */
1040 int ssl_cipher_disabled(SSL *s, const SSL_CIPHER *c, int op, int ecdhe)
1041 {
1042     if (c->algorithm_mkey & s->s3->tmp.mask_k
1043         || c->algorithm_auth & s->s3->tmp.mask_a)
1044         return 1;
1045     if (s->s3->tmp.max_ver == 0)
1046         return 1;
1047     if (!SSL_IS_DTLS(s)) {
1048         int min_tls = c->min_tls;
1049
1050         /*
1051          * For historical reasons we will allow ECHDE to be selected by a server
1052          * in SSLv3 if we are a client
1053          */
1054         if (min_tls == TLS1_VERSION && ecdhe
1055                 && (c->algorithm_mkey & (SSL_kECDHE | SSL_kECDHEPSK)) != 0)
1056             min_tls = SSL3_VERSION;
1057
1058         if ((min_tls > s->s3->tmp.max_ver) || (c->max_tls < s->s3->tmp.min_ver))
1059             return 1;
1060     }
1061     if (SSL_IS_DTLS(s) && (DTLS_VERSION_GT(c->min_dtls, s->s3->tmp.max_ver)
1062                            || DTLS_VERSION_LT(c->max_dtls, s->s3->tmp.min_ver)))
1063         return 1;
1064
1065     return !ssl_security(s, op, c->strength_bits, 0, (void *)c);
1066 }
1067
1068 int tls_use_ticket(SSL *s)
1069 {
1070     if ((s->options & SSL_OP_NO_TICKET))
1071         return 0;
1072     return ssl_security(s, SSL_SECOP_TICKET, 0, 0, NULL);
1073 }
1074
1075 int tls1_set_server_sigalgs(SSL *s)
1076 {
1077     int al;
1078     size_t i;
1079
1080     /* Clear any shared signature algorithms */
1081     OPENSSL_free(s->cert->shared_sigalgs);
1082     s->cert->shared_sigalgs = NULL;
1083     s->cert->shared_sigalgslen = 0;
1084     /* Clear certificate validity flags */
1085     for (i = 0; i < SSL_PKEY_NUM; i++)
1086         s->s3->tmp.valid_flags[i] = 0;
1087     /*
1088      * If peer sent no signature algorithms check to see if we support
1089      * the default algorithm for each certificate type
1090      */
1091     if (s->s3->tmp.peer_sigalgs == NULL) {
1092         const uint16_t *sent_sigs;
1093         size_t sent_sigslen = tls12_get_psigalgs(s, 1, &sent_sigs);
1094
1095         for (i = 0; i < SSL_PKEY_NUM; i++) {
1096             const SIGALG_LOOKUP *lu = tls1_get_legacy_sigalg(s, i);
1097             size_t j;
1098
1099             if (lu == NULL)
1100                 continue;
1101             /* Check default matches a type we sent */
1102             for (j = 0; j < sent_sigslen; j++) {
1103                 if (lu->sigalg == sent_sigs[j]) {
1104                         s->s3->tmp.valid_flags[i] = CERT_PKEY_SIGN;
1105                         break;
1106                 }
1107             }
1108         }
1109         return 1;
1110     }
1111
1112     if (!tls1_process_sigalgs(s)) {
1113         SSLerr(SSL_F_TLS1_SET_SERVER_SIGALGS, ERR_R_MALLOC_FAILURE);
1114         al = SSL_AD_INTERNAL_ERROR;
1115         goto err;
1116     }
1117     if (s->cert->shared_sigalgs != NULL)
1118         return 1;
1119     /* Fatal error if no shared signature algorithms */
1120     SSLerr(SSL_F_TLS1_SET_SERVER_SIGALGS, SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS);
1121     al = SSL_AD_HANDSHAKE_FAILURE;
1122  err:
1123     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1124     return 0;
1125 }
1126
1127 /*-
1128  * Gets the ticket information supplied by the client if any.
1129  *
1130  *   hello: The parsed ClientHello data
1131  *   ret: (output) on return, if a ticket was decrypted, then this is set to
1132  *       point to the resulting session.
1133  *
1134  * If s->tls_session_secret_cb is set then we are expecting a pre-shared key
1135  * ciphersuite, in which case we have no use for session tickets and one will
1136  * never be decrypted, nor will s->ext.ticket_expected be set to 1.
1137  *
1138  * Returns:
1139  *   -1: fatal error, either from parsing or decrypting the ticket.
1140  *    0: no ticket was found (or was ignored, based on settings).
1141  *    1: a zero length extension was found, indicating that the client supports
1142  *       session tickets but doesn't currently have one to offer.
1143  *    2: either s->tls_session_secret_cb was set, or a ticket was offered but
1144  *       couldn't be decrypted because of a non-fatal error.
1145  *    3: a ticket was successfully decrypted and *ret was set.
1146  *
1147  * Side effects:
1148  *   Sets s->ext.ticket_expected to 1 if the server will have to issue
1149  *   a new session ticket to the client because the client indicated support
1150  *   (and s->tls_session_secret_cb is NULL) but the client either doesn't have
1151  *   a session ticket or we couldn't use the one it gave us, or if
1152  *   s->ctx->ext.ticket_key_cb asked to renew the client's ticket.
1153  *   Otherwise, s->ext.ticket_expected is set to 0.
1154  */
1155 TICKET_RETURN tls_get_ticket_from_client(SSL *s, CLIENTHELLO_MSG *hello,
1156                                          SSL_SESSION **ret)
1157 {
1158     int retv;
1159     size_t size;
1160     RAW_EXTENSION *ticketext;
1161
1162     *ret = NULL;
1163     s->ext.ticket_expected = 0;
1164
1165     /*
1166      * If tickets disabled or not supported by the protocol version
1167      * (e.g. TLSv1.3) behave as if no ticket present to permit stateful
1168      * resumption.
1169      */
1170     if (s->version <= SSL3_VERSION || !tls_use_ticket(s))
1171         return TICKET_NONE;
1172
1173     ticketext = &hello->pre_proc_exts[TLSEXT_IDX_session_ticket];
1174     if (!ticketext->present)
1175         return TICKET_NONE;
1176
1177     size = PACKET_remaining(&ticketext->data);
1178     if (size == 0) {
1179         /*
1180          * The client will accept a ticket but doesn't currently have
1181          * one.
1182          */
1183         s->ext.ticket_expected = 1;
1184         return TICKET_EMPTY;
1185     }
1186     if (s->ext.session_secret_cb) {
1187         /*
1188          * Indicate that the ticket couldn't be decrypted rather than
1189          * generating the session from ticket now, trigger
1190          * abbreviated handshake based on external mechanism to
1191          * calculate the master secret later.
1192          */
1193         return TICKET_NO_DECRYPT;
1194     }
1195
1196     retv = tls_decrypt_ticket(s, PACKET_data(&ticketext->data), size,
1197                               hello->session_id, hello->session_id_len, ret);
1198     switch (retv) {
1199     case TICKET_NO_DECRYPT:
1200         s->ext.ticket_expected = 1;
1201         return TICKET_NO_DECRYPT;
1202
1203     case TICKET_SUCCESS:
1204         return TICKET_SUCCESS;
1205
1206     case TICKET_SUCCESS_RENEW:
1207         s->ext.ticket_expected = 1;
1208         return TICKET_SUCCESS;
1209
1210     default:
1211         return TICKET_FATAL_ERR_OTHER;
1212     }
1213 }
1214
1215 /*-
1216  * tls_decrypt_ticket attempts to decrypt a session ticket.
1217  *
1218  *   etick: points to the body of the session ticket extension.
1219  *   eticklen: the length of the session tickets extension.
1220  *   sess_id: points at the session ID.
1221  *   sesslen: the length of the session ID.
1222  *   psess: (output) on return, if a ticket was decrypted, then this is set to
1223  *       point to the resulting session.
1224  */
1225 TICKET_RETURN tls_decrypt_ticket(SSL *s, const unsigned char *etick,
1226                                  size_t eticklen, const unsigned char *sess_id,
1227                                  size_t sesslen, SSL_SESSION **psess)
1228 {
1229     SSL_SESSION *sess;
1230     unsigned char *sdec;
1231     const unsigned char *p;
1232     int slen, renew_ticket = 0, declen;
1233     TICKET_RETURN ret = TICKET_FATAL_ERR_OTHER;
1234     size_t mlen;
1235     unsigned char tick_hmac[EVP_MAX_MD_SIZE];
1236     HMAC_CTX *hctx = NULL;
1237     EVP_CIPHER_CTX *ctx;
1238     SSL_CTX *tctx = s->session_ctx;
1239
1240     /* Initialize session ticket encryption and HMAC contexts */
1241     hctx = HMAC_CTX_new();
1242     if (hctx == NULL)
1243         return TICKET_FATAL_ERR_MALLOC;
1244     ctx = EVP_CIPHER_CTX_new();
1245     if (ctx == NULL) {
1246         ret = TICKET_FATAL_ERR_MALLOC;
1247         goto err;
1248     }
1249     if (tctx->ext.ticket_key_cb) {
1250         unsigned char *nctick = (unsigned char *)etick;
1251         int rv = tctx->ext.ticket_key_cb(s, nctick, nctick + 16,
1252                                             ctx, hctx, 0);
1253         if (rv < 0)
1254             goto err;
1255         if (rv == 0) {
1256             ret = TICKET_NO_DECRYPT;
1257             goto err;
1258         }
1259         if (rv == 2)
1260             renew_ticket = 1;
1261     } else {
1262         /* Check key name matches */
1263         if (memcmp(etick, tctx->ext.tick_key_name,
1264                    sizeof(tctx->ext.tick_key_name)) != 0) {
1265             ret = TICKET_NO_DECRYPT;
1266             goto err;
1267         }
1268         if (HMAC_Init_ex(hctx, tctx->ext.tick_hmac_key,
1269                          sizeof(tctx->ext.tick_hmac_key),
1270                          EVP_sha256(), NULL) <= 0
1271             || EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL,
1272                                   tctx->ext.tick_aes_key,
1273                                   etick
1274                                   + sizeof(tctx->ext.tick_key_name)) <= 0) {
1275             goto err;
1276         }
1277     }
1278     /*
1279      * Attempt to process session ticket, first conduct sanity and integrity
1280      * checks on ticket.
1281      */
1282     mlen = HMAC_size(hctx);
1283     if (mlen == 0) {
1284         goto err;
1285     }
1286     /* Sanity check ticket length: must exceed keyname + IV + HMAC */
1287     if (eticklen <=
1288         TLSEXT_KEYNAME_LENGTH + EVP_CIPHER_CTX_iv_length(ctx) + mlen) {
1289         ret = TICKET_NO_DECRYPT;
1290         goto err;
1291     }
1292     eticklen -= mlen;
1293     /* Check HMAC of encrypted ticket */
1294     if (HMAC_Update(hctx, etick, eticklen) <= 0
1295         || HMAC_Final(hctx, tick_hmac, NULL) <= 0) {
1296         goto err;
1297     }
1298     HMAC_CTX_free(hctx);
1299     if (CRYPTO_memcmp(tick_hmac, etick + eticklen, mlen)) {
1300         EVP_CIPHER_CTX_free(ctx);
1301         return TICKET_NO_DECRYPT;
1302     }
1303     /* Attempt to decrypt session data */
1304     /* Move p after IV to start of encrypted ticket, update length */
1305     p = etick + TLSEXT_KEYNAME_LENGTH + EVP_CIPHER_CTX_iv_length(ctx);
1306     eticklen -= TLSEXT_KEYNAME_LENGTH + EVP_CIPHER_CTX_iv_length(ctx);
1307     sdec = OPENSSL_malloc(eticklen);
1308     if (sdec == NULL || EVP_DecryptUpdate(ctx, sdec, &slen, p,
1309                                           (int)eticklen) <= 0) {
1310         EVP_CIPHER_CTX_free(ctx);
1311         OPENSSL_free(sdec);
1312         return TICKET_FATAL_ERR_OTHER;
1313     }
1314     if (EVP_DecryptFinal(ctx, sdec + slen, &declen) <= 0) {
1315         EVP_CIPHER_CTX_free(ctx);
1316         OPENSSL_free(sdec);
1317         return TICKET_NO_DECRYPT;
1318     }
1319     slen += declen;
1320     EVP_CIPHER_CTX_free(ctx);
1321     ctx = NULL;
1322     p = sdec;
1323
1324     sess = d2i_SSL_SESSION(NULL, &p, slen);
1325     slen -= p - sdec;
1326     OPENSSL_free(sdec);
1327     if (sess) {
1328         /* Some additional consistency checks */
1329         if (slen != 0 || sess->session_id_length != 0) {
1330             SSL_SESSION_free(sess);
1331             return TICKET_NO_DECRYPT;
1332         }
1333         /*
1334          * The session ID, if non-empty, is used by some clients to detect
1335          * that the ticket has been accepted. So we copy it to the session
1336          * structure. If it is empty set length to zero as required by
1337          * standard.
1338          */
1339         if (sesslen)
1340             memcpy(sess->session_id, sess_id, sesslen);
1341         sess->session_id_length = sesslen;
1342         *psess = sess;
1343         if (renew_ticket)
1344             return TICKET_SUCCESS_RENEW;
1345         else
1346             return TICKET_SUCCESS;
1347     }
1348     ERR_clear_error();
1349     /*
1350      * For session parse failure, indicate that we need to send a new ticket.
1351      */
1352     return TICKET_NO_DECRYPT;
1353  err:
1354     EVP_CIPHER_CTX_free(ctx);
1355     HMAC_CTX_free(hctx);
1356     return ret;
1357 }
1358
1359 /* Check to see if a signature algorithm is allowed */
1360 static int tls12_sigalg_allowed(SSL *s, int op, const SIGALG_LOOKUP *lu)
1361 {
1362     unsigned char sigalgstr[2];
1363     int secbits;
1364
1365     /* See if sigalgs is recognised and if hash is enabled */
1366     if (!tls1_lookup_md(lu, NULL))
1367         return 0;
1368     /* DSA is not allowed in TLS 1.3 */
1369     if (SSL_IS_TLS13(s) && lu->sig == EVP_PKEY_DSA)
1370         return 0;
1371     /* TODO(OpenSSL1.2) fully axe DSA/etc. in ClientHello per TLS 1.3 spec */
1372     if (!s->server && !SSL_IS_DTLS(s) && s->s3->tmp.min_ver >= TLS1_3_VERSION
1373         && (lu->sig == EVP_PKEY_DSA || lu->hash_idx == SSL_MD_SHA1_IDX
1374             || lu->hash_idx == SSL_MD_MD5_IDX
1375             || lu->hash_idx == SSL_MD_SHA224_IDX))
1376         return 0;
1377     /* See if public key algorithm allowed */
1378     if (ssl_cert_is_disabled(lu->sig_idx))
1379         return 0;
1380     if (lu->hash == NID_undef)
1381         return 1;
1382     /* Security bits: half digest bits */
1383     secbits = EVP_MD_size(ssl_md(lu->hash_idx)) * 4;
1384     /* Finally see if security callback allows it */
1385     sigalgstr[0] = (lu->sigalg >> 8) & 0xff;
1386     sigalgstr[1] = lu->sigalg & 0xff;
1387     return ssl_security(s, op, secbits, lu->hash, (void *)sigalgstr);
1388 }
1389
1390 /*
1391  * Get a mask of disabled public key algorithms based on supported signature
1392  * algorithms. For example if no signature algorithm supports RSA then RSA is
1393  * disabled.
1394  */
1395
1396 void ssl_set_sig_mask(uint32_t *pmask_a, SSL *s, int op)
1397 {
1398     const uint16_t *sigalgs;
1399     size_t i, sigalgslen;
1400     uint32_t disabled_mask = SSL_aRSA | SSL_aDSS | SSL_aECDSA;
1401     /*
1402      * Go through all signature algorithms seeing if we support any
1403      * in disabled_mask.
1404      */
1405     sigalgslen = tls12_get_psigalgs(s, 1, &sigalgs);
1406     for (i = 0; i < sigalgslen; i ++, sigalgs++) {
1407         const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(*sigalgs);
1408         const SSL_CERT_LOOKUP *clu;
1409
1410         if (lu == NULL)
1411             continue;
1412
1413         clu = ssl_cert_lookup_by_idx(lu->sig_idx);
1414
1415         /* If algorithm is disabled see if we can enable it */
1416         if ((clu->amask & disabled_mask) != 0
1417                 && tls12_sigalg_allowed(s, op, lu))
1418             disabled_mask &= ~clu->amask;
1419     }
1420     *pmask_a |= disabled_mask;
1421 }
1422
1423 int tls12_copy_sigalgs(SSL *s, WPACKET *pkt,
1424                        const uint16_t *psig, size_t psiglen)
1425 {
1426     size_t i;
1427     int rv = 0;
1428
1429     for (i = 0; i < psiglen; i++, psig++) {
1430         const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(*psig);
1431
1432         if (!tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SUPPORTED, lu))
1433             continue;
1434         if (!WPACKET_put_bytes_u16(pkt, *psig))
1435             return 0;
1436         /*
1437          * If TLS 1.3 must have at least one valid TLS 1.3 message
1438          * signing algorithm: i.e. neither RSA nor SHA1/SHA224
1439          */
1440         if (rv == 0 && (!SSL_IS_TLS13(s)
1441             || (lu->sig != EVP_PKEY_RSA
1442                 && lu->hash != NID_sha1
1443                 && lu->hash != NID_sha224)))
1444             rv = 1;
1445     }
1446     if (rv == 0)
1447         SSLerr(SSL_F_TLS12_COPY_SIGALGS, SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM);
1448     return rv;
1449 }
1450
1451 /* Given preference and allowed sigalgs set shared sigalgs */
1452 static size_t tls12_shared_sigalgs(SSL *s, const SIGALG_LOOKUP **shsig,
1453                                    const uint16_t *pref, size_t preflen,
1454                                    const uint16_t *allow, size_t allowlen)
1455 {
1456     const uint16_t *ptmp, *atmp;
1457     size_t i, j, nmatch = 0;
1458     for (i = 0, ptmp = pref; i < preflen; i++, ptmp++) {
1459         const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(*ptmp);
1460
1461         /* Skip disabled hashes or signature algorithms */
1462         if (!tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SHARED, lu))
1463             continue;
1464         for (j = 0, atmp = allow; j < allowlen; j++, atmp++) {
1465             if (*ptmp == *atmp) {
1466                 nmatch++;
1467                 if (shsig)
1468                     *shsig++ = lu;
1469                 break;
1470             }
1471         }
1472     }
1473     return nmatch;
1474 }
1475
1476 /* Set shared signature algorithms for SSL structures */
1477 static int tls1_set_shared_sigalgs(SSL *s)
1478 {
1479     const uint16_t *pref, *allow, *conf;
1480     size_t preflen, allowlen, conflen;
1481     size_t nmatch;
1482     const SIGALG_LOOKUP **salgs = NULL;
1483     CERT *c = s->cert;
1484     unsigned int is_suiteb = tls1_suiteb(s);
1485
1486     OPENSSL_free(c->shared_sigalgs);
1487     c->shared_sigalgs = NULL;
1488     c->shared_sigalgslen = 0;
1489     /* If client use client signature algorithms if not NULL */
1490     if (!s->server && c->client_sigalgs && !is_suiteb) {
1491         conf = c->client_sigalgs;
1492         conflen = c->client_sigalgslen;
1493     } else if (c->conf_sigalgs && !is_suiteb) {
1494         conf = c->conf_sigalgs;
1495         conflen = c->conf_sigalgslen;
1496     } else
1497         conflen = tls12_get_psigalgs(s, 0, &conf);
1498     if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE || is_suiteb) {
1499         pref = conf;
1500         preflen = conflen;
1501         allow = s->s3->tmp.peer_sigalgs;
1502         allowlen = s->s3->tmp.peer_sigalgslen;
1503     } else {
1504         allow = conf;
1505         allowlen = conflen;
1506         pref = s->s3->tmp.peer_sigalgs;
1507         preflen = s->s3->tmp.peer_sigalgslen;
1508     }
1509     nmatch = tls12_shared_sigalgs(s, NULL, pref, preflen, allow, allowlen);
1510     if (nmatch) {
1511         salgs = OPENSSL_malloc(nmatch * sizeof(*salgs));
1512         if (salgs == NULL)
1513             return 0;
1514         nmatch = tls12_shared_sigalgs(s, salgs, pref, preflen, allow, allowlen);
1515     } else {
1516         salgs = NULL;
1517     }
1518     c->shared_sigalgs = salgs;
1519     c->shared_sigalgslen = nmatch;
1520     return 1;
1521 }
1522
1523 int tls1_save_u16(PACKET *pkt, uint16_t **pdest, size_t *pdestlen)
1524 {
1525     unsigned int stmp;
1526     size_t size, i;
1527     uint16_t *buf;
1528
1529     size = PACKET_remaining(pkt);
1530
1531     /* Invalid data length */
1532     if (size == 0 || (size & 1) != 0)
1533         return 0;
1534
1535     size >>= 1;
1536
1537     buf = OPENSSL_malloc(size * sizeof(*buf));
1538     if (buf == NULL)
1539         return 0;
1540     for (i = 0; i < size && PACKET_get_net_2(pkt, &stmp); i++)
1541         buf[i] = stmp;
1542
1543     if (i != size) {
1544         OPENSSL_free(buf);
1545         return 0;
1546     }
1547
1548     OPENSSL_free(*pdest);
1549     *pdest = buf;
1550     *pdestlen = size;
1551
1552     return 1;
1553 }
1554
1555 int tls1_save_sigalgs(SSL *s, PACKET *pkt)
1556 {
1557     /* Extension ignored for inappropriate versions */
1558     if (!SSL_USE_SIGALGS(s))
1559         return 1;
1560     /* Should never happen */
1561     if (s->cert == NULL)
1562         return 0;
1563
1564     return tls1_save_u16(pkt, &s->s3->tmp.peer_sigalgs,
1565                          &s->s3->tmp.peer_sigalgslen);
1566
1567     return 1;
1568 }
1569
1570 /* Set preferred digest for each key type */
1571
1572 int tls1_process_sigalgs(SSL *s)
1573 {
1574     size_t i;
1575     uint32_t *pvalid = s->s3->tmp.valid_flags;
1576     CERT *c = s->cert;
1577
1578     if (!tls1_set_shared_sigalgs(s))
1579         return 0;
1580
1581     for (i = 0; i < SSL_PKEY_NUM; i++)
1582         pvalid[i] = 0;
1583
1584     for (i = 0; i < c->shared_sigalgslen; i++) {
1585         const SIGALG_LOOKUP *sigptr = c->shared_sigalgs[i];
1586         int idx = sigptr->sig_idx;
1587
1588         /* Ignore PKCS1 based sig algs in TLSv1.3 */
1589         if (SSL_IS_TLS13(s) && sigptr->sig == EVP_PKEY_RSA)
1590             continue;
1591         /* If not disabled indicate we can explicitly sign */
1592         if (pvalid[idx] == 0 && !ssl_cert_is_disabled(idx))
1593             pvalid[idx] = CERT_PKEY_EXPLICIT_SIGN | CERT_PKEY_SIGN;
1594     }
1595     return 1;
1596 }
1597
1598 int SSL_get_sigalgs(SSL *s, int idx,
1599                     int *psign, int *phash, int *psignhash,
1600                     unsigned char *rsig, unsigned char *rhash)
1601 {
1602     uint16_t *psig = s->s3->tmp.peer_sigalgs;
1603     size_t numsigalgs = s->s3->tmp.peer_sigalgslen;
1604     if (psig == NULL || numsigalgs > INT_MAX)
1605         return 0;
1606     if (idx >= 0) {
1607         const SIGALG_LOOKUP *lu;
1608
1609         if (idx >= (int)numsigalgs)
1610             return 0;
1611         psig += idx;
1612         if (rhash != NULL)
1613             *rhash = (unsigned char)((*psig >> 8) & 0xff);
1614         if (rsig != NULL)
1615             *rsig = (unsigned char)(*psig & 0xff);
1616         lu = tls1_lookup_sigalg(*psig);
1617         if (psign != NULL)
1618             *psign = lu != NULL ? lu->sig : NID_undef;
1619         if (phash != NULL)
1620             *phash = lu != NULL ? lu->hash : NID_undef;
1621         if (psignhash != NULL)
1622             *psignhash = lu != NULL ? lu->sigandhash : NID_undef;
1623     }
1624     return (int)numsigalgs;
1625 }
1626
1627 int SSL_get_shared_sigalgs(SSL *s, int idx,
1628                            int *psign, int *phash, int *psignhash,
1629                            unsigned char *rsig, unsigned char *rhash)
1630 {
1631     const SIGALG_LOOKUP *shsigalgs;
1632     if (s->cert->shared_sigalgs == NULL
1633         || idx < 0
1634         || idx >= (int)s->cert->shared_sigalgslen
1635         || s->cert->shared_sigalgslen > INT_MAX)
1636         return 0;
1637     shsigalgs = s->cert->shared_sigalgs[idx];
1638     if (phash != NULL)
1639         *phash = shsigalgs->hash;
1640     if (psign != NULL)
1641         *psign = shsigalgs->sig;
1642     if (psignhash != NULL)
1643         *psignhash = shsigalgs->sigandhash;
1644     if (rsig != NULL)
1645         *rsig = (unsigned char)(shsigalgs->sigalg & 0xff);
1646     if (rhash != NULL)
1647         *rhash = (unsigned char)((shsigalgs->sigalg >> 8) & 0xff);
1648     return (int)s->cert->shared_sigalgslen;
1649 }
1650
1651 /* Maximum possible number of unique entries in sigalgs array */
1652 #define TLS_MAX_SIGALGCNT (OSSL_NELEM(sigalg_lookup_tbl) * 2)
1653
1654 typedef struct {
1655     size_t sigalgcnt;
1656     int sigalgs[TLS_MAX_SIGALGCNT];
1657 } sig_cb_st;
1658
1659 static void get_sigorhash(int *psig, int *phash, const char *str)
1660 {
1661     if (strcmp(str, "RSA") == 0) {
1662         *psig = EVP_PKEY_RSA;
1663     } else if (strcmp(str, "RSA-PSS") == 0 || strcmp(str, "PSS") == 0) {
1664         *psig = EVP_PKEY_RSA_PSS;
1665     } else if (strcmp(str, "DSA") == 0) {
1666         *psig = EVP_PKEY_DSA;
1667     } else if (strcmp(str, "ECDSA") == 0) {
1668         *psig = EVP_PKEY_EC;
1669     } else {
1670         *phash = OBJ_sn2nid(str);
1671         if (*phash == NID_undef)
1672             *phash = OBJ_ln2nid(str);
1673     }
1674 }
1675 /* Maximum length of a signature algorithm string component */
1676 #define TLS_MAX_SIGSTRING_LEN   40
1677
1678 static int sig_cb(const char *elem, int len, void *arg)
1679 {
1680     sig_cb_st *sarg = arg;
1681     size_t i;
1682     char etmp[TLS_MAX_SIGSTRING_LEN], *p;
1683     int sig_alg = NID_undef, hash_alg = NID_undef;
1684     if (elem == NULL)
1685         return 0;
1686     if (sarg->sigalgcnt == TLS_MAX_SIGALGCNT)
1687         return 0;
1688     if (len > (int)(sizeof(etmp) - 1))
1689         return 0;
1690     memcpy(etmp, elem, len);
1691     etmp[len] = 0;
1692     p = strchr(etmp, '+');
1693     /* See if we have a match for TLS 1.3 names */
1694     if (p == NULL) {
1695         const SIGALG_LOOKUP *s;
1696
1697         for (i = 0, s = sigalg_lookup_tbl; i < OSSL_NELEM(sigalg_lookup_tbl);
1698              i++, s++) {
1699             if (s->name != NULL && strcmp(etmp, s->name) == 0) {
1700                 sig_alg = s->sig;
1701                 hash_alg = s->hash;
1702                 break;
1703             }
1704         }
1705     } else {
1706         *p = 0;
1707         p++;
1708         if (*p == 0)
1709             return 0;
1710         get_sigorhash(&sig_alg, &hash_alg, etmp);
1711         get_sigorhash(&sig_alg, &hash_alg, p);
1712     }
1713
1714     if (sig_alg == NID_undef || (p != NULL && hash_alg == NID_undef))
1715         return 0;
1716
1717     for (i = 0; i < sarg->sigalgcnt; i += 2) {
1718         if (sarg->sigalgs[i] == sig_alg && sarg->sigalgs[i + 1] == hash_alg)
1719             return 0;
1720     }
1721     sarg->sigalgs[sarg->sigalgcnt++] = hash_alg;
1722     sarg->sigalgs[sarg->sigalgcnt++] = sig_alg;
1723     return 1;
1724 }
1725
1726 /*
1727  * Set supported signature algorithms based on a colon separated list of the
1728  * form sig+hash e.g. RSA+SHA512:DSA+SHA512
1729  */
1730 int tls1_set_sigalgs_list(CERT *c, const char *str, int client)
1731 {
1732     sig_cb_st sig;
1733     sig.sigalgcnt = 0;
1734     if (!CONF_parse_list(str, ':', 1, sig_cb, &sig))
1735         return 0;
1736     if (c == NULL)
1737         return 1;
1738     return tls1_set_sigalgs(c, sig.sigalgs, sig.sigalgcnt, client);
1739 }
1740
1741 int tls1_set_sigalgs(CERT *c, const int *psig_nids, size_t salglen, int client)
1742 {
1743     uint16_t *sigalgs, *sptr;
1744     size_t i;
1745
1746     if (salglen & 1)
1747         return 0;
1748     sigalgs = OPENSSL_malloc((salglen / 2) * sizeof(*sigalgs));
1749     if (sigalgs == NULL)
1750         return 0;
1751     for (i = 0, sptr = sigalgs; i < salglen; i += 2) {
1752         size_t j;
1753         const SIGALG_LOOKUP *curr;
1754         int md_id = *psig_nids++;
1755         int sig_id = *psig_nids++;
1756
1757         for (j = 0, curr = sigalg_lookup_tbl; j < OSSL_NELEM(sigalg_lookup_tbl);
1758              j++, curr++) {
1759             if (curr->hash == md_id && curr->sig == sig_id) {
1760                 *sptr++ = curr->sigalg;
1761                 break;
1762             }
1763         }
1764
1765         if (j == OSSL_NELEM(sigalg_lookup_tbl))
1766             goto err;
1767     }
1768
1769     if (client) {
1770         OPENSSL_free(c->client_sigalgs);
1771         c->client_sigalgs = sigalgs;
1772         c->client_sigalgslen = salglen / 2;
1773     } else {
1774         OPENSSL_free(c->conf_sigalgs);
1775         c->conf_sigalgs = sigalgs;
1776         c->conf_sigalgslen = salglen / 2;
1777     }
1778
1779     return 1;
1780
1781  err:
1782     OPENSSL_free(sigalgs);
1783     return 0;
1784 }
1785
1786 static int tls1_check_sig_alg(CERT *c, X509 *x, int default_nid)
1787 {
1788     int sig_nid;
1789     size_t i;
1790     if (default_nid == -1)
1791         return 1;
1792     sig_nid = X509_get_signature_nid(x);
1793     if (default_nid)
1794         return sig_nid == default_nid ? 1 : 0;
1795     for (i = 0; i < c->shared_sigalgslen; i++)
1796         if (sig_nid == c->shared_sigalgs[i]->sigandhash)
1797             return 1;
1798     return 0;
1799 }
1800
1801 /* Check to see if a certificate issuer name matches list of CA names */
1802 static int ssl_check_ca_name(STACK_OF(X509_NAME) *names, X509 *x)
1803 {
1804     X509_NAME *nm;
1805     int i;
1806     nm = X509_get_issuer_name(x);
1807     for (i = 0; i < sk_X509_NAME_num(names); i++) {
1808         if (!X509_NAME_cmp(nm, sk_X509_NAME_value(names, i)))
1809             return 1;
1810     }
1811     return 0;
1812 }
1813
1814 /*
1815  * Check certificate chain is consistent with TLS extensions and is usable by
1816  * server. This servers two purposes: it allows users to check chains before
1817  * passing them to the server and it allows the server to check chains before
1818  * attempting to use them.
1819  */
1820
1821 /* Flags which need to be set for a certificate when strict mode not set */
1822
1823 #define CERT_PKEY_VALID_FLAGS \
1824         (CERT_PKEY_EE_SIGNATURE|CERT_PKEY_EE_PARAM)
1825 /* Strict mode flags */
1826 #define CERT_PKEY_STRICT_FLAGS \
1827          (CERT_PKEY_VALID_FLAGS|CERT_PKEY_CA_SIGNATURE|CERT_PKEY_CA_PARAM \
1828          | CERT_PKEY_ISSUER_NAME|CERT_PKEY_CERT_TYPE)
1829
1830 int tls1_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain,
1831                      int idx)
1832 {
1833     int i;
1834     int rv = 0;
1835     int check_flags = 0, strict_mode;
1836     CERT_PKEY *cpk = NULL;
1837     CERT *c = s->cert;
1838     uint32_t *pvalid;
1839     unsigned int suiteb_flags = tls1_suiteb(s);
1840     /* idx == -1 means checking server chains */
1841     if (idx != -1) {
1842         /* idx == -2 means checking client certificate chains */
1843         if (idx == -2) {
1844             cpk = c->key;
1845             idx = (int)(cpk - c->pkeys);
1846         } else
1847             cpk = c->pkeys + idx;
1848         pvalid = s->s3->tmp.valid_flags + idx;
1849         x = cpk->x509;
1850         pk = cpk->privatekey;
1851         chain = cpk->chain;
1852         strict_mode = c->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT;
1853         /* If no cert or key, forget it */
1854         if (!x || !pk)
1855             goto end;
1856     } else {
1857         size_t certidx;
1858
1859         if (!x || !pk)
1860             return 0;
1861
1862         if (ssl_cert_lookup_by_pkey(pk, &certidx) == NULL)
1863             return 0;
1864         idx = certidx;
1865         pvalid = s->s3->tmp.valid_flags + idx;
1866
1867         if (c->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)
1868             check_flags = CERT_PKEY_STRICT_FLAGS;
1869         else
1870             check_flags = CERT_PKEY_VALID_FLAGS;
1871         strict_mode = 1;
1872     }
1873
1874     if (suiteb_flags) {
1875         int ok;
1876         if (check_flags)
1877             check_flags |= CERT_PKEY_SUITEB;
1878         ok = X509_chain_check_suiteb(NULL, x, chain, suiteb_flags);
1879         if (ok == X509_V_OK)
1880             rv |= CERT_PKEY_SUITEB;
1881         else if (!check_flags)
1882             goto end;
1883     }
1884
1885     /*
1886      * Check all signature algorithms are consistent with signature
1887      * algorithms extension if TLS 1.2 or later and strict mode.
1888      */
1889     if (TLS1_get_version(s) >= TLS1_2_VERSION && strict_mode) {
1890         int default_nid;
1891         int rsign = 0;
1892         if (s->s3->tmp.peer_sigalgs)
1893             default_nid = 0;
1894         /* If no sigalgs extension use defaults from RFC5246 */
1895         else {
1896             switch (idx) {
1897             case SSL_PKEY_RSA:
1898                 rsign = EVP_PKEY_RSA;
1899                 default_nid = NID_sha1WithRSAEncryption;
1900                 break;
1901
1902             case SSL_PKEY_DSA_SIGN:
1903                 rsign = EVP_PKEY_DSA;
1904                 default_nid = NID_dsaWithSHA1;
1905                 break;
1906
1907             case SSL_PKEY_ECC:
1908                 rsign = EVP_PKEY_EC;
1909                 default_nid = NID_ecdsa_with_SHA1;
1910                 break;
1911
1912             case SSL_PKEY_GOST01:
1913                 rsign = NID_id_GostR3410_2001;
1914                 default_nid = NID_id_GostR3411_94_with_GostR3410_2001;
1915                 break;
1916
1917             case SSL_PKEY_GOST12_256:
1918                 rsign = NID_id_GostR3410_2012_256;
1919                 default_nid = NID_id_tc26_signwithdigest_gost3410_2012_256;
1920                 break;
1921
1922             case SSL_PKEY_GOST12_512:
1923                 rsign = NID_id_GostR3410_2012_512;
1924                 default_nid = NID_id_tc26_signwithdigest_gost3410_2012_512;
1925                 break;
1926
1927             default:
1928                 default_nid = -1;
1929                 break;
1930             }
1931         }
1932         /*
1933          * If peer sent no signature algorithms extension and we have set
1934          * preferred signature algorithms check we support sha1.
1935          */
1936         if (default_nid > 0 && c->conf_sigalgs) {
1937             size_t j;
1938             const uint16_t *p = c->conf_sigalgs;
1939             for (j = 0; j < c->conf_sigalgslen; j++, p++) {
1940                 const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(*p);
1941
1942                 if (lu != NULL && lu->hash == NID_sha1 && lu->sig == rsign)
1943                     break;
1944             }
1945             if (j == c->conf_sigalgslen) {
1946                 if (check_flags)
1947                     goto skip_sigs;
1948                 else
1949                     goto end;
1950             }
1951         }
1952         /* Check signature algorithm of each cert in chain */
1953         if (!tls1_check_sig_alg(c, x, default_nid)) {
1954             if (!check_flags)
1955                 goto end;
1956         } else
1957             rv |= CERT_PKEY_EE_SIGNATURE;
1958         rv |= CERT_PKEY_CA_SIGNATURE;
1959         for (i = 0; i < sk_X509_num(chain); i++) {
1960             if (!tls1_check_sig_alg(c, sk_X509_value(chain, i), default_nid)) {
1961                 if (check_flags) {
1962                     rv &= ~CERT_PKEY_CA_SIGNATURE;
1963                     break;
1964                 } else
1965                     goto end;
1966             }
1967         }
1968     }
1969     /* Else not TLS 1.2, so mark EE and CA signing algorithms OK */
1970     else if (check_flags)
1971         rv |= CERT_PKEY_EE_SIGNATURE | CERT_PKEY_CA_SIGNATURE;
1972  skip_sigs:
1973     /* Check cert parameters are consistent */
1974     if (tls1_check_cert_param(s, x, 1))
1975         rv |= CERT_PKEY_EE_PARAM;
1976     else if (!check_flags)
1977         goto end;
1978     if (!s->server)
1979         rv |= CERT_PKEY_CA_PARAM;
1980     /* In strict mode check rest of chain too */
1981     else if (strict_mode) {
1982         rv |= CERT_PKEY_CA_PARAM;
1983         for (i = 0; i < sk_X509_num(chain); i++) {
1984             X509 *ca = sk_X509_value(chain, i);
1985             if (!tls1_check_cert_param(s, ca, 0)) {
1986                 if (check_flags) {
1987                     rv &= ~CERT_PKEY_CA_PARAM;
1988                     break;
1989                 } else
1990                     goto end;
1991             }
1992         }
1993     }
1994     if (!s->server && strict_mode) {
1995         STACK_OF(X509_NAME) *ca_dn;
1996         int check_type = 0;
1997         switch (EVP_PKEY_id(pk)) {
1998         case EVP_PKEY_RSA:
1999             check_type = TLS_CT_RSA_SIGN;
2000             break;
2001         case EVP_PKEY_DSA:
2002             check_type = TLS_CT_DSS_SIGN;
2003             break;
2004         case EVP_PKEY_EC:
2005             check_type = TLS_CT_ECDSA_SIGN;
2006             break;
2007         }
2008         if (check_type) {
2009             const uint8_t *ctypes = s->s3->tmp.ctype;
2010             size_t j;
2011
2012             for (j = 0; j < s->s3->tmp.ctype_len; j++, ctypes++) {
2013                 if (*ctypes == check_type) {
2014                     rv |= CERT_PKEY_CERT_TYPE;
2015                     break;
2016                 }
2017             }
2018             if (!(rv & CERT_PKEY_CERT_TYPE) && !check_flags)
2019                 goto end;
2020         } else {
2021             rv |= CERT_PKEY_CERT_TYPE;
2022         }
2023
2024         ca_dn = s->s3->tmp.peer_ca_names;
2025
2026         if (!sk_X509_NAME_num(ca_dn))
2027             rv |= CERT_PKEY_ISSUER_NAME;
2028
2029         if (!(rv & CERT_PKEY_ISSUER_NAME)) {
2030             if (ssl_check_ca_name(ca_dn, x))
2031                 rv |= CERT_PKEY_ISSUER_NAME;
2032         }
2033         if (!(rv & CERT_PKEY_ISSUER_NAME)) {
2034             for (i = 0; i < sk_X509_num(chain); i++) {
2035                 X509 *xtmp = sk_X509_value(chain, i);
2036                 if (ssl_check_ca_name(ca_dn, xtmp)) {
2037                     rv |= CERT_PKEY_ISSUER_NAME;
2038                     break;
2039                 }
2040             }
2041         }
2042         if (!check_flags && !(rv & CERT_PKEY_ISSUER_NAME))
2043             goto end;
2044     } else
2045         rv |= CERT_PKEY_ISSUER_NAME | CERT_PKEY_CERT_TYPE;
2046
2047     if (!check_flags || (rv & check_flags) == check_flags)
2048         rv |= CERT_PKEY_VALID;
2049
2050  end:
2051
2052     if (TLS1_get_version(s) >= TLS1_2_VERSION)
2053         rv |= *pvalid & (CERT_PKEY_EXPLICIT_SIGN | CERT_PKEY_SIGN);
2054     else
2055         rv |= CERT_PKEY_SIGN | CERT_PKEY_EXPLICIT_SIGN;
2056
2057     /*
2058      * When checking a CERT_PKEY structure all flags are irrelevant if the
2059      * chain is invalid.
2060      */
2061     if (!check_flags) {
2062         if (rv & CERT_PKEY_VALID) {
2063             *pvalid = rv;
2064         } else {
2065             /* Preserve sign and explicit sign flag, clear rest */
2066             *pvalid &= CERT_PKEY_EXPLICIT_SIGN | CERT_PKEY_SIGN;
2067             return 0;
2068         }
2069     }
2070     return rv;
2071 }
2072
2073 /* Set validity of certificates in an SSL structure */
2074 void tls1_set_cert_validity(SSL *s)
2075 {
2076     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_RSA);
2077     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_RSA_PSS_SIGN);
2078     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_DSA_SIGN);
2079     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_ECC);
2080     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_GOST01);
2081     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_GOST12_256);
2082     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_GOST12_512);
2083     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_ED25519);
2084 }
2085
2086 /* User level utility function to check a chain is suitable */
2087 int SSL_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain)
2088 {
2089     return tls1_check_chain(s, x, pk, chain, -1);
2090 }
2091
2092 #ifndef OPENSSL_NO_DH
2093 DH *ssl_get_auto_dh(SSL *s)
2094 {
2095     int dh_secbits = 80;
2096     if (s->cert->dh_tmp_auto == 2)
2097         return DH_get_1024_160();
2098     if (s->s3->tmp.new_cipher->algorithm_auth & (SSL_aNULL | SSL_aPSK)) {
2099         if (s->s3->tmp.new_cipher->strength_bits == 256)
2100             dh_secbits = 128;
2101         else
2102             dh_secbits = 80;
2103     } else {
2104         if (s->s3->tmp.cert == NULL)
2105             return NULL;
2106         dh_secbits = EVP_PKEY_security_bits(s->s3->tmp.cert->privatekey);
2107     }
2108
2109     if (dh_secbits >= 128) {
2110         DH *dhp = DH_new();
2111         BIGNUM *p, *g;
2112         if (dhp == NULL)
2113             return NULL;
2114         g = BN_new();
2115         if (g != NULL)
2116             BN_set_word(g, 2);
2117         if (dh_secbits >= 192)
2118             p = BN_get_rfc3526_prime_8192(NULL);
2119         else
2120             p = BN_get_rfc3526_prime_3072(NULL);
2121         if (p == NULL || g == NULL || !DH_set0_pqg(dhp, p, NULL, g)) {
2122             DH_free(dhp);
2123             BN_free(p);
2124             BN_free(g);
2125             return NULL;
2126         }
2127         return dhp;
2128     }
2129     if (dh_secbits >= 112)
2130         return DH_get_2048_224();
2131     return DH_get_1024_160();
2132 }
2133 #endif
2134
2135 static int ssl_security_cert_key(SSL *s, SSL_CTX *ctx, X509 *x, int op)
2136 {
2137     int secbits = -1;
2138     EVP_PKEY *pkey = X509_get0_pubkey(x);
2139     if (pkey) {
2140         /*
2141          * If no parameters this will return -1 and fail using the default
2142          * security callback for any non-zero security level. This will
2143          * reject keys which omit parameters but this only affects DSA and
2144          * omission of parameters is never (?) done in practice.
2145          */
2146         secbits = EVP_PKEY_security_bits(pkey);
2147     }
2148     if (s)
2149         return ssl_security(s, op, secbits, 0, x);
2150     else
2151         return ssl_ctx_security(ctx, op, secbits, 0, x);
2152 }
2153
2154 static int ssl_security_cert_sig(SSL *s, SSL_CTX *ctx, X509 *x, int op)
2155 {
2156     /* Lookup signature algorithm digest */
2157     int secbits, nid, pknid;
2158     /* Don't check signature if self signed */
2159     if ((X509_get_extension_flags(x) & EXFLAG_SS) != 0)
2160         return 1;
2161     if (!X509_get_signature_info(x, &nid, &pknid, &secbits, NULL))
2162         secbits = -1;
2163     /* If digest NID not defined use signature NID */
2164     if (nid == NID_undef)
2165         nid = pknid;
2166     if (s)
2167         return ssl_security(s, op, secbits, nid, x);
2168     else
2169         return ssl_ctx_security(ctx, op, secbits, nid, x);
2170 }
2171
2172 int ssl_security_cert(SSL *s, SSL_CTX *ctx, X509 *x, int vfy, int is_ee)
2173 {
2174     if (vfy)
2175         vfy = SSL_SECOP_PEER;
2176     if (is_ee) {
2177         if (!ssl_security_cert_key(s, ctx, x, SSL_SECOP_EE_KEY | vfy))
2178             return SSL_R_EE_KEY_TOO_SMALL;
2179     } else {
2180         if (!ssl_security_cert_key(s, ctx, x, SSL_SECOP_CA_KEY | vfy))
2181             return SSL_R_CA_KEY_TOO_SMALL;
2182     }
2183     if (!ssl_security_cert_sig(s, ctx, x, SSL_SECOP_CA_MD | vfy))
2184         return SSL_R_CA_MD_TOO_WEAK;
2185     return 1;
2186 }
2187
2188 /*
2189  * Check security of a chain, if |sk| includes the end entity certificate then
2190  * |x| is NULL. If |vfy| is 1 then we are verifying a peer chain and not sending
2191  * one to the peer. Return values: 1 if ok otherwise error code to use
2192  */
2193
2194 int ssl_security_cert_chain(SSL *s, STACK_OF(X509) *sk, X509 *x, int vfy)
2195 {
2196     int rv, start_idx, i;
2197     if (x == NULL) {
2198         x = sk_X509_value(sk, 0);
2199         start_idx = 1;
2200     } else
2201         start_idx = 0;
2202
2203     rv = ssl_security_cert(s, NULL, x, vfy, 1);
2204     if (rv != 1)
2205         return rv;
2206
2207     for (i = start_idx; i < sk_X509_num(sk); i++) {
2208         x = sk_X509_value(sk, i);
2209         rv = ssl_security_cert(s, NULL, x, vfy, 0);
2210         if (rv != 1)
2211             return rv;
2212     }
2213     return 1;
2214 }
2215
2216 /*
2217  * For TLS 1.2 servers check if we have a certificate which can be used
2218  * with the signature algorithm "lu" and return index of certificate.
2219  */
2220
2221 static int tls12_get_cert_sigalg_idx(const SSL *s, const SIGALG_LOOKUP *lu)
2222 {
2223     int sig_idx = lu->sig_idx;
2224     const SSL_CERT_LOOKUP *clu = ssl_cert_lookup_by_idx(sig_idx);
2225
2226     /* If not recognised or not supported by cipher mask it is not suitable */
2227     if (clu == NULL || !(clu->amask & s->s3->tmp.new_cipher->algorithm_auth))
2228         return -1;
2229
2230     /* If PSS and we have no PSS cert use RSA */
2231     if (sig_idx == SSL_PKEY_RSA_PSS_SIGN && !ssl_has_cert(s, sig_idx))
2232         sig_idx = SSL_PKEY_RSA;
2233
2234     return s->s3->tmp.valid_flags[sig_idx] & CERT_PKEY_VALID ? sig_idx : -1;
2235 }
2236
2237 /*
2238  * Choose an appropriate signature algorithm based on available certificates
2239  * Sets chosen certificate and signature algorithm.
2240  *
2241  * For servers if we fail to find a required certificate it is a fatal error
2242  * and an appropriate error code is set and the TLS alert set in *al.
2243  *
2244  * For clients al is set to NULL. If a certificate is not suitable it is not
2245  * a fatal error: we will either try another certificate or not present one
2246  * to the server. In this case no error is set.
2247  */
2248 int tls_choose_sigalg(SSL *s, int *al)
2249 {
2250     const SIGALG_LOOKUP *lu = NULL;
2251     int sig_idx = -1;
2252
2253     s->s3->tmp.cert = NULL;
2254     s->s3->tmp.sigalg = NULL;
2255
2256     if (SSL_IS_TLS13(s)) {
2257         size_t i;
2258 #ifndef OPENSSL_NO_EC
2259         int curve = -1, skip_ec = 0;
2260 #endif
2261
2262         /* Look for a certificate matching shared sigalgs */
2263         for (i = 0; i < s->cert->shared_sigalgslen; i++) {
2264             lu = s->cert->shared_sigalgs[i];
2265
2266             /* Skip SHA1, SHA224, DSA and RSA if not PSS */
2267             if (lu->hash == NID_sha1
2268                 || lu->hash == NID_sha224
2269                 || lu->sig == EVP_PKEY_DSA
2270                 || lu->sig == EVP_PKEY_RSA)
2271                 continue;
2272             if (!tls1_lookup_md(lu, NULL))
2273                 continue;
2274             if (!ssl_has_cert(s, lu->sig_idx)) {
2275                 if (lu->sig_idx != SSL_PKEY_RSA_PSS_SIGN
2276                         || !ssl_has_cert(s, SSL_PKEY_RSA))
2277                     continue;
2278                 sig_idx = SSL_PKEY_RSA;
2279             }
2280             if (lu->sig == EVP_PKEY_EC) {
2281 #ifndef OPENSSL_NO_EC
2282                 if (curve == -1) {
2283                     EC_KEY *ec = EVP_PKEY_get0_EC_KEY(s->cert->pkeys[SSL_PKEY_ECC].privatekey);
2284
2285                     curve = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
2286                     if (EC_KEY_get_conv_form(ec)
2287                         != POINT_CONVERSION_UNCOMPRESSED)
2288                         skip_ec = 1;
2289                 }
2290                 if (skip_ec || (lu->curve != NID_undef && curve != lu->curve))
2291                     continue;
2292 #else
2293                 continue;
2294 #endif
2295             }
2296             break;
2297         }
2298         if (i == s->cert->shared_sigalgslen) {
2299             if (al == NULL)
2300                 return 1;
2301             *al = SSL_AD_HANDSHAKE_FAILURE;
2302             SSLerr(SSL_F_TLS_CHOOSE_SIGALG,
2303                    SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM);
2304             return 0;
2305         }
2306     } else {
2307         /* If ciphersuite doesn't require a cert nothing to do */
2308         if (!(s->s3->tmp.new_cipher->algorithm_auth & SSL_aCERT))
2309             return 1;
2310         if (!s->server && !ssl_has_cert(s, s->cert->key - s->cert->pkeys))
2311                 return 1;
2312
2313         if (SSL_USE_SIGALGS(s)) {
2314             if (s->s3->tmp.peer_sigalgs != NULL) {
2315                 size_t i;
2316 #ifndef OPENSSL_NO_EC
2317                 int curve;
2318
2319                 /* For Suite B need to match signature algorithm to curve */
2320                 if (tls1_suiteb(s)) {
2321                     EC_KEY *ec = EVP_PKEY_get0_EC_KEY(s->cert->pkeys[SSL_PKEY_ECC].privatekey);
2322                     curve = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
2323                 } else {
2324                     curve = -1;
2325                 }
2326 #endif
2327
2328                 /*
2329                  * Find highest preference signature algorithm matching
2330                  * cert type
2331                  */
2332                 for (i = 0; i < s->cert->shared_sigalgslen; i++) {
2333                     lu = s->cert->shared_sigalgs[i];
2334
2335                     if (s->server) {
2336                         if ((sig_idx = tls12_get_cert_sigalg_idx(s, lu)) == -1)
2337                             continue;
2338                     } else {
2339                         int cc_idx = s->cert->key - s->cert->pkeys;
2340
2341                         sig_idx = lu->sig_idx;
2342                         if (cc_idx != sig_idx) {
2343                             if (sig_idx != SSL_PKEY_RSA_PSS_SIGN
2344                                 || cc_idx != SSL_PKEY_RSA)
2345                                 continue;
2346                             sig_idx = SSL_PKEY_RSA;
2347                         }
2348                     }
2349 #ifndef OPENSSL_NO_EC
2350                     if (curve == -1 || lu->curve == curve)
2351 #endif
2352                         break;
2353                 }
2354                 if (i == s->cert->shared_sigalgslen) {
2355                     if (al == NULL)
2356                         return 1;
2357                     *al = SSL_AD_INTERNAL_ERROR;
2358                     SSLerr(SSL_F_TLS_CHOOSE_SIGALG, ERR_R_INTERNAL_ERROR);
2359                     return 0;
2360                 }
2361             } else {
2362                 /*
2363                  * If we have no sigalg use defaults
2364                  */
2365                 const uint16_t *sent_sigs;
2366                 size_t sent_sigslen, i;
2367
2368                 if ((lu = tls1_get_legacy_sigalg(s, -1)) == NULL) {
2369                     if (al == NULL)
2370                         return 1;
2371                     *al = SSL_AD_INTERNAL_ERROR;
2372                     SSLerr(SSL_F_TLS_CHOOSE_SIGALG, ERR_R_INTERNAL_ERROR);
2373                     return 0;
2374                 }
2375
2376                 /* Check signature matches a type we sent */
2377                 sent_sigslen = tls12_get_psigalgs(s, 1, &sent_sigs);
2378                 for (i = 0; i < sent_sigslen; i++, sent_sigs++) {
2379                     if (lu->sigalg == *sent_sigs)
2380                         break;
2381                 }
2382                 if (i == sent_sigslen) {
2383                     if (al == NULL)
2384                         return 1;
2385                     SSLerr(SSL_F_TLS_CHOOSE_SIGALG, SSL_R_WRONG_SIGNATURE_TYPE);
2386                     *al = SSL_AD_ILLEGAL_PARAMETER;
2387                     return 0;
2388                 }
2389             }
2390         } else {
2391             if ((lu = tls1_get_legacy_sigalg(s, -1)) == NULL) {
2392                 if (al == NULL)
2393                     return 1;
2394                 *al = SSL_AD_INTERNAL_ERROR;
2395                 SSLerr(SSL_F_TLS_CHOOSE_SIGALG, ERR_R_INTERNAL_ERROR);
2396                 return 0;
2397             }
2398         }
2399     }
2400     if (sig_idx == -1)
2401         sig_idx = lu->sig_idx;
2402     s->s3->tmp.cert = &s->cert->pkeys[sig_idx];
2403     s->cert->key = s->s3->tmp.cert;
2404     s->s3->tmp.sigalg = lu;
2405     return 1;
2406 }