ssl/t1_lib.c

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