ssl/t1_lib.c

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