ssl/t1_lib.c

   1 /*
   2  * Copyright 1995-2016 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 "ssl_locl.h"
  21 #include <openssl/ct.h>
  22
  23 static int tls_decrypt_ticket(SSL *s, const unsigned char *tick, size_t ticklen,
  24                               const unsigned char *sess_id, size_t sesslen,
  25                               SSL_SESSION **psess);
  26 static int ssl_check_clienthello_tlsext_early(SSL *s);
  27 static int ssl_check_serverhello_tlsext(SSL *s);
  28
  29 SSL3_ENC_METHOD const TLSv1_enc_data = {
  30     tls1_enc,
  31     tls1_mac,
  32     tls1_setup_key_block,
  33     tls1_generate_master_secret,
  34     tls1_change_cipher_state,
  35     tls1_final_finish_mac,
  36     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
  37     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
  38     tls1_alert_code,
  39     tls1_export_keying_material,
  40     0,
  41     ssl3_set_handshake_header,
  42     tls_close_construct_packet,
  43     ssl3_handshake_write
  44 };
  45
  46 SSL3_ENC_METHOD const TLSv1_1_enc_data = {
  47     tls1_enc,
  48     tls1_mac,
  49     tls1_setup_key_block,
  50     tls1_generate_master_secret,
  51     tls1_change_cipher_state,
  52     tls1_final_finish_mac,
  53     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
  54     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
  55     tls1_alert_code,
  56     tls1_export_keying_material,
  57     SSL_ENC_FLAG_EXPLICIT_IV,
  58     ssl3_set_handshake_header,
  59     tls_close_construct_packet,
  60     ssl3_handshake_write
  61 };
  62
  63 SSL3_ENC_METHOD const TLSv1_2_enc_data = {
  64     tls1_enc,
  65     tls1_mac,
  66     tls1_setup_key_block,
  67     tls1_generate_master_secret,
  68     tls1_change_cipher_state,
  69     tls1_final_finish_mac,
  70     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
  71     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
  72     tls1_alert_code,
  73     tls1_export_keying_material,
  74     SSL_ENC_FLAG_EXPLICIT_IV | SSL_ENC_FLAG_SIGALGS | SSL_ENC_FLAG_SHA256_PRF
  75         | SSL_ENC_FLAG_TLS1_2_CIPHERS,
  76     ssl3_set_handshake_header,
  77     tls_close_construct_packet,
  78     ssl3_handshake_write
  79 };
  80
  81 SSL3_ENC_METHOD const TLSv1_3_enc_data = {
  82     tls1_enc,
  83     tls1_mac,
  84     tls1_setup_key_block,
  85     tls1_generate_master_secret,
  86     tls1_change_cipher_state,
  87     tls1_final_finish_mac,
  88     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
  89     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
  90     tls1_alert_code,
  91     tls1_export_keying_material,
  92     SSL_ENC_FLAG_EXPLICIT_IV | SSL_ENC_FLAG_SIGALGS | SSL_ENC_FLAG_SHA256_PRF
  93         | SSL_ENC_FLAG_TLS1_2_CIPHERS,
  94     ssl3_set_handshake_header,
  95     tls_close_construct_packet,
  96     ssl3_handshake_write
  97 };
  98
  99 long tls1_default_timeout(void)
 100 {
 101     /*
 102      * 2 hours, the 24 hours mentioned in the TLSv1 spec is way too long for
 103      * http, the cache would over fill
 104      */
 105     return (60 * 60 * 2);
 106 }
 107
 108 int tls1_new(SSL *s)
 109 {
 110     if (!ssl3_new(s))
 111         return (0);
 112     s->method->ssl_clear(s);
 113     return (1);
 114 }
 115
 116 void tls1_free(SSL *s)
 117 {
 118     OPENSSL_free(s->tlsext_session_ticket);
 119     ssl3_free(s);
 120 }
 121
 122 void tls1_clear(SSL *s)
 123 {
 124     ssl3_clear(s);
 125     if (s->method->version == TLS_ANY_VERSION)
 126         s->version = TLS_MAX_VERSION;
 127     else
 128         s->version = s->method->version;
 129 }
 130
 131 #ifndef OPENSSL_NO_EC
 132
 133 typedef struct {
 134     int nid;                    /* Curve NID */
 135     int secbits;                /* Bits of security (from SP800-57) */
 136     unsigned int flags;         /* Flags: currently just field type */
 137 } tls_curve_info;
 138
 139 /*
 140  * Table of curve information.
 141  * Do not delete entries or reorder this array! It is used as a lookup
 142  * table: the index of each entry is one less than the TLS curve id.
 143  */
 144 static const tls_curve_info nid_list[] = {
 145     {NID_sect163k1, 80, TLS_CURVE_CHAR2}, /* sect163k1 (1) */
 146     {NID_sect163r1, 80, TLS_CURVE_CHAR2}, /* sect163r1 (2) */
 147     {NID_sect163r2, 80, TLS_CURVE_CHAR2}, /* sect163r2 (3) */
 148     {NID_sect193r1, 80, TLS_CURVE_CHAR2}, /* sect193r1 (4) */
 149     {NID_sect193r2, 80, TLS_CURVE_CHAR2}, /* sect193r2 (5) */
 150     {NID_sect233k1, 112, TLS_CURVE_CHAR2}, /* sect233k1 (6) */
 151     {NID_sect233r1, 112, TLS_CURVE_CHAR2}, /* sect233r1 (7) */
 152     {NID_sect239k1, 112, TLS_CURVE_CHAR2}, /* sect239k1 (8) */
 153     {NID_sect283k1, 128, TLS_CURVE_CHAR2}, /* sect283k1 (9) */
 154     {NID_sect283r1, 128, TLS_CURVE_CHAR2}, /* sect283r1 (10) */
 155     {NID_sect409k1, 192, TLS_CURVE_CHAR2}, /* sect409k1 (11) */
 156     {NID_sect409r1, 192, TLS_CURVE_CHAR2}, /* sect409r1 (12) */
 157     {NID_sect571k1, 256, TLS_CURVE_CHAR2}, /* sect571k1 (13) */
 158     {NID_sect571r1, 256, TLS_CURVE_CHAR2}, /* sect571r1 (14) */
 159     {NID_secp160k1, 80, TLS_CURVE_PRIME}, /* secp160k1 (15) */
 160     {NID_secp160r1, 80, TLS_CURVE_PRIME}, /* secp160r1 (16) */
 161     {NID_secp160r2, 80, TLS_CURVE_PRIME}, /* secp160r2 (17) */
 162     {NID_secp192k1, 80, TLS_CURVE_PRIME}, /* secp192k1 (18) */
 163     {NID_X9_62_prime192v1, 80, TLS_CURVE_PRIME}, /* secp192r1 (19) */
 164     {NID_secp224k1, 112, TLS_CURVE_PRIME}, /* secp224k1 (20) */
 165     {NID_secp224r1, 112, TLS_CURVE_PRIME}, /* secp224r1 (21) */
 166     {NID_secp256k1, 128, TLS_CURVE_PRIME}, /* secp256k1 (22) */
 167     {NID_X9_62_prime256v1, 128, TLS_CURVE_PRIME}, /* secp256r1 (23) */
 168     {NID_secp384r1, 192, TLS_CURVE_PRIME}, /* secp384r1 (24) */
 169     {NID_secp521r1, 256, TLS_CURVE_PRIME}, /* secp521r1 (25) */
 170     {NID_brainpoolP256r1, 128, TLS_CURVE_PRIME}, /* brainpoolP256r1 (26) */
 171     {NID_brainpoolP384r1, 192, TLS_CURVE_PRIME}, /* brainpoolP384r1 (27) */
 172     {NID_brainpoolP512r1, 256, TLS_CURVE_PRIME}, /* brainpool512r1 (28) */
 173     {NID_X25519, 128, TLS_CURVE_CUSTOM}, /* X25519 (29) */
 174 };
 175
 176 static const unsigned char ecformats_default[] = {
 177     TLSEXT_ECPOINTFORMAT_uncompressed,
 178     TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime,
 179     TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2
 180 };
 181
 182 /* The default curves */
 183 static const unsigned char eccurves_default[] = {
 184     0, 29,                      /* X25519 (29) */
 185     0, 23,                      /* secp256r1 (23) */
 186     0, 25,                      /* secp521r1 (25) */
 187     0, 24,                      /* secp384r1 (24) */
 188 };
 189
 190 static const unsigned char eccurves_all[] = {
 191     0, 29,                      /* X25519 (29) */
 192     0, 23,                      /* secp256r1 (23) */
 193     0, 25,                      /* secp521r1 (25) */
 194     0, 24,                      /* secp384r1 (24) */
 195     0, 26,                      /* brainpoolP256r1 (26) */
 196     0, 27,                      /* brainpoolP384r1 (27) */
 197     0, 28,                      /* brainpool512r1 (28) */
 198
 199     /*
 200      * Remaining curves disabled by default but still permitted if set
 201      * via an explicit callback or parameters.
 202      */
 203     0, 22,                      /* secp256k1 (22) */
 204     0, 14,                      /* sect571r1 (14) */
 205     0, 13,                      /* sect571k1 (13) */
 206     0, 11,                      /* sect409k1 (11) */
 207     0, 12,                      /* sect409r1 (12) */
 208     0, 9,                       /* sect283k1 (9) */
 209     0, 10,                      /* sect283r1 (10) */
 210     0, 20,                      /* secp224k1 (20) */
 211     0, 21,                      /* secp224r1 (21) */
 212     0, 18,                      /* secp192k1 (18) */
 213     0, 19,                      /* secp192r1 (19) */
 214     0, 15,                      /* secp160k1 (15) */
 215     0, 16,                      /* secp160r1 (16) */
 216     0, 17,                      /* secp160r2 (17) */
 217     0, 8,                       /* sect239k1 (8) */
 218     0, 6,                       /* sect233k1 (6) */
 219     0, 7,                       /* sect233r1 (7) */
 220     0, 4,                       /* sect193r1 (4) */
 221     0, 5,                       /* sect193r2 (5) */
 222     0, 1,                       /* sect163k1 (1) */
 223     0, 2,                       /* sect163r1 (2) */
 224     0, 3,                       /* sect163r2 (3) */
 225 };
 226
 227 static const unsigned char suiteb_curves[] = {
 228     0, TLSEXT_curve_P_256,
 229     0, TLSEXT_curve_P_384
 230 };
 231
 232 int tls1_ec_curve_id2nid(int curve_id, unsigned int *pflags)
 233 {
 234     const tls_curve_info *cinfo;
 235     /* ECC curves from RFC 4492 and RFC 7027 */
 236     if ((curve_id < 1) || ((unsigned int)curve_id > OSSL_NELEM(nid_list)))
 237         return 0;
 238     cinfo = nid_list + curve_id - 1;
 239     if (pflags)
 240         *pflags = cinfo->flags;
 241     return cinfo->nid;
 242 }
 243
 244 int tls1_ec_nid2curve_id(int nid)
 245 {
 246     size_t i;
 247     for (i = 0; i < OSSL_NELEM(nid_list); i++) {
 248         if (nid_list[i].nid == nid)
 249             return (int)(i + 1);
 250     }
 251     return 0;
 252 }
 253
 254 /*
 255  * Get curves list, if "sess" is set return client curves otherwise
 256  * preferred list.
 257  * Sets |num_curves| to the number of curves in the list, i.e.,
 258  * the length of |pcurves| is 2 * num_curves.
 259  * Returns 1 on success and 0 if the client curves list has invalid format.
 260  * The latter indicates an internal error: we should not be accepting such
 261  * lists in the first place.
 262  * TODO(emilia): we should really be storing the curves list in explicitly
 263  * parsed form instead. (However, this would affect binary compatibility
 264  * so cannot happen in the 1.0.x series.)
 265  */
 266 static int tls1_get_curvelist(SSL *s, int sess,
 267                               const unsigned char **pcurves, size_t *num_curves)
 268 {
 269     size_t pcurveslen = 0;
 270     if (sess) {
 271         *pcurves = s->session->tlsext_supportedgroupslist;
 272         pcurveslen = s->session->tlsext_supportedgroupslist_length;
 273     } else {
 274         /* For Suite B mode only include P-256, P-384 */
 275         switch (tls1_suiteb(s)) {
 276         case SSL_CERT_FLAG_SUITEB_128_LOS:
 277             *pcurves = suiteb_curves;
 278             pcurveslen = sizeof(suiteb_curves);
 279             break;
 280
 281         case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY:
 282             *pcurves = suiteb_curves;
 283             pcurveslen = 2;
 284             break;
 285
 286         case SSL_CERT_FLAG_SUITEB_192_LOS:
 287             *pcurves = suiteb_curves + 2;
 288             pcurveslen = 2;
 289             break;
 290         default:
 291             *pcurves = s->tlsext_supportedgroupslist;
 292             pcurveslen = s->tlsext_supportedgroupslist_length;
 293         }
 294         if (!*pcurves) {
 295             *pcurves = eccurves_default;
 296             pcurveslen = sizeof(eccurves_default);
 297         }
 298     }
 299
 300     /* We do not allow odd length arrays to enter the system. */
 301     if (pcurveslen & 1) {
 302         SSLerr(SSL_F_TLS1_GET_CURVELIST, ERR_R_INTERNAL_ERROR);
 303         *num_curves = 0;
 304         return 0;
 305     } else {
 306         *num_curves = pcurveslen / 2;
 307         return 1;
 308     }
 309 }
 310
 311 /* See if curve is allowed by security callback */
 312 static int tls_curve_allowed(SSL *s, const unsigned char *curve, int op)
 313 {
 314     const tls_curve_info *cinfo;
 315     if (curve[0])
 316         return 1;
 317     if ((curve[1] < 1) || ((size_t)curve[1] > OSSL_NELEM(nid_list)))
 318         return 0;
 319     cinfo = &nid_list[curve[1] - 1];
 320 # ifdef OPENSSL_NO_EC2M
 321     if (cinfo->flags & TLS_CURVE_CHAR2)
 322         return 0;
 323 # endif
 324     return ssl_security(s, op, cinfo->secbits, cinfo->nid, (void *)curve);
 325 }
 326
 327 /* Check a curve is one of our preferences */
 328 int tls1_check_curve(SSL *s, const unsigned char *p, size_t len)
 329 {
 330     const unsigned char *curves;
 331     size_t num_curves, i;
 332     unsigned int suiteb_flags = tls1_suiteb(s);
 333     if (len != 3 || p[0] != NAMED_CURVE_TYPE)
 334         return 0;
 335     /* Check curve matches Suite B preferences */
 336     if (suiteb_flags) {
 337         unsigned long cid = s->s3->tmp.new_cipher->id;
 338         if (p[1])
 339             return 0;
 340         if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256) {
 341             if (p[2] != TLSEXT_curve_P_256)
 342                 return 0;
 343         } else if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384) {
 344             if (p[2] != TLSEXT_curve_P_384)
 345                 return 0;
 346         } else                  /* Should never happen */
 347             return 0;
 348     }
 349     if (!tls1_get_curvelist(s, 0, &curves, &num_curves))
 350         return 0;
 351     for (i = 0; i < num_curves; i++, curves += 2) {
 352         if (p[1] == curves[0] && p[2] == curves[1])
 353             return tls_curve_allowed(s, p + 1, SSL_SECOP_CURVE_CHECK);
 354     }
 355     return 0;
 356 }
 357
 358 /*-
 359  * For nmatch >= 0, return the NID of the |nmatch|th shared group or NID_undef
 360  * if there is no match.
 361  * For nmatch == -1, return number of matches
 362  * For nmatch == -2, return the NID of the group to use for
 363  * an EC tmp key, or NID_undef if there is no match.
 364  */
 365 int tls1_shared_group(SSL *s, int nmatch)
 366 {
 367     const unsigned char *pref, *supp;
 368     size_t num_pref, num_supp, i, j;
 369     int k;
 370     /* Can't do anything on client side */
 371     if (s->server == 0)
 372         return -1;
 373     if (nmatch == -2) {
 374         if (tls1_suiteb(s)) {
 375             /*
 376              * For Suite B ciphersuite determines curve: we already know
 377              * these are acceptable due to previous checks.
 378              */
 379             unsigned long cid = s->s3->tmp.new_cipher->id;
 380             if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)
 381                 return NID_X9_62_prime256v1; /* P-256 */
 382             if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384)
 383                 return NID_secp384r1; /* P-384 */
 384             /* Should never happen */
 385             return NID_undef;
 386         }
 387         /* If not Suite B just return first preference shared curve */
 388         nmatch = 0;
 389     }
 390     /*
 391      * Avoid truncation. tls1_get_curvelist takes an int
 392      * but s->options is a long...
 393      */
 394     if (!tls1_get_curvelist
 395         (s, (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE) != 0, &supp,
 396          &num_supp))
 397         /* In practice, NID_undef == 0 but let's be precise. */
 398         return nmatch == -1 ? 0 : NID_undef;
 399     if (!tls1_get_curvelist
 400         (s, !(s->options & SSL_OP_CIPHER_SERVER_PREFERENCE), &pref, &num_pref))
 401         return nmatch == -1 ? 0 : NID_undef;
 402
 403     /*
 404      * If the client didn't send the elliptic_curves extension all of them
 405      * are allowed.
 406      */
 407     if (num_supp == 0 && (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE) != 0) {
 408         supp = eccurves_all;
 409         num_supp = sizeof(eccurves_all) / 2;
 410     } else if (num_pref == 0 &&
 411                (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE) == 0) {
 412         pref = eccurves_all;
 413         num_pref = sizeof(eccurves_all) / 2;
 414     }
 415
 416     k = 0;
 417     for (i = 0; i < num_pref; i++, pref += 2) {
 418         const unsigned char *tsupp = supp;
 419         for (j = 0; j < num_supp; j++, tsupp += 2) {
 420             if (pref[0] == tsupp[0] && pref[1] == tsupp[1]) {
 421                 if (!tls_curve_allowed(s, pref, SSL_SECOP_CURVE_SHARED))
 422                     continue;
 423                 if (nmatch == k) {
 424                     int id = (pref[0] << 8) | pref[1];
 425                     return tls1_ec_curve_id2nid(id, NULL);
 426                 }
 427                 k++;
 428             }
 429         }
 430     }
 431     if (nmatch == -1)
 432         return k;
 433     /* Out of range (nmatch > k). */
 434     return NID_undef;
 435 }
 436
 437 int tls1_set_groups(unsigned char **pext, size_t *pextlen,
 438                     int *groups, size_t ngroups)
 439 {
 440     unsigned char *glist, *p;
 441     size_t i;
 442     /*
 443      * Bitmap of groups included to detect duplicates: only works while group
 444      * ids < 32
 445      */
 446     unsigned long dup_list = 0;
 447     glist = OPENSSL_malloc(ngroups * 2);
 448     if (glist == NULL)
 449         return 0;
 450     for (i = 0, p = glist; i < ngroups; i++) {
 451         unsigned long idmask;
 452         int id;
 453         /* TODO(TLS1.3): Convert for DH groups */
 454         id = tls1_ec_nid2curve_id(groups[i]);
 455         idmask = 1L << id;
 456         if (!id || (dup_list & idmask)) {
 457             OPENSSL_free(glist);
 458             return 0;
 459         }
 460         dup_list |= idmask;
 461         s2n(id, p);
 462     }
 463     OPENSSL_free(*pext);
 464     *pext = glist;
 465     *pextlen = ngroups * 2;
 466     return 1;
 467 }
 468
 469 # define MAX_CURVELIST   28
 470
 471 typedef struct {
 472     size_t nidcnt;
 473     int nid_arr[MAX_CURVELIST];
 474 } nid_cb_st;
 475
 476 static int nid_cb(const char *elem, int len, void *arg)
 477 {
 478     nid_cb_st *narg = arg;
 479     size_t i;
 480     int nid;
 481     char etmp[20];
 482     if (elem == NULL)
 483         return 0;
 484     if (narg->nidcnt == MAX_CURVELIST)
 485         return 0;
 486     if (len > (int)(sizeof(etmp) - 1))
 487         return 0;
 488     memcpy(etmp, elem, len);
 489     etmp[len] = 0;
 490     nid = EC_curve_nist2nid(etmp);
 491     if (nid == NID_undef)
 492         nid = OBJ_sn2nid(etmp);
 493     if (nid == NID_undef)
 494         nid = OBJ_ln2nid(etmp);
 495     if (nid == NID_undef)
 496         return 0;
 497     for (i = 0; i < narg->nidcnt; i++)
 498         if (narg->nid_arr[i] == nid)
 499             return 0;
 500     narg->nid_arr[narg->nidcnt++] = nid;
 501     return 1;
 502 }
 503
 504 /* Set groups based on a colon separate list */
 505 int tls1_set_groups_list(unsigned char **pext, size_t *pextlen, const char *str)
 506 {
 507     nid_cb_st ncb;
 508     ncb.nidcnt = 0;
 509     if (!CONF_parse_list(str, ':', 1, nid_cb, &ncb))
 510         return 0;
 511     if (pext == NULL)
 512         return 1;
 513     return tls1_set_groups(pext, pextlen, ncb.nid_arr, ncb.nidcnt);
 514 }
 515
 516 /* For an EC key set TLS id and required compression based on parameters */
 517 static int tls1_set_ec_id(unsigned char *curve_id, unsigned char *comp_id,
 518                           EC_KEY *ec)
 519 {
 520     int id;
 521     const EC_GROUP *grp;
 522     if (!ec)
 523         return 0;
 524     /* Determine if it is a prime field */
 525     grp = EC_KEY_get0_group(ec);
 526     if (!grp)
 527         return 0;
 528     /* Determine curve ID */
 529     id = EC_GROUP_get_curve_name(grp);
 530     id = tls1_ec_nid2curve_id(id);
 531     /* If no id return error: we don't support arbitrary explicit curves */
 532     if (id == 0)
 533         return 0;
 534     curve_id[0] = 0;
 535     curve_id[1] = (unsigned char)id;
 536     if (comp_id) {
 537         if (EC_KEY_get0_public_key(ec) == NULL)
 538             return 0;
 539         if (EC_KEY_get_conv_form(ec) == POINT_CONVERSION_UNCOMPRESSED) {
 540             *comp_id = TLSEXT_ECPOINTFORMAT_uncompressed;
 541         } else {
 542             if ((nid_list[id - 1].flags & TLS_CURVE_TYPE) == TLS_CURVE_PRIME)
 543                 *comp_id = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime;
 544             else
 545                 *comp_id = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2;
 546         }
 547     }
 548     return 1;
 549 }
 550
 551 /* Check an EC key is compatible with extensions */
 552 static int tls1_check_ec_key(SSL *s,
 553                              unsigned char *curve_id, unsigned char *comp_id)
 554 {
 555     const unsigned char *pformats, *pcurves;
 556     size_t num_formats, num_curves, i;
 557     int j;
 558     /*
 559      * If point formats extension present check it, otherwise everything is
 560      * supported (see RFC4492).
 561      */
 562     if (comp_id && s->session->tlsext_ecpointformatlist) {
 563         pformats = s->session->tlsext_ecpointformatlist;
 564         num_formats = s->session->tlsext_ecpointformatlist_length;
 565         for (i = 0; i < num_formats; i++, pformats++) {
 566             if (*comp_id == *pformats)
 567                 break;
 568         }
 569         if (i == num_formats)
 570             return 0;
 571     }
 572     if (!curve_id)
 573         return 1;
 574     /* Check curve is consistent with client and server preferences */
 575     for (j = 0; j <= 1; j++) {
 576         if (!tls1_get_curvelist(s, j, &pcurves, &num_curves))
 577             return 0;
 578         if (j == 1 && num_curves == 0) {
 579             /*
 580              * If we've not received any curves then skip this check.
 581              * RFC 4492 does not require the supported elliptic curves extension
 582              * so if it is not sent we can just choose any curve.
 583              * It is invalid to send an empty list in the elliptic curves
 584              * extension, so num_curves == 0 always means no extension.
 585              */
 586             break;
 587         }
 588         for (i = 0; i < num_curves; i++, pcurves += 2) {
 589             if (pcurves[0] == curve_id[0] && pcurves[1] == curve_id[1])
 590                 break;
 591         }
 592         if (i == num_curves)
 593             return 0;
 594         /* For clients can only check sent curve list */
 595         if (!s->server)
 596             break;
 597     }
 598     return 1;
 599 }
 600
 601 static void tls1_get_formatlist(SSL *s, const unsigned char **pformats,
 602                                 size_t *num_formats)
 603 {
 604     /*
 605      * If we have a custom point format list use it otherwise use default
 606      */
 607     if (s->tlsext_ecpointformatlist) {
 608         *pformats = s->tlsext_ecpointformatlist;
 609         *num_formats = s->tlsext_ecpointformatlist_length;
 610     } else {
 611         *pformats = ecformats_default;
 612         /* For Suite B we don't support char2 fields */
 613         if (tls1_suiteb(s))
 614             *num_formats = sizeof(ecformats_default) - 1;
 615         else
 616             *num_formats = sizeof(ecformats_default);
 617     }
 618 }
 619
 620 /*
 621  * Check cert parameters compatible with extensions: currently just checks EC
 622  * certificates have compatible curves and compression.
 623  */
 624 static int tls1_check_cert_param(SSL *s, X509 *x, int set_ee_md)
 625 {
 626     unsigned char comp_id, curve_id[2];
 627     EVP_PKEY *pkey;
 628     int rv;
 629     pkey = X509_get0_pubkey(x);
 630     if (!pkey)
 631         return 0;
 632     /* If not EC nothing to do */
 633     if (EVP_PKEY_id(pkey) != EVP_PKEY_EC)
 634         return 1;
 635     rv = tls1_set_ec_id(curve_id, &comp_id, EVP_PKEY_get0_EC_KEY(pkey));
 636     if (!rv)
 637         return 0;
 638     /*
 639      * Can't check curve_id for client certs as we don't have a supported
 640      * curves extension.
 641      */
 642     rv = tls1_check_ec_key(s, s->server ? curve_id : NULL, &comp_id);
 643     if (!rv)
 644         return 0;
 645     /*
 646      * Special case for suite B. We *MUST* sign using SHA256+P-256 or
 647      * SHA384+P-384, adjust digest if necessary.
 648      */
 649     if (set_ee_md && tls1_suiteb(s)) {
 650         int check_md;
 651         size_t i;
 652         CERT *c = s->cert;
 653         if (curve_id[0])
 654             return 0;
 655         /* Check to see we have necessary signing algorithm */
 656         if (curve_id[1] == TLSEXT_curve_P_256)
 657             check_md = NID_ecdsa_with_SHA256;
 658         else if (curve_id[1] == TLSEXT_curve_P_384)
 659             check_md = NID_ecdsa_with_SHA384;
 660         else
 661             return 0;           /* Should never happen */
 662         for (i = 0; i < c->shared_sigalgslen; i++)
 663             if (check_md == c->shared_sigalgs[i].signandhash_nid)
 664                 break;
 665         if (i == c->shared_sigalgslen)
 666             return 0;
 667         if (set_ee_md == 2) {
 668             if (check_md == NID_ecdsa_with_SHA256)
 669                 s->s3->tmp.md[SSL_PKEY_ECC] = EVP_sha256();
 670             else
 671                 s->s3->tmp.md[SSL_PKEY_ECC] = EVP_sha384();
 672         }
 673     }
 674     return rv;
 675 }
 676
 677 # ifndef OPENSSL_NO_EC
 678 /*
 679  * tls1_check_ec_tmp_key - Check EC temporary key compatibility
 680  * @s: SSL connection
 681  * @cid: Cipher ID we're considering using
 682  *
 683  * Checks that the kECDHE cipher suite we're considering using
 684  * is compatible with the client extensions.
 685  *
 686  * Returns 0 when the cipher can't be used or 1 when it can.
 687  */
 688 int tls1_check_ec_tmp_key(SSL *s, unsigned long cid)
 689 {
 690     /*
 691      * If Suite B, AES128 MUST use P-256 and AES256 MUST use P-384, no other
 692      * curves permitted.
 693      */
 694     if (tls1_suiteb(s)) {
 695         unsigned char curve_id[2];
 696         /* Curve to check determined by ciphersuite */
 697         if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)
 698             curve_id[1] = TLSEXT_curve_P_256;
 699         else if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384)
 700             curve_id[1] = TLSEXT_curve_P_384;
 701         else
 702             return 0;
 703         curve_id[0] = 0;
 704         /* Check this curve is acceptable */
 705         if (!tls1_check_ec_key(s, curve_id, NULL))
 706             return 0;
 707         return 1;
 708     }
 709     /* Need a shared curve */
 710     if (tls1_shared_group(s, 0))
 711         return 1;
 712     return 0;
 713 }
 714 # endif                         /* OPENSSL_NO_EC */
 715
 716 #else
 717
 718 static int tls1_check_cert_param(SSL *s, X509 *x, int set_ee_md)
 719 {
 720     return 1;
 721 }
 722
 723 #endif                          /* OPENSSL_NO_EC */
 724
 725 /*
 726  * List of supported signature algorithms and hashes. Should make this
 727  * customisable at some point, for now include everything we support.
 728  */
 729
 730 #ifdef OPENSSL_NO_RSA
 731 # define tlsext_sigalg_rsa(md)  /* */
 732 #else
 733 # define tlsext_sigalg_rsa(md) md, TLSEXT_signature_rsa,
 734 #endif
 735
 736 #ifdef OPENSSL_NO_DSA
 737 # define tlsext_sigalg_dsa(md)  /* */
 738 #else
 739 # define tlsext_sigalg_dsa(md) md, TLSEXT_signature_dsa,
 740 #endif
 741
 742 #ifdef OPENSSL_NO_EC
 743 # define tlsext_sigalg_ecdsa(md)/* */
 744 #else
 745 # define tlsext_sigalg_ecdsa(md) md, TLSEXT_signature_ecdsa,
 746 #endif
 747
 748 #define tlsext_sigalg(md) \
 749                 tlsext_sigalg_rsa(md) \
 750                 tlsext_sigalg_dsa(md) \
 751                 tlsext_sigalg_ecdsa(md)
 752
 753 static const unsigned char tls12_sigalgs[] = {
 754     tlsext_sigalg(TLSEXT_hash_sha512)
 755         tlsext_sigalg(TLSEXT_hash_sha384)
 756         tlsext_sigalg(TLSEXT_hash_sha256)
 757         tlsext_sigalg(TLSEXT_hash_sha224)
 758         tlsext_sigalg(TLSEXT_hash_sha1)
 759 #ifndef OPENSSL_NO_GOST
 760         TLSEXT_hash_gostr3411, TLSEXT_signature_gostr34102001,
 761     TLSEXT_hash_gostr34112012_256, TLSEXT_signature_gostr34102012_256,
 762     TLSEXT_hash_gostr34112012_512, TLSEXT_signature_gostr34102012_512
 763 #endif
 764 };
 765
 766 #ifndef OPENSSL_NO_EC
 767 static const unsigned char suiteb_sigalgs[] = {
 768     tlsext_sigalg_ecdsa(TLSEXT_hash_sha256)
 769         tlsext_sigalg_ecdsa(TLSEXT_hash_sha384)
 770 };
 771 #endif
 772 size_t tls12_get_psigalgs(SSL *s, const unsigned char **psigs)
 773 {
 774     /*
 775      * If Suite B mode use Suite B sigalgs only, ignore any other
 776      * preferences.
 777      */
 778 #ifndef OPENSSL_NO_EC
 779     switch (tls1_suiteb(s)) {
 780     case SSL_CERT_FLAG_SUITEB_128_LOS:
 781         *psigs = suiteb_sigalgs;
 782         return sizeof(suiteb_sigalgs);
 783
 784     case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY:
 785         *psigs = suiteb_sigalgs;
 786         return 2;
 787
 788     case SSL_CERT_FLAG_SUITEB_192_LOS:
 789         *psigs = suiteb_sigalgs + 2;
 790         return 2;
 791     }
 792 #endif
 793     /* If server use client authentication sigalgs if not NULL */
 794     if (s->server && s->cert->client_sigalgs) {
 795         *psigs = s->cert->client_sigalgs;
 796         return s->cert->client_sigalgslen;
 797     } else if (s->cert->conf_sigalgs) {
 798         *psigs = s->cert->conf_sigalgs;
 799         return s->cert->conf_sigalgslen;
 800     } else {
 801         *psigs = tls12_sigalgs;
 802         return sizeof(tls12_sigalgs);
 803     }
 804 }
 805
 806 /*
 807  * Check signature algorithm is consistent with sent supported signature
 808  * algorithms and if so return relevant digest.
 809  */
 810 int tls12_check_peer_sigalg(const EVP_MD **pmd, SSL *s,
 811                             const unsigned char *sig, EVP_PKEY *pkey)
 812 {
 813     const unsigned char *sent_sigs;
 814     size_t sent_sigslen, i;
 815     int sigalg = tls12_get_sigid(pkey);
 816     /* Should never happen */
 817     if (sigalg == -1)
 818         return -1;
 819     /* Check key type is consistent with signature */
 820     if (sigalg != (int)sig[1]) {
 821         SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_SIGNATURE_TYPE);
 822         return 0;
 823     }
 824 #ifndef OPENSSL_NO_EC
 825     if (EVP_PKEY_id(pkey) == EVP_PKEY_EC) {
 826         unsigned char curve_id[2], comp_id;
 827         /* Check compression and curve matches extensions */
 828         if (!tls1_set_ec_id(curve_id, &comp_id, EVP_PKEY_get0_EC_KEY(pkey)))
 829             return 0;
 830         if (!s->server && !tls1_check_ec_key(s, curve_id, &comp_id)) {
 831             SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_CURVE);
 832             return 0;
 833         }
 834         /* If Suite B only P-384+SHA384 or P-256+SHA-256 allowed */
 835         if (tls1_suiteb(s)) {
 836             if (curve_id[0])
 837                 return 0;
 838             if (curve_id[1] == TLSEXT_curve_P_256) {
 839                 if (sig[0] != TLSEXT_hash_sha256) {
 840                     SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG,
 841                            SSL_R_ILLEGAL_SUITEB_DIGEST);
 842                     return 0;
 843                 }
 844             } else if (curve_id[1] == TLSEXT_curve_P_384) {
 845                 if (sig[0] != TLSEXT_hash_sha384) {
 846                     SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG,
 847                            SSL_R_ILLEGAL_SUITEB_DIGEST);
 848                     return 0;
 849                 }
 850             } else
 851                 return 0;
 852         }
 853     } else if (tls1_suiteb(s))
 854         return 0;
 855 #endif
 856
 857     /* Check signature matches a type we sent */
 858     sent_sigslen = tls12_get_psigalgs(s, &sent_sigs);
 859     for (i = 0; i < sent_sigslen; i += 2, sent_sigs += 2) {
 860         if (sig[0] == sent_sigs[0] && sig[1] == sent_sigs[1])
 861             break;
 862     }
 863     /* Allow fallback to SHA1 if not strict mode */
 864     if (i == sent_sigslen
 865         && (sig[0] != TLSEXT_hash_sha1
 866             || s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)) {
 867         SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_SIGNATURE_TYPE);
 868         return 0;
 869     }
 870     *pmd = tls12_get_hash(sig[0]);
 871     if (*pmd == NULL) {
 872         SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_UNKNOWN_DIGEST);
 873         return 0;
 874     }
 875     /* Make sure security callback allows algorithm */
 876     if (!ssl_security(s, SSL_SECOP_SIGALG_CHECK,
 877                       EVP_MD_size(*pmd) * 4, EVP_MD_type(*pmd), (void *)sig)) {
 878         SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_SIGNATURE_TYPE);
 879         return 0;
 880     }
 881     /*
 882      * Store the digest used so applications can retrieve it if they wish.
 883      */
 884     s->s3->tmp.peer_md = *pmd;
 885     return 1;
 886 }
 887
 888 /*
 889  * Set a mask of disabled algorithms: an algorithm is disabled if it isn't
 890  * supported, doesn't appear in supported signature algorithms, isn't supported
 891  * by the enabled protocol versions or by the security level.
 892  *
 893  * This function should only be used for checking which ciphers are supported
 894  * by the client.
 895  *
 896  * Call ssl_cipher_disabled() to check that it's enabled or not.
 897  */
 898 void ssl_set_client_disabled(SSL *s)
 899 {
 900     s->s3->tmp.mask_a = 0;
 901     s->s3->tmp.mask_k = 0;
 902     ssl_set_sig_mask(&s->s3->tmp.mask_a, s, SSL_SECOP_SIGALG_MASK);
 903     ssl_get_client_min_max_version(s, &s->s3->tmp.min_ver, &s->s3->tmp.max_ver);
 904 #ifndef OPENSSL_NO_PSK
 905     /* with PSK there must be client callback set */
 906     if (!s->psk_client_callback) {
 907         s->s3->tmp.mask_a |= SSL_aPSK;
 908         s->s3->tmp.mask_k |= SSL_PSK;
 909     }
 910 #endif                          /* OPENSSL_NO_PSK */
 911 #ifndef OPENSSL_NO_SRP
 912     if (!(s->srp_ctx.srp_Mask & SSL_kSRP)) {
 913         s->s3->tmp.mask_a |= SSL_aSRP;
 914         s->s3->tmp.mask_k |= SSL_kSRP;
 915     }
 916 #endif
 917 }
 918
 919 /*
 920  * ssl_cipher_disabled - check that a cipher is disabled or not
 921  * @s: SSL connection that you want to use the cipher on
 922  * @c: cipher to check
 923  * @op: Security check that you want to do
 924  *
 925  * Returns 1 when it's disabled, 0 when enabled.
 926  */
 927 int ssl_cipher_disabled(SSL *s, const SSL_CIPHER *c, int op)
 928 {
 929     if (c->algorithm_mkey & s->s3->tmp.mask_k
 930         || c->algorithm_auth & s->s3->tmp.mask_a)
 931         return 1;
 932     if (s->s3->tmp.max_ver == 0)
 933         return 1;
 934     if (!SSL_IS_DTLS(s) && ((c->min_tls > s->s3->tmp.max_ver)
 935                             || (c->max_tls < s->s3->tmp.min_ver)))
 936         return 1;
 937     if (SSL_IS_DTLS(s) && (DTLS_VERSION_GT(c->min_dtls, s->s3->tmp.max_ver)
 938                            || DTLS_VERSION_LT(c->max_dtls, s->s3->tmp.min_ver)))
 939         return 1;
 940
 941     return !ssl_security(s, op, c->strength_bits, 0, (void *)c);
 942 }
 943
 944 static int tls_use_ticket(SSL *s)
 945 {
 946     if (s->options & SSL_OP_NO_TICKET)
 947         return 0;
 948     return ssl_security(s, SSL_SECOP_TICKET, 0, 0, NULL);
 949 }
 950
 951 static int compare_uint(const void *p1, const void *p2)
 952 {
 953     unsigned int u1 = *((const unsigned int *)p1);
 954     unsigned int u2 = *((const unsigned int *)p2);
 955     if (u1 < u2)
 956         return -1;
 957     else if (u1 > u2)
 958         return 1;
 959     else
 960         return 0;
 961 }
 962
 963 /*
 964  * Per http://tools.ietf.org/html/rfc5246#section-7.4.1.4, there may not be
 965  * more than one extension of the same type in a ClientHello or ServerHello.
 966  * This function does an initial scan over the extensions block to filter those
 967  * out. It returns 1 if all extensions are unique, and 0 if the extensions
 968  * contain duplicates, could not be successfully parsed, or an internal error
 969  * occurred.
 970  */
 971 static int tls1_check_duplicate_extensions(const PACKET *packet)
 972 {
 973     PACKET extensions = *packet;
 974     size_t num_extensions = 0, i = 0;
 975     unsigned int *extension_types = NULL;
 976     int ret = 0;
 977
 978     /* First pass: count the extensions. */
 979     while (PACKET_remaining(&extensions) > 0) {
 980         unsigned int type;
 981         PACKET extension;
 982         if (!PACKET_get_net_2(&extensions, &type) ||
 983             !PACKET_get_length_prefixed_2(&extensions, &extension)) {
 984             goto done;
 985         }
 986         num_extensions++;
 987     }
 988
 989     if (num_extensions <= 1)
 990         return 1;
 991
 992     extension_types = OPENSSL_malloc(sizeof(unsigned int) * num_extensions);
 993     if (extension_types == NULL) {
 994         SSLerr(SSL_F_TLS1_CHECK_DUPLICATE_EXTENSIONS, ERR_R_MALLOC_FAILURE);
 995         goto done;
 996     }
 997
 998     /* Second pass: gather the extension types. */
 999     extensions = *packet;
1000     for (i = 0; i < num_extensions; i++) {
1001         PACKET extension;
1002         if (!PACKET_get_net_2(&extensions, &extension_types[i]) ||
1003             !PACKET_get_length_prefixed_2(&extensions, &extension)) {
1004             /* This should not happen. */
1005             SSLerr(SSL_F_TLS1_CHECK_DUPLICATE_EXTENSIONS, ERR_R_INTERNAL_ERROR);
1006             goto done;
1007         }
1008     }
1009
1010     if (PACKET_remaining(&extensions) != 0) {
1011         SSLerr(SSL_F_TLS1_CHECK_DUPLICATE_EXTENSIONS, ERR_R_INTERNAL_ERROR);
1012         goto done;
1013     }
1014     /* Sort the extensions and make sure there are no duplicates. */
1015     qsort(extension_types, num_extensions, sizeof(unsigned int), compare_uint);
1016     for (i = 1; i < num_extensions; i++) {
1017         if (extension_types[i - 1] == extension_types[i])
1018             goto done;
1019     }
1020     ret = 1;
1021  done:
1022     OPENSSL_free(extension_types);
1023     return ret;
1024 }
1025
1026 int ssl_add_clienthello_tlsext(SSL *s, WPACKET *pkt, int *al)
1027 {
1028 #ifndef OPENSSL_NO_EC
1029     const unsigned char *pcurves = NULL;
1030     size_t num_curves = 0;
1031     int using_ecc = 0;
1032
1033     /* See if we support any ECC ciphersuites */
1034     if ((s->version >= TLS1_VERSION && s->version <= TLS1_2_VERSION)
1035             || SSL_IS_DTLS(s)) {
1036         int i;
1037         unsigned long alg_k, alg_a;
1038         STACK_OF(SSL_CIPHER) *cipher_stack = SSL_get_ciphers(s);
1039
1040         for (i = 0; i < sk_SSL_CIPHER_num(cipher_stack); i++) {
1041             const SSL_CIPHER *c = sk_SSL_CIPHER_value(cipher_stack, i);
1042
1043             alg_k = c->algorithm_mkey;
1044             alg_a = c->algorithm_auth;
1045             if ((alg_k & (SSL_kECDHE | SSL_kECDHEPSK))
1046                 || (alg_a & SSL_aECDSA)) {
1047                 using_ecc = 1;
1048                 break;
1049             }
1050         }
1051     } else if (s->version >= TLS1_3_VERSION) {
1052         /*
1053          * TODO(TLS1.3): We always use ECC for TLSv1.3 at the moment. This will
1054          * change if we implement DH key shares
1055          */
1056         using_ecc = 1;
1057     }
1058 #else
1059     if (s->version >= TLS1_3_VERSION) {
1060         /* Shouldn't happen! */
1061         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1062         return 0;
1063     }
1064 #endif
1065
1066     /* Add RI if renegotiating */
1067     if (s->renegotiate) {
1068         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate)
1069                 || !WPACKET_start_sub_packet_u16(pkt)
1070                 || !WPACKET_sub_memcpy_u8(pkt, s->s3->previous_client_finished,
1071                                    s->s3->previous_client_finished_len)
1072                 || !WPACKET_close(pkt)) {
1073             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1074             return 0;
1075         }
1076     }
1077     /* Only add RI for SSLv3 */
1078     if (s->client_version == SSL3_VERSION)
1079         goto done;
1080
1081     if (s->tlsext_hostname != NULL) {
1082         /* Add TLS extension servername to the Client Hello message */
1083         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name)
1084                    /* Sub-packet for server_name extension */
1085                 || !WPACKET_start_sub_packet_u16(pkt)
1086                    /* Sub-packet for servername list (always 1 hostname)*/
1087                 || !WPACKET_start_sub_packet_u16(pkt)
1088                 || !WPACKET_put_bytes_u8(pkt, TLSEXT_NAMETYPE_host_name)
1089                 || !WPACKET_sub_memcpy_u16(pkt, s->tlsext_hostname,
1090                                            strlen(s->tlsext_hostname))
1091                 || !WPACKET_close(pkt)
1092                 || !WPACKET_close(pkt)) {
1093             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1094             return 0;
1095         }
1096     }
1097 #ifndef OPENSSL_NO_SRP
1098     /* Add SRP username if there is one */
1099     if (s->srp_ctx.login != NULL) {
1100         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_srp)
1101                    /* Sub-packet for SRP extension */
1102                 || !WPACKET_start_sub_packet_u16(pkt)
1103                 || !WPACKET_start_sub_packet_u8(pkt)
1104                    /* login must not be zero...internal error if so */
1105                 || !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
1106                 || !WPACKET_memcpy(pkt, s->srp_ctx.login,
1107                                    strlen(s->srp_ctx.login))
1108                 || !WPACKET_close(pkt)
1109                 || !WPACKET_close(pkt)) {
1110             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1111             return 0;
1112         }
1113     }
1114 #endif
1115
1116 #ifndef OPENSSL_NO_EC
1117     if (using_ecc) {
1118         /*
1119          * Add TLS extension ECPointFormats to the ClientHello message
1120          */
1121         const unsigned char *pformats, *pcurvestmp;
1122         size_t num_formats;
1123         size_t i;
1124
1125         tls1_get_formatlist(s, &pformats, &num_formats);
1126
1127         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats)
1128                    /* Sub-packet for formats extension */
1129                 || !WPACKET_start_sub_packet_u16(pkt)
1130                 || !WPACKET_sub_memcpy_u8(pkt, pformats, num_formats)
1131                 || !WPACKET_close(pkt)) {
1132             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1133             return 0;
1134         }
1135
1136         /*
1137          * Add TLS extension supported_groups to the ClientHello message
1138          */
1139         /* TODO(TLS1.3): Add support for DHE groups */
1140         pcurves = s->tlsext_supportedgroupslist;
1141         if (!tls1_get_curvelist(s, 0, &pcurves, &num_curves)) {
1142             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1143             return 0;
1144         }
1145         pcurvestmp = pcurves;
1146
1147         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_groups)
1148                    /* Sub-packet for supported_groups extension */
1149                 || !WPACKET_start_sub_packet_u16(pkt)
1150                 || !WPACKET_start_sub_packet_u16(pkt)) {
1151             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1152             return 0;
1153         }
1154         /* Copy curve ID if supported */
1155         for (i = 0; i < num_curves; i++, pcurvestmp += 2) {
1156             if (tls_curve_allowed(s, pcurves, SSL_SECOP_CURVE_SUPPORTED)) {
1157                 if (!WPACKET_put_bytes_u8(pkt, pcurvestmp[0])
1158                     || !WPACKET_put_bytes_u8(pkt, pcurvestmp[1])) {
1159                         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT,
1160                                ERR_R_INTERNAL_ERROR);
1161                         return 0;
1162                     }
1163             }
1164         }
1165         if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
1166             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1167             return 0;
1168         }
1169     }
1170 #endif                          /* OPENSSL_NO_EC */
1171
1172     if (tls_use_ticket(s)) {
1173         size_t ticklen;
1174         if (!s->new_session && s->session && s->session->tlsext_tick)
1175             ticklen = s->session->tlsext_ticklen;
1176         else if (s->session && s->tlsext_session_ticket &&
1177                  s->tlsext_session_ticket->data) {
1178             ticklen = s->tlsext_session_ticket->length;
1179             s->session->tlsext_tick = OPENSSL_malloc(ticklen);
1180             if (s->session->tlsext_tick == NULL) {
1181                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1182                 return 0;
1183             }
1184             memcpy(s->session->tlsext_tick,
1185                    s->tlsext_session_ticket->data, ticklen);
1186             s->session->tlsext_ticklen = ticklen;
1187         } else
1188             ticklen = 0;
1189         if (ticklen == 0 && s->tlsext_session_ticket &&
1190             s->tlsext_session_ticket->data == NULL)
1191             goto skip_ext;
1192
1193         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket)
1194                 || !WPACKET_sub_memcpy_u16(pkt, s->session->tlsext_tick,
1195                                            ticklen)) {
1196             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1197             return 0;
1198         }
1199     }
1200  skip_ext:
1201
1202     if (SSL_CLIENT_USE_SIGALGS(s)) {
1203         size_t salglen;
1204         const unsigned char *salg;
1205
1206         salglen = tls12_get_psigalgs(s, &salg);
1207
1208         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signature_algorithms)
1209                    /* Sub-packet for sig-algs extension */
1210                 || !WPACKET_start_sub_packet_u16(pkt)
1211                    /* Sub-packet for the actual list */
1212                 || !WPACKET_start_sub_packet_u16(pkt)
1213                 || !tls12_copy_sigalgs(s, pkt, salg, salglen)
1214                 || !WPACKET_close(pkt)
1215                 || !WPACKET_close(pkt)) {
1216             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1217             return 0;
1218         }
1219     }
1220 #ifndef OPENSSL_NO_OCSP
1221     if (s->tlsext_status_type == TLSEXT_STATUSTYPE_ocsp) {
1222         int i;
1223
1224         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request)
1225                    /* Sub-packet for status request extension */
1226                 || !WPACKET_start_sub_packet_u16(pkt)
1227                 || !WPACKET_put_bytes_u8(pkt, TLSEXT_STATUSTYPE_ocsp)
1228                    /* Sub-packet for the ids */
1229                 || !WPACKET_start_sub_packet_u16(pkt)) {
1230             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1231             return 0;
1232         }
1233         for (i = 0; i < sk_OCSP_RESPID_num(s->tlsext_ocsp_ids); i++) {
1234             unsigned char *idbytes;
1235             int idlen;
1236             OCSP_RESPID *id;
1237
1238             id = sk_OCSP_RESPID_value(s->tlsext_ocsp_ids, i);
1239             idlen = i2d_OCSP_RESPID(id, NULL);
1240             if (idlen <= 0
1241                        /* Sub-packet for an individual id */
1242                     || !WPACKET_sub_allocate_bytes_u16(pkt, idlen, &idbytes)
1243                     || i2d_OCSP_RESPID(id, &idbytes) != idlen) {
1244                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1245                 return 0;
1246             }
1247         }
1248         if (!WPACKET_close(pkt)
1249                 || !WPACKET_start_sub_packet_u16(pkt)) {
1250             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1251             return 0;
1252         }
1253         if (s->tlsext_ocsp_exts) {
1254             unsigned char *extbytes;
1255             int extlen = i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts, NULL);
1256
1257             if (extlen < 0) {
1258                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1259                 return 0;
1260             }
1261             if (!WPACKET_allocate_bytes(pkt, extlen, &extbytes)
1262                     || i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts, &extbytes)
1263                        != extlen) {
1264                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1265                 return 0;
1266            }
1267         }
1268         if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
1269             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1270             return 0;
1271         }
1272     }
1273 #endif
1274
1275 #ifndef OPENSSL_NO_NEXTPROTONEG
1276     if (s->ctx->next_proto_select_cb && !s->s3->tmp.finish_md_len) {
1277         /*
1278          * The client advertises an empty extension to indicate its support
1279          * for Next Protocol Negotiation
1280          */
1281         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg)
1282                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1283             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1284             return 0;
1285         }
1286     }
1287 #endif
1288
1289     /*
1290      * finish_md_len is non-zero during a renegotiation, so
1291      * this avoids sending ALPN during the renegotiation
1292      * (see longer comment below)
1293      */
1294     if (s->alpn_client_proto_list && !s->s3->tmp.finish_md_len) {
1295         if (!WPACKET_put_bytes_u16(pkt,
1296                     TLSEXT_TYPE_application_layer_protocol_negotiation)
1297                    /* Sub-packet ALPN extension */
1298                 || !WPACKET_start_sub_packet_u16(pkt)
1299                 || !WPACKET_sub_memcpy_u16(pkt, s->alpn_client_proto_list,
1300                                            s->alpn_client_proto_list_len)
1301                 || !WPACKET_close(pkt)) {
1302             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1303             return 0;
1304         }
1305         s->s3->alpn_sent = 1;
1306     }
1307 #ifndef OPENSSL_NO_SRTP
1308     if (SSL_IS_DTLS(s) && SSL_get_srtp_profiles(s)) {
1309         STACK_OF(SRTP_PROTECTION_PROFILE) *clnt = SSL_get_srtp_profiles(s);
1310         SRTP_PROTECTION_PROFILE *prof;
1311         int i, ct;
1312
1313         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp)
1314                    /* Sub-packet for SRTP extension */
1315                 || !WPACKET_start_sub_packet_u16(pkt)
1316                    /* Sub-packet for the protection profile list */
1317                 || !WPACKET_start_sub_packet_u16(pkt)) {
1318             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1319             return 0;
1320         }
1321         ct = sk_SRTP_PROTECTION_PROFILE_num(clnt);
1322         for (i = 0; i < ct; i++) {
1323             prof = sk_SRTP_PROTECTION_PROFILE_value(clnt, i);
1324             if (prof == NULL || !WPACKET_put_bytes_u16(pkt, prof->id)) {
1325                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1326                 return 0;
1327             }
1328         }
1329         if (!WPACKET_close(pkt)
1330                    /* Add an empty use_mki value */
1331                 || !WPACKET_put_bytes_u8(pkt, 0)
1332                 || !WPACKET_close(pkt)) {
1333             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1334             return 0;
1335         }
1336     }
1337 #endif
1338     custom_ext_init(&s->cert->cli_ext);
1339     /* Add custom TLS Extensions to ClientHello */
1340     if (!custom_ext_add(s, 0, pkt, al)) {
1341         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1342         return 0;
1343     }
1344
1345     if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)) {
1346         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac)
1347             || !WPACKET_put_bytes_u16(pkt, 0)) {
1348             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1349             return 0;
1350         }
1351     }
1352
1353 #ifndef OPENSSL_NO_CT
1354     if (s->ct_validation_callback != NULL) {
1355         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signed_certificate_timestamp)
1356                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1357             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1358             return 0;
1359         }
1360     }
1361 #endif
1362
1363     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret)
1364             || !WPACKET_put_bytes_u16(pkt, 0)) {
1365         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1366         return 0;
1367     }
1368
1369     /* TLS1.3 specific extensions */
1370     if (SSL_IS_TLS13(s)) {
1371         int min_version, max_version, reason, currv;
1372         size_t i, sharessent = 0;
1373
1374         /* TODO(TLS1.3): Should we add this extension for versions < TLS1.3? */
1375         /* supported_versions extension */
1376         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_versions)
1377                 || !WPACKET_start_sub_packet_u16(pkt)
1378                 || !WPACKET_start_sub_packet_u8(pkt)) {
1379             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1380             return 0;
1381         }
1382         reason = ssl_get_client_min_max_version(s, &min_version, &max_version);
1383         if (reason != 0) {
1384             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, reason);
1385             return 0;
1386         }
1387         /*
1388          * TODO(TLS1.3): There is some discussion on the TLS list as to wheter
1389          * we should include versions <TLS1.2. For the moment we do. To be
1390          * reviewed later.
1391          */
1392         for (currv = max_version; currv >= min_version; currv--) {
1393             /* TODO(TLS1.3): Remove this first if clause prior to release!! */
1394             if (currv == TLS1_3_VERSION) {
1395                 if (!WPACKET_put_bytes_u16(pkt, TLS1_3_VERSION_DRAFT)) {
1396                     SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT,
1397                            ERR_R_INTERNAL_ERROR);
1398                     return 0;
1399                 }
1400             } else if (!WPACKET_put_bytes_u16(pkt, currv)) {
1401                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1402                 return 0;
1403             }
1404         }
1405         if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
1406             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1407             return 0;
1408         }
1409
1410
1411         /* key_share extension */
1412         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share)
1413                    /* Extension data sub-packet */
1414                 || !WPACKET_start_sub_packet_u16(pkt)
1415                    /* KeyShare list sub-packet */
1416                 || !WPACKET_start_sub_packet_u16(pkt)) {
1417             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1418             return 0;
1419         }
1420
1421         /*
1422          * TODO(TLS1.3): Make the number of key_shares sent configurable. For
1423          * now, just send one
1424          */
1425         for (i = 0; i < num_curves && sharessent < 1; i++, pcurves += 2) {
1426             if (tls_curve_allowed(s, pcurves, SSL_SECOP_CURVE_SUPPORTED)) {
1427                 unsigned char *encodedPoint = NULL;
1428                 unsigned int curve_id = 0;
1429                 EVP_PKEY *key_share_key = NULL;
1430                 size_t encodedlen;
1431
1432                 if (s->s3->tmp.pkey != NULL) {
1433                     /* Shouldn't happen! */
1434                     SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT,
1435                            ERR_R_INTERNAL_ERROR);
1436                     return 0;
1437                 }
1438
1439                 /* Generate a key for this key_share */
1440                 curve_id = (pcurves[0] << 8) | pcurves[1];
1441                 key_share_key = ssl_generate_pkey_curve(curve_id);
1442                 if (key_share_key == NULL) {
1443                     SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_EVP_LIB);
1444                     return 0;
1445                 }
1446
1447                 /* Encode the public key. */
1448                 encodedlen = EVP_PKEY_get1_tls_encodedpoint(key_share_key,
1449                                                             &encodedPoint);
1450                 if (encodedlen == 0) {
1451                     SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_EC_LIB);
1452                     EVP_PKEY_free(key_share_key);
1453                     return 0;
1454                 }
1455
1456                 /* Create KeyShareEntry */
1457                 if (!WPACKET_put_bytes_u16(pkt, curve_id)
1458                         || !WPACKET_sub_memcpy_u16(pkt, encodedPoint,
1459                                                    encodedlen)) {
1460                     SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT,
1461                            ERR_R_INTERNAL_ERROR);
1462                     EVP_PKEY_free(key_share_key);
1463                     OPENSSL_free(encodedPoint);
1464                     return 0;
1465                 }
1466
1467                 /*
1468                  * TODO(TLS1.3): When changing to send more than one key_share
1469                  * we're going to need to be able to save more than one EVP_PKEY
1470                  * For now we reuse the existing tmp.pkey
1471                  */
1472                 s->s3->group_id = curve_id;
1473                 s->s3->tmp.pkey = key_share_key;
1474                 sharessent++;
1475                 OPENSSL_free(encodedPoint);
1476             }
1477         }
1478         if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
1479             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1480             return 0;
1481         }
1482     }
1483
1484     /*
1485      * Add padding to workaround bugs in F5 terminators. See
1486      * https://tools.ietf.org/html/draft-agl-tls-padding-03 NB: because this
1487      * code works out the length of all existing extensions it MUST always
1488      * appear last.
1489      */
1490     if (s->options & SSL_OP_TLSEXT_PADDING) {
1491         unsigned char *padbytes;
1492         size_t hlen;
1493
1494         if (!WPACKET_get_total_written(pkt, &hlen)) {
1495             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1496             return 0;
1497         }
1498
1499         if (hlen > 0xff && hlen < 0x200) {
1500             hlen = 0x200 - hlen;
1501             if (hlen >= 4)
1502                 hlen -= 4;
1503             else
1504                 hlen = 0;
1505
1506             if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_padding)
1507                     || !WPACKET_sub_allocate_bytes_u16(pkt, hlen, &padbytes)) {
1508                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1509                 return 0;
1510             }
1511             memset(padbytes, 0, hlen);
1512         }
1513     }
1514
1515  done:
1516     return 1;
1517 }
1518
1519 int ssl_add_serverhello_tlsext(SSL *s, WPACKET *pkt, int *al)
1520 {
1521 #ifndef OPENSSL_NO_NEXTPROTONEG
1522     int next_proto_neg_seen;
1523 #endif
1524 #ifndef OPENSSL_NO_EC
1525     unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
1526     unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
1527     int using_ecc = (alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA);
1528     using_ecc = using_ecc && (s->session->tlsext_ecpointformatlist != NULL);
1529 #endif
1530
1531     if (!WPACKET_start_sub_packet_u16(pkt)
1532             || !WPACKET_set_flags(pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH)) {
1533         SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1534         return 0;
1535     }
1536
1537     if (s->s3->send_connection_binding &&
1538             !ssl_add_serverhello_renegotiate_ext(s, pkt)) {
1539         SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1540         return 0;
1541     }
1542
1543     /* Only add RI for SSLv3 */
1544     if (s->version == SSL3_VERSION)
1545         goto done;
1546
1547     if (!s->hit && s->servername_done == 1
1548             && s->session->tlsext_hostname != NULL) {
1549         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name)
1550                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1551             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1552             return 0;
1553         }
1554     }
1555 #ifndef OPENSSL_NO_EC
1556     if (using_ecc) {
1557         const unsigned char *plist;
1558         size_t plistlen;
1559         /*
1560          * Add TLS extension ECPointFormats to the ServerHello message
1561          */
1562         tls1_get_formatlist(s, &plist, &plistlen);
1563
1564         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats)
1565                 || !WPACKET_start_sub_packet_u16(pkt)
1566                 || !WPACKET_sub_memcpy_u8(pkt, plist, plistlen)
1567                 || !WPACKET_close(pkt)) {
1568             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1569             return 0;
1570         }
1571     }
1572     /*
1573      * Currently the server should not respond with a SupportedCurves
1574      * extension
1575      */
1576 #endif                          /* OPENSSL_NO_EC */
1577
1578     if (s->tlsext_ticket_expected && tls_use_ticket(s)) {
1579         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket)
1580                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1581             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1582             return 0;
1583         }
1584     } else {
1585         /*
1586          * if we don't add the above TLSEXT, we can't add a session ticket
1587          * later
1588          */
1589         s->tlsext_ticket_expected = 0;
1590     }
1591
1592     if (s->tlsext_status_expected) {
1593         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request)
1594                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1595             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1596             return 0;
1597         }
1598     }
1599 #ifndef OPENSSL_NO_SRTP
1600     if (SSL_IS_DTLS(s) && s->srtp_profile) {
1601         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp)
1602                 || !WPACKET_start_sub_packet_u16(pkt)
1603                 || !WPACKET_put_bytes_u16(pkt, 2)
1604                 || !WPACKET_put_bytes_u16(pkt, s->srtp_profile->id)
1605                 || !WPACKET_put_bytes_u8(pkt, 0)
1606                 || !WPACKET_close(pkt)) {
1607             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1608             return 0;
1609         }
1610     }
1611 #endif
1612
1613     if (((s->s3->tmp.new_cipher->id & 0xFFFF) == 0x80
1614          || (s->s3->tmp.new_cipher->id & 0xFFFF) == 0x81)
1615         && (SSL_get_options(s) & SSL_OP_CRYPTOPRO_TLSEXT_BUG)) {
1616         const unsigned char cryptopro_ext[36] = {
1617             0xfd, 0xe8,         /* 65000 */
1618             0x00, 0x20,         /* 32 bytes length */
1619             0x30, 0x1e, 0x30, 0x08, 0x06, 0x06, 0x2a, 0x85,
1620             0x03, 0x02, 0x02, 0x09, 0x30, 0x08, 0x06, 0x06,
1621             0x2a, 0x85, 0x03, 0x02, 0x02, 0x16, 0x30, 0x08,
1622             0x06, 0x06, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x17
1623         };
1624         if (!WPACKET_memcpy(pkt, cryptopro_ext, sizeof(cryptopro_ext))) {
1625             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1626             return 0;
1627         }
1628     }
1629
1630 #ifndef OPENSSL_NO_NEXTPROTONEG
1631     next_proto_neg_seen = s->s3->next_proto_neg_seen;
1632     s->s3->next_proto_neg_seen = 0;
1633     if (next_proto_neg_seen && s->ctx->next_protos_advertised_cb) {
1634         const unsigned char *npa;
1635         unsigned int npalen;
1636         int r;
1637
1638         r = s->ctx->next_protos_advertised_cb(s, &npa, &npalen,
1639                                               s->
1640                                               ctx->next_protos_advertised_cb_arg);
1641         if (r == SSL_TLSEXT_ERR_OK) {
1642             if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg)
1643                     || !WPACKET_sub_memcpy_u16(pkt, npa, npalen)) {
1644                 SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1645                 return 0;
1646             }
1647             s->s3->next_proto_neg_seen = 1;
1648         }
1649     }
1650 #endif
1651     if (!custom_ext_add(s, 1, pkt, al)) {
1652         SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1653         return 0;
1654     }
1655
1656     if (s->s3->flags & TLS1_FLAGS_ENCRYPT_THEN_MAC) {
1657         /*
1658          * Don't use encrypt_then_mac if AEAD or RC4 might want to disable
1659          * for other cases too.
1660          */
1661         if (s->s3->tmp.new_cipher->algorithm_mac == SSL_AEAD
1662             || s->s3->tmp.new_cipher->algorithm_enc == SSL_RC4
1663             || s->s3->tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT
1664             || s->s3->tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT12)
1665             s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
1666         else {
1667             if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac)
1668                     || !WPACKET_put_bytes_u16(pkt, 0)) {
1669                 SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1670                 return 0;
1671             }
1672         }
1673     }
1674     if (s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) {
1675         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret)
1676                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1677             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1678             return 0;
1679         }
1680     }
1681
1682     if (s->s3->alpn_selected != NULL) {
1683         if (!WPACKET_put_bytes_u16(pkt,
1684                     TLSEXT_TYPE_application_layer_protocol_negotiation)
1685                 || !WPACKET_start_sub_packet_u16(pkt)
1686                 || !WPACKET_start_sub_packet_u16(pkt)
1687                 || !WPACKET_sub_memcpy_u8(pkt, s->s3->alpn_selected,
1688                                           s->s3->alpn_selected_len)
1689                 || !WPACKET_close(pkt)
1690                 || !WPACKET_close(pkt)) {
1691             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1692             return 0;
1693         }
1694     }
1695
1696  done:
1697     if (!WPACKET_close(pkt)) {
1698         SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1699         return 0;
1700     }
1701     return 1;
1702 }
1703
1704 /*
1705  * Save the ALPN extension in a ClientHello.
1706  * pkt: the contents of the ALPN extension, not including type and length.
1707  * al: a pointer to the  alert value to send in the event of a failure.
1708  * returns: 1 on success, 0 on error.
1709  */
1710 static int tls1_alpn_handle_client_hello(SSL *s, PACKET *pkt, int *al)
1711 {
1712     PACKET protocol_list, save_protocol_list, protocol;
1713
1714     *al = SSL_AD_DECODE_ERROR;
1715
1716     if (!PACKET_as_length_prefixed_2(pkt, &protocol_list)
1717         || PACKET_remaining(&protocol_list) < 2) {
1718         return 0;
1719     }
1720
1721     save_protocol_list = protocol_list;
1722     do {
1723         /* Protocol names can't be empty. */
1724         if (!PACKET_get_length_prefixed_1(&protocol_list, &protocol)
1725             || PACKET_remaining(&protocol) == 0) {
1726             return 0;
1727         }
1728     } while (PACKET_remaining(&protocol_list) != 0);
1729
1730     if (!PACKET_memdup(&save_protocol_list,
1731                        &s->s3->alpn_proposed, &s->s3->alpn_proposed_len)) {
1732         *al = TLS1_AD_INTERNAL_ERROR;
1733         return 0;
1734     }
1735
1736     return 1;
1737 }
1738
1739 /*
1740  * Process the ALPN extension in a ClientHello.
1741  * al: a pointer to the alert value to send in the event of a failure.
1742  * returns 1 on success, 0 on error.
1743  */
1744 static int tls1_alpn_handle_client_hello_late(SSL *s, int *al)
1745 {
1746     const unsigned char *selected = NULL;
1747     unsigned char selected_len = 0;
1748
1749     if (s->ctx->alpn_select_cb != NULL && s->s3->alpn_proposed != NULL) {
1750         int r = s->ctx->alpn_select_cb(s, &selected, &selected_len,
1751                                        s->s3->alpn_proposed,
1752                                        (unsigned int)s->s3->alpn_proposed_len,
1753                                        s->ctx->alpn_select_cb_arg);
1754
1755         if (r == SSL_TLSEXT_ERR_OK) {
1756             OPENSSL_free(s->s3->alpn_selected);
1757             s->s3->alpn_selected = OPENSSL_memdup(selected, selected_len);
1758             if (s->s3->alpn_selected == NULL) {
1759                 *al = SSL_AD_INTERNAL_ERROR;
1760                 return 0;
1761             }
1762             s->s3->alpn_selected_len = selected_len;
1763 #ifndef OPENSSL_NO_NEXTPROTONEG
1764             /* ALPN takes precedence over NPN. */
1765             s->s3->next_proto_neg_seen = 0;
1766 #endif
1767         } else {
1768             *al = SSL_AD_NO_APPLICATION_PROTOCOL;
1769             return 0;
1770         }
1771     }
1772
1773     return 1;
1774 }
1775
1776 #ifndef OPENSSL_NO_EC
1777 /*-
1778  * ssl_check_for_safari attempts to fingerprint Safari using OS X
1779  * SecureTransport using the TLS extension block in |hello|.
1780  * Safari, since 10.6, sends exactly these extensions, in this order:
1781  *   SNI,
1782  *   elliptic_curves
1783  *   ec_point_formats
1784  *
1785  * We wish to fingerprint Safari because they broke ECDHE-ECDSA support in 10.8,
1786  * but they advertise support. So enabling ECDHE-ECDSA ciphers breaks them.
1787  * Sadly we cannot differentiate 10.6, 10.7 and 10.8.4 (which work), from
1788  * 10.8..10.8.3 (which don't work).
1789  */
1790 static void ssl_check_for_safari(SSL *s, const CLIENTHELLO_MSG *hello)
1791 {
1792     unsigned int type;
1793     PACKET sni, tmppkt;
1794     size_t ext_len;
1795
1796     static const unsigned char kSafariExtensionsBlock[] = {
1797         0x00, 0x0a,             /* elliptic_curves extension */
1798         0x00, 0x08,             /* 8 bytes */
1799         0x00, 0x06,             /* 6 bytes of curve ids */
1800         0x00, 0x17,             /* P-256 */
1801         0x00, 0x18,             /* P-384 */
1802         0x00, 0x19,             /* P-521 */
1803
1804         0x00, 0x0b,             /* ec_point_formats */
1805         0x00, 0x02,             /* 2 bytes */
1806         0x01,                   /* 1 point format */
1807         0x00,                   /* uncompressed */
1808         /* The following is only present in TLS 1.2 */
1809         0x00, 0x0d,             /* signature_algorithms */
1810         0x00, 0x0c,             /* 12 bytes */
1811         0x00, 0x0a,             /* 10 bytes */
1812         0x05, 0x01,             /* SHA-384/RSA */
1813         0x04, 0x01,             /* SHA-256/RSA */
1814         0x02, 0x01,             /* SHA-1/RSA */
1815         0x04, 0x03,             /* SHA-256/ECDSA */
1816         0x02, 0x03,             /* SHA-1/ECDSA */
1817     };
1818
1819     /* Length of the common prefix (first two extensions). */
1820     static const size_t kSafariCommonExtensionsLength = 18;
1821
1822     tmppkt = hello->extensions;
1823
1824     if (!PACKET_forward(&tmppkt, 2)
1825         || !PACKET_get_net_2(&tmppkt, &type)
1826         || !PACKET_get_length_prefixed_2(&tmppkt, &sni)) {
1827         return;
1828     }
1829
1830     if (type != TLSEXT_TYPE_server_name)
1831         return;
1832
1833     ext_len = TLS1_get_client_version(s) >= TLS1_2_VERSION ?
1834         sizeof(kSafariExtensionsBlock) : kSafariCommonExtensionsLength;
1835
1836     s->s3->is_probably_safari = PACKET_equal(&tmppkt, kSafariExtensionsBlock,
1837                                              ext_len);
1838 }
1839 #endif                          /* !OPENSSL_NO_EC */
1840
1841 /*
1842  * Loop through all remaining ClientHello extensions that we collected earlier
1843  * and haven't already processed. For each one parse it and update the SSL
1844  * object as required.
1845  *
1846  * Behaviour upon resumption is extension-specific. If the extension has no
1847  * effect during resumption, it is parsed (to verify its format) but otherwise
1848  * ignored.
1849  *
1850  * Returns 1 on success and 0 on failure.
1851  * Upon failure, sets |al| to the appropriate alert.
1852  */
1853 static int ssl_scan_clienthello_tlsext(SSL *s, CLIENTHELLO_MSG *hello, int *al)
1854 {
1855     size_t loop;
1856     int renegotiate_seen = 0;
1857
1858     *al = SSL_AD_DECODE_ERROR;
1859     s->servername_done = 0;
1860     s->tlsext_status_type = -1;
1861 #ifndef OPENSSL_NO_NEXTPROTONEG
1862     s->s3->next_proto_neg_seen = 0;
1863 #endif
1864
1865     OPENSSL_free(s->s3->alpn_selected);
1866     s->s3->alpn_selected = NULL;
1867     s->s3->alpn_selected_len = 0;
1868     OPENSSL_free(s->s3->alpn_proposed);
1869     s->s3->alpn_proposed = NULL;
1870     s->s3->alpn_proposed_len = 0;
1871
1872 #ifndef OPENSSL_NO_EC
1873     if (s->options & SSL_OP_SAFARI_ECDHE_ECDSA_BUG)
1874         ssl_check_for_safari(s, hello);
1875 #endif                          /* !OPENSSL_NO_EC */
1876
1877     /* Clear any signature algorithms extension received */
1878     OPENSSL_free(s->s3->tmp.peer_sigalgs);
1879     s->s3->tmp.peer_sigalgs = NULL;
1880     s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
1881
1882 #ifndef OPENSSL_NO_SRP
1883     OPENSSL_free(s->srp_ctx.login);
1884     s->srp_ctx.login = NULL;
1885 #endif
1886
1887     s->srtp_profile = NULL;
1888
1889     /*
1890      * We parse all extensions to ensure the ClientHello is well-formed but,
1891      * unless an extension specifies otherwise, we ignore extensions upon
1892      * resumption.
1893      */
1894     for (loop = 0; loop < hello->num_extensions; loop++) {
1895         RAW_EXTENSION *currext = &hello->pre_proc_exts[loop];
1896
1897         if (s->tlsext_debug_cb)
1898             s->tlsext_debug_cb(s, 0, currext->type,
1899                                PACKET_data(&currext->data),
1900                                PACKET_remaining(&currext->data),
1901                                s->tlsext_debug_arg);
1902
1903         if (currext->type == TLSEXT_TYPE_renegotiate) {
1904             if (!ssl_parse_clienthello_renegotiate_ext(s,
1905                     &currext->data, al))
1906                 return 0;
1907             renegotiate_seen = 1;
1908         } else if (s->version == SSL3_VERSION) {
1909         }
1910 /*-
1911  * The servername extension is treated as follows:
1912  *
1913  * - Only the hostname type is supported with a maximum length of 255.
1914  * - The servername is rejected if too long or if it contains zeros,
1915  *   in which case an fatal alert is generated.
1916  * - The servername field is maintained together with the session cache.
1917  * - When a session is resumed, the servername call back invoked in order
1918  *   to allow the application to position itself to the right context.
1919  * - The servername is acknowledged if it is new for a session or when
1920  *   it is identical to a previously used for the same session.
1921  *   Applications can control the behaviour.  They can at any time
1922  *   set a 'desirable' servername for a new SSL object. This can be the
1923  *   case for example with HTTPS when a Host: header field is received and
1924  *   a renegotiation is requested. In this case, a possible servername
1925  *   presented in the new client hello is only acknowledged if it matches
1926  *   the value of the Host: field.
1927  * - Applications must  use SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
1928  *   if they provide for changing an explicit servername context for the
1929  *   session, i.e. when the session has been established with a servername
1930  *   extension.
1931  * - On session reconnect, the servername extension may be absent.
1932  *
1933  */
1934
1935         else if (currext->type == TLSEXT_TYPE_server_name) {
1936             unsigned int servname_type;
1937             PACKET sni, hostname;
1938
1939             if (!PACKET_as_length_prefixed_2(&currext->data, &sni)
1940                 /* ServerNameList must be at least 1 byte long. */
1941                 || PACKET_remaining(&sni) == 0) {
1942                 return 0;
1943             }
1944
1945             /*
1946              * Although the server_name extension was intended to be
1947              * extensible to new name types, RFC 4366 defined the
1948              * syntax inextensibility and OpenSSL 1.0.x parses it as
1949              * such.
1950              * RFC 6066 corrected the mistake but adding new name types
1951              * is nevertheless no longer feasible, so act as if no other
1952              * SNI types can exist, to simplify parsing.
1953              *
1954              * Also note that the RFC permits only one SNI value per type,
1955              * i.e., we can only have a single hostname.
1956              */
1957             if (!PACKET_get_1(&sni, &servname_type)
1958                 || servname_type != TLSEXT_NAMETYPE_host_name
1959                 || !PACKET_as_length_prefixed_2(&sni, &hostname)) {
1960                 return 0;
1961             }
1962
1963             if (!s->hit) {
1964                 if (PACKET_remaining(&hostname) > TLSEXT_MAXLEN_host_name) {
1965                     *al = TLS1_AD_UNRECOGNIZED_NAME;
1966                     return 0;
1967                 }
1968
1969                 if (PACKET_contains_zero_byte(&hostname)) {
1970                     *al = TLS1_AD_UNRECOGNIZED_NAME;
1971                     return 0;
1972                 }
1973
1974                 if (!PACKET_strndup(&hostname, &s->session->tlsext_hostname)) {
1975                     *al = TLS1_AD_INTERNAL_ERROR;
1976                     return 0;
1977                 }
1978
1979                 s->servername_done = 1;
1980             } else {
1981                 /*
1982                  * TODO(openssl-team): if the SNI doesn't match, we MUST
1983                  * fall back to a full handshake.
1984                  */
1985                 s->servername_done = s->session->tlsext_hostname
1986                     && PACKET_equal(&hostname, s->session->tlsext_hostname,
1987                                     strlen(s->session->tlsext_hostname));
1988             }
1989         }
1990 #ifndef OPENSSL_NO_SRP
1991         else if (currext->type == TLSEXT_TYPE_srp) {
1992             PACKET srp_I;
1993
1994             if (!PACKET_as_length_prefixed_1(&currext->data, &srp_I))
1995                 return 0;
1996
1997             if (PACKET_contains_zero_byte(&srp_I))
1998                 return 0;
1999
2000             /*
2001              * TODO(openssl-team): currently, we re-authenticate the user
2002              * upon resumption. Instead, we MUST ignore the login.
2003              */
2004             if (!PACKET_strndup(&srp_I, &s->srp_ctx.login)) {
2005                 *al = TLS1_AD_INTERNAL_ERROR;
2006                 return 0;
2007             }
2008         }
2009 #endif
2010
2011 #ifndef OPENSSL_NO_EC
2012         else if (currext->type == TLSEXT_TYPE_ec_point_formats) {
2013             PACKET ec_point_format_list;
2014
2015             if (!PACKET_as_length_prefixed_1(&currext->data,
2016                                              &ec_point_format_list)
2017                 || PACKET_remaining(&ec_point_format_list) == 0) {
2018                 return 0;
2019             }
2020
2021             if (!s->hit) {
2022                 if (!PACKET_memdup(&ec_point_format_list,
2023                                    &s->session->tlsext_ecpointformatlist,
2024                                    &s->
2025                                    session->tlsext_ecpointformatlist_length)) {
2026                     *al = TLS1_AD_INTERNAL_ERROR;
2027                     return 0;
2028                 }
2029             }
2030         } else if (currext->type == TLSEXT_TYPE_supported_groups) {
2031             PACKET supported_groups_list;
2032
2033             /* Each group is 2 bytes and we must have at least 1. */
2034             if (!PACKET_as_length_prefixed_2(&currext->data,
2035                                              &supported_groups_list)
2036                 || PACKET_remaining(&supported_groups_list) == 0
2037                 || (PACKET_remaining(&supported_groups_list) % 2) != 0) {
2038                 return 0;
2039             }
2040
2041             if (!s->hit) {
2042                 if (!PACKET_memdup(&supported_groups_list,
2043                                    &s->session->tlsext_supportedgroupslist,
2044                                    &s->
2045                                    session->tlsext_supportedgroupslist_length)) {
2046                     *al = TLS1_AD_INTERNAL_ERROR;
2047                     return 0;
2048                 }
2049             }
2050         }
2051 #endif                          /* OPENSSL_NO_EC */
2052         else if (currext->type == TLSEXT_TYPE_session_ticket) {
2053             if (s->tls_session_ticket_ext_cb &&
2054                 !s->tls_session_ticket_ext_cb(s,
2055                     PACKET_data(&currext->data),
2056                     PACKET_remaining(&currext->data),
2057                     s->tls_session_ticket_ext_cb_arg)) {
2058                 *al = TLS1_AD_INTERNAL_ERROR;
2059                 return 0;
2060             }
2061         } else if (currext->type == TLSEXT_TYPE_signature_algorithms) {
2062             PACKET supported_sig_algs;
2063
2064             if (!PACKET_as_length_prefixed_2(&currext->data,
2065                                              &supported_sig_algs)
2066                 || (PACKET_remaining(&supported_sig_algs) % 2) != 0
2067                 || PACKET_remaining(&supported_sig_algs) == 0) {
2068                 return 0;
2069             }
2070
2071             if (!s->hit) {
2072                 if (!tls1_save_sigalgs(s, PACKET_data(&supported_sig_algs),
2073                                        PACKET_remaining(&supported_sig_algs))) {
2074                     return 0;
2075                 }
2076             }
2077         } else if (currext->type == TLSEXT_TYPE_status_request) {
2078             if (!PACKET_get_1(&currext->data,
2079                               (unsigned int *)&s->tlsext_status_type)) {
2080                 return 0;
2081             }
2082 #ifndef OPENSSL_NO_OCSP
2083             if (s->tlsext_status_type == TLSEXT_STATUSTYPE_ocsp) {
2084                 const unsigned char *ext_data;
2085                 PACKET responder_id_list, exts;
2086                 if (!PACKET_get_length_prefixed_2
2087                     (&currext->data, &responder_id_list))
2088                     return 0;
2089
2090                 /*
2091                  * We remove any OCSP_RESPIDs from a previous handshake
2092                  * to prevent unbounded memory growth - CVE-2016-6304
2093                  */
2094                 sk_OCSP_RESPID_pop_free(s->tlsext_ocsp_ids,
2095                                         OCSP_RESPID_free);
2096                 if (PACKET_remaining(&responder_id_list) > 0) {
2097                     s->tlsext_ocsp_ids = sk_OCSP_RESPID_new_null();
2098                     if (s->tlsext_ocsp_ids == NULL) {
2099                         *al = SSL_AD_INTERNAL_ERROR;
2100                         return 0;
2101                     }
2102                 } else {
2103                     s->tlsext_ocsp_ids = NULL;
2104                 }
2105
2106                 while (PACKET_remaining(&responder_id_list) > 0) {
2107                     OCSP_RESPID *id;
2108                     PACKET responder_id;
2109                     const unsigned char *id_data;
2110
2111                     if (!PACKET_get_length_prefixed_2(&responder_id_list,
2112                                                       &responder_id)
2113                         || PACKET_remaining(&responder_id) == 0) {
2114                         return 0;
2115                     }
2116
2117                     id_data = PACKET_data(&responder_id);
2118                     /* TODO(size_t): Convert d2i_* to size_t */
2119                     id = d2i_OCSP_RESPID(NULL, &id_data,
2120                                          (int)PACKET_remaining(&responder_id));
2121                     if (id == NULL)
2122                         return 0;
2123
2124                     if (id_data != PACKET_end(&responder_id)) {
2125                         OCSP_RESPID_free(id);
2126                         return 0;
2127                     }
2128
2129                     if (!sk_OCSP_RESPID_push(s->tlsext_ocsp_ids, id)) {
2130                         OCSP_RESPID_free(id);
2131                         *al = SSL_AD_INTERNAL_ERROR;
2132                         return 0;
2133                     }
2134                 }
2135
2136                 /* Read in request_extensions */
2137                 if (!PACKET_as_length_prefixed_2(
2138                         &currext->data, &exts))
2139                     return 0;
2140
2141                 if (PACKET_remaining(&exts) > 0) {
2142                     ext_data = PACKET_data(&exts);
2143                     sk_X509_EXTENSION_pop_free(s->tlsext_ocsp_exts,
2144                                                X509_EXTENSION_free);
2145                     s->tlsext_ocsp_exts =
2146                         d2i_X509_EXTENSIONS(NULL, &ext_data,
2147                                             (int)PACKET_remaining(&exts));
2148                     if (s->tlsext_ocsp_exts == NULL
2149                         || ext_data != PACKET_end(&exts)) {
2150                         return 0;
2151                     }
2152                 }
2153             } else
2154 #endif
2155             {
2156                 /*
2157                  * We don't know what to do with any other type so ignore it.
2158                  */
2159                 s->tlsext_status_type = -1;
2160             }
2161         }
2162 #ifndef OPENSSL_NO_NEXTPROTONEG
2163         else if (currext->type == TLSEXT_TYPE_next_proto_neg
2164                  && s->s3->tmp.finish_md_len == 0) {
2165             /*-
2166              * We shouldn't accept this extension on a
2167              * renegotiation.
2168              *
2169              * s->new_session will be set on renegotiation, but we
2170              * probably shouldn't rely that it couldn't be set on
2171              * the initial renegotiation too in certain cases (when
2172              * there's some other reason to disallow resuming an
2173              * earlier session -- the current code won't be doing
2174              * anything like that, but this might change).
2175              *
2176              * A valid sign that there's been a previous handshake
2177              * in this connection is if s->s3->tmp.finish_md_len >
2178              * 0.  (We are talking about a check that will happen
2179              * in the Hello protocol round, well before a new
2180              * Finished message could have been computed.)
2181              */
2182             s->s3->next_proto_neg_seen = 1;
2183         }
2184 #endif
2185
2186         else if (currext->type
2187                      == TLSEXT_TYPE_application_layer_protocol_negotiation
2188                  && s->s3->tmp.finish_md_len == 0) {
2189             if (!tls1_alpn_handle_client_hello(s,
2190                     &currext->data, al))
2191                 return 0;
2192         }
2193
2194         /* session ticket processed earlier */
2195 #ifndef OPENSSL_NO_SRTP
2196         else if (SSL_IS_DTLS(s) && SSL_get_srtp_profiles(s)
2197                  && currext->type == TLSEXT_TYPE_use_srtp) {
2198             if (ssl_parse_clienthello_use_srtp_ext(s,
2199                     &currext->data, al))
2200                 return 0;
2201         }
2202 #endif
2203         else if (currext->type == TLSEXT_TYPE_encrypt_then_mac
2204                  && !(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)) {
2205             s->s3->flags |= TLS1_FLAGS_ENCRYPT_THEN_MAC;
2206         } else if (currext->type == TLSEXT_TYPE_key_share
2207                    && s->version == TLS1_3_VERSION) {
2208             unsigned int group_id;
2209             PACKET key_share_list, encoded_pt;
2210             const unsigned char *curves;
2211             size_t num_curves, i;
2212             int group_nid;
2213             unsigned int curve_flags;
2214
2215             /* Sanity check */
2216             if (s->s3->peer_tmp != NULL) {
2217                 *al = SSL_AD_INTERNAL_ERROR;
2218                 SSLerr(SSL_F_SSL_SCAN_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
2219                 return 0;
2220             }
2221
2222             if (!PACKET_as_length_prefixed_2(&currext->data, &key_share_list)) {
2223                 *al = SSL_AD_HANDSHAKE_FAILURE;
2224                 SSLerr(SSL_F_SSL_SCAN_CLIENTHELLO_TLSEXT,
2225                        SSL_R_LENGTH_MISMATCH);
2226                 return 0;
2227             }
2228
2229             while (PACKET_remaining(&key_share_list) > 0) {
2230                 if (!PACKET_get_net_2(&key_share_list, &group_id)
2231                         || !PACKET_get_length_prefixed_2(&key_share_list,
2232                                                          &encoded_pt)) {
2233                     *al = SSL_AD_HANDSHAKE_FAILURE;
2234                     SSLerr(SSL_F_SSL_SCAN_CLIENTHELLO_TLSEXT,
2235                            SSL_R_LENGTH_MISMATCH);
2236                     return 0;
2237                 }
2238
2239                 /* Find a share that we can use */
2240                 if (!tls1_get_curvelist(s, 0, &curves, &num_curves)) {
2241                     *al = SSL_AD_INTERNAL_ERROR;
2242                     SSLerr(SSL_F_SSL_SCAN_CLIENTHELLO_TLSEXT,
2243                            ERR_R_INTERNAL_ERROR);
2244                     return 0;
2245                 }
2246                 for (i = 0; i < num_curves; i++, curves += 2) {
2247                     unsigned int share_id = (curves[0] << 8) | (curves[1]);
2248                     if (group_id == share_id
2249                             && tls_curve_allowed(s, curves,
2250                                                  SSL_SECOP_CURVE_CHECK)) {
2251                         break;
2252                     }
2253                 }
2254
2255                 if (i == num_curves) {
2256                     /* Share not suitable */
2257                     continue;
2258                 }
2259
2260                 group_nid = tls1_ec_curve_id2nid(group_id, &curve_flags);
2261
2262                 if (group_nid == 0) {
2263                     *al = SSL_AD_INTERNAL_ERROR;
2264                     SSLerr(SSL_F_SSL_SCAN_CLIENTHELLO_TLSEXT,
2265                            SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS);
2266                     return 0;
2267                 }
2268
2269                 if ((curve_flags & TLS_CURVE_TYPE) == TLS_CURVE_CUSTOM) {
2270                     /* Can happen for some curves, e.g. X25519 */
2271                     EVP_PKEY *key = EVP_PKEY_new();
2272
2273                     if (key == NULL || !EVP_PKEY_set_type(key, group_nid)) {
2274                         *al = SSL_AD_INTERNAL_ERROR;
2275                         SSLerr(SSL_F_SSL_SCAN_CLIENTHELLO_TLSEXT, ERR_R_EVP_LIB);
2276                         EVP_PKEY_free(key);
2277                         return 0;
2278                     }
2279                     s->s3->peer_tmp = key;
2280                 } else {
2281                     /* Set up EVP_PKEY with named curve as parameters */
2282                     EVP_PKEY_CTX *pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
2283                     if (pctx == NULL
2284                         || EVP_PKEY_paramgen_init(pctx) <= 0
2285                         || EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx,
2286                                                                   group_nid) <= 0
2287                         || EVP_PKEY_paramgen(pctx, &s->s3->peer_tmp) <= 0) {
2288                         *al = SSL_AD_INTERNAL_ERROR;
2289                         SSLerr(SSL_F_SSL_SCAN_CLIENTHELLO_TLSEXT, ERR_R_EVP_LIB);
2290                         EVP_PKEY_CTX_free(pctx);
2291                         return 0;
2292                     }
2293                     EVP_PKEY_CTX_free(pctx);
2294                     pctx = NULL;
2295                 }
2296
2297                 if (!EVP_PKEY_set1_tls_encodedpoint(s->s3->peer_tmp,
2298                         PACKET_data(&encoded_pt),
2299                         PACKET_remaining(&encoded_pt))) {
2300                     *al = SSL_AD_DECODE_ERROR;
2301                     SSLerr(SSL_F_SSL_SCAN_CLIENTHELLO_TLSEXT, SSL_R_BAD_ECPOINT);
2302                     return 0;
2303                 }
2304             }
2305         }
2306         /*
2307          * Note: extended master secret extension handled in
2308          * tls_check_client_ems_support()
2309          */
2310
2311         /*
2312          * If this ClientHello extension was unhandled and this is a
2313          * nonresumed connection, check whether the extension is a custom
2314          * TLS Extension (has a custom_srv_ext_record), and if so call the
2315          * callback and record the extension number so that an appropriate
2316          * ServerHello may be later returned.
2317          */
2318         else if (!s->hit) {
2319             if (custom_ext_parse(s, 1, currext->type,
2320                     PACKET_data(&currext->data),
2321                     PACKET_remaining(&currext->data), al) <= 0)
2322                 return 0;
2323         }
2324     }
2325
2326     /* Need RI if renegotiating */
2327
2328     if (!renegotiate_seen && s->renegotiate &&
2329         !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)) {
2330         *al = SSL_AD_HANDSHAKE_FAILURE;
2331         SSLerr(SSL_F_SSL_SCAN_CLIENTHELLO_TLSEXT,
2332                SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
2333         return 0;
2334     }
2335
2336     /*
2337      * This function currently has no state to clean up, so it returns directly.
2338      * If parsing fails at any point, the function returns early.
2339      * The SSL object may be left with partial data from extensions, but it must
2340      * then no longer be used, and clearing it up will free the leftovers.
2341      */
2342     return 1;
2343 }
2344
2345 int ssl_parse_clienthello_tlsext(SSL *s, CLIENTHELLO_MSG *hello)
2346 {
2347     int al = -1;
2348     custom_ext_init(&s->cert->srv_ext);
2349     if (ssl_scan_clienthello_tlsext(s, hello, &al) <= 0) {
2350         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2351         return 0;
2352     }
2353     if (ssl_check_clienthello_tlsext_early(s) <= 0) {
2354         SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_TLSEXT, SSL_R_CLIENTHELLO_TLSEXT);
2355         return 0;
2356     }
2357     return 1;
2358 }
2359
2360 #ifndef OPENSSL_NO_NEXTPROTONEG
2361 /*
2362  * ssl_next_proto_validate validates a Next Protocol Negotiation block. No
2363  * elements of zero length are allowed and the set of elements must exactly
2364  * fill the length of the block.
2365  */
2366 static char ssl_next_proto_validate(PACKET *pkt)
2367 {
2368     PACKET tmp_protocol;
2369
2370     while (PACKET_remaining(pkt)) {
2371         if (!PACKET_get_length_prefixed_1(pkt, &tmp_protocol)
2372             || PACKET_remaining(&tmp_protocol) == 0)
2373             return 0;
2374     }
2375
2376     return 1;
2377 }
2378 #endif
2379
2380 static int ssl_scan_serverhello_tlsext(SSL *s, PACKET *pkt, int *al)
2381 {
2382     unsigned int length, type, size;
2383     int tlsext_servername = 0;
2384     int renegotiate_seen = 0;
2385
2386 #ifndef OPENSSL_NO_NEXTPROTONEG
2387     s->s3->next_proto_neg_seen = 0;
2388 #endif
2389     s->tlsext_ticket_expected = 0;
2390
2391     OPENSSL_free(s->s3->alpn_selected);
2392     s->s3->alpn_selected = NULL;
2393
2394     s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
2395
2396     s->s3->flags &= ~TLS1_FLAGS_RECEIVED_EXTMS;
2397
2398     if (!PACKET_get_net_2(pkt, &length))
2399         goto ri_check;
2400
2401     if (PACKET_remaining(pkt) != length) {
2402         *al = SSL_AD_DECODE_ERROR;
2403         return 0;
2404     }
2405
2406     if (!tls1_check_duplicate_extensions(pkt)) {
2407         *al = SSL_AD_DECODE_ERROR;
2408         return 0;
2409     }
2410
2411     while (PACKET_get_net_2(pkt, &type) && PACKET_get_net_2(pkt, &size)) {
2412         const unsigned char *data;
2413         PACKET spkt;
2414
2415         if (!PACKET_get_sub_packet(pkt, &spkt, size)
2416             || !PACKET_peek_bytes(&spkt, &data, size))
2417             goto ri_check;
2418
2419         if (s->tlsext_debug_cb)
2420             s->tlsext_debug_cb(s, 1, type, data, size, s->tlsext_debug_arg);
2421
2422         if (type == TLSEXT_TYPE_renegotiate) {
2423             if (!ssl_parse_serverhello_renegotiate_ext(s, &spkt, al))
2424                 return 0;
2425             renegotiate_seen = 1;
2426         } else if (s->version == SSL3_VERSION) {
2427         } else if (type == TLSEXT_TYPE_server_name) {
2428             if (s->tlsext_hostname == NULL || size > 0) {
2429                 *al = TLS1_AD_UNRECOGNIZED_NAME;
2430                 return 0;
2431             }
2432             tlsext_servername = 1;
2433         }
2434 #ifndef OPENSSL_NO_EC
2435         else if (type == TLSEXT_TYPE_ec_point_formats) {
2436             unsigned int ecpointformatlist_length;
2437             if (!PACKET_get_1(&spkt, &ecpointformatlist_length)
2438                 || ecpointformatlist_length != size - 1) {
2439                 *al = TLS1_AD_DECODE_ERROR;
2440                 return 0;
2441             }
2442             if (!s->hit) {
2443                 s->session->tlsext_ecpointformatlist_length = 0;
2444                 OPENSSL_free(s->session->tlsext_ecpointformatlist);
2445                 if ((s->session->tlsext_ecpointformatlist =
2446                      OPENSSL_malloc(ecpointformatlist_length)) == NULL) {
2447                     *al = TLS1_AD_INTERNAL_ERROR;
2448                     return 0;
2449                 }
2450                 s->session->tlsext_ecpointformatlist_length =
2451                     ecpointformatlist_length;
2452                 if (!PACKET_copy_bytes(&spkt,
2453                                        s->session->tlsext_ecpointformatlist,
2454                                        ecpointformatlist_length)) {
2455                     *al = TLS1_AD_DECODE_ERROR;
2456                     return 0;
2457                 }
2458
2459             }
2460         }
2461 #endif                          /* OPENSSL_NO_EC */
2462
2463         else if (type == TLSEXT_TYPE_session_ticket) {
2464             if (s->tls_session_ticket_ext_cb &&
2465                 !s->tls_session_ticket_ext_cb(s, data, size,
2466                                               s->tls_session_ticket_ext_cb_arg))
2467             {
2468                 *al = TLS1_AD_INTERNAL_ERROR;
2469                 return 0;
2470             }
2471             if (!tls_use_ticket(s) || (size > 0)) {
2472                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
2473                 return 0;
2474             }
2475             s->tlsext_ticket_expected = 1;
2476         } else if (type == TLSEXT_TYPE_status_request) {
2477             /*
2478              * MUST be empty and only sent if we've requested a status
2479              * request message.
2480              */
2481             if ((s->tlsext_status_type == -1) || (size > 0)) {
2482                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
2483                 return 0;
2484             }
2485             /* Set flag to expect CertificateStatus message */
2486             s->tlsext_status_expected = 1;
2487         }
2488 #ifndef OPENSSL_NO_CT
2489         /*
2490          * Only take it if we asked for it - i.e if there is no CT validation
2491          * callback set, then a custom extension MAY be processing it, so we
2492          * need to let control continue to flow to that.
2493          */
2494         else if (type == TLSEXT_TYPE_signed_certificate_timestamp &&
2495                  s->ct_validation_callback != NULL) {
2496             /* Simply copy it off for later processing */
2497             if (s->tlsext_scts != NULL) {
2498                 OPENSSL_free(s->tlsext_scts);
2499                 s->tlsext_scts = NULL;
2500             }
2501             s->tlsext_scts_len = size;
2502             if (size > 0) {
2503                 s->tlsext_scts = OPENSSL_malloc(size);
2504                 if (s->tlsext_scts == NULL) {
2505                     *al = TLS1_AD_INTERNAL_ERROR;
2506                     return 0;
2507                 }
2508                 memcpy(s->tlsext_scts, data, size);
2509             }
2510         }
2511 #endif
2512 #ifndef OPENSSL_NO_NEXTPROTONEG
2513         else if (type == TLSEXT_TYPE_next_proto_neg &&
2514                  s->s3->tmp.finish_md_len == 0) {
2515             unsigned char *selected;
2516             unsigned char selected_len;
2517             /* We must have requested it. */
2518             if (s->ctx->next_proto_select_cb == NULL) {
2519                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
2520                 return 0;
2521             }
2522             /* The data must be valid */
2523             if (!ssl_next_proto_validate(&spkt)) {
2524                 *al = TLS1_AD_DECODE_ERROR;
2525                 return 0;
2526             }
2527             if (s->ctx->next_proto_select_cb(s, &selected, &selected_len, data,
2528                                              size,
2529                                              s->
2530                                              ctx->next_proto_select_cb_arg) !=
2531                 SSL_TLSEXT_ERR_OK) {
2532                 *al = TLS1_AD_INTERNAL_ERROR;
2533                 return 0;
2534             }
2535             /*
2536              * Could be non-NULL if server has sent multiple NPN extensions in
2537              * a single Serverhello
2538              */
2539             OPENSSL_free(s->next_proto_negotiated);
2540             s->next_proto_negotiated = OPENSSL_malloc(selected_len);
2541             if (s->next_proto_negotiated == NULL) {
2542                 *al = TLS1_AD_INTERNAL_ERROR;
2543                 return 0;
2544             }
2545             memcpy(s->next_proto_negotiated, selected, selected_len);
2546             s->next_proto_negotiated_len = selected_len;
2547             s->s3->next_proto_neg_seen = 1;
2548         }
2549 #endif
2550
2551         else if (type == TLSEXT_TYPE_application_layer_protocol_negotiation) {
2552             unsigned len;
2553             /* We must have requested it. */
2554             if (!s->s3->alpn_sent) {
2555                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
2556                 return 0;
2557             }
2558             /*-
2559              * The extension data consists of:
2560              *   uint16 list_length
2561              *   uint8 proto_length;
2562              *   uint8 proto[proto_length];
2563              */
2564             if (!PACKET_get_net_2(&spkt, &len)
2565                 || PACKET_remaining(&spkt) != len || !PACKET_get_1(&spkt, &len)
2566                 || PACKET_remaining(&spkt) != len) {
2567                 *al = TLS1_AD_DECODE_ERROR;
2568                 return 0;
2569             }
2570             OPENSSL_free(s->s3->alpn_selected);
2571             s->s3->alpn_selected = OPENSSL_malloc(len);
2572             if (s->s3->alpn_selected == NULL) {
2573                 *al = TLS1_AD_INTERNAL_ERROR;
2574                 return 0;
2575             }
2576             if (!PACKET_copy_bytes(&spkt, s->s3->alpn_selected, len)) {
2577                 *al = TLS1_AD_DECODE_ERROR;
2578                 return 0;
2579             }
2580             s->s3->alpn_selected_len = len;
2581         }
2582 #ifndef OPENSSL_NO_SRTP
2583         else if (SSL_IS_DTLS(s) && type == TLSEXT_TYPE_use_srtp) {
2584             if (ssl_parse_serverhello_use_srtp_ext(s, &spkt, al))
2585                 return 0;
2586         }
2587 #endif
2588         else if (type == TLSEXT_TYPE_encrypt_then_mac) {
2589             /* Ignore if inappropriate ciphersuite */
2590             if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC) &&
2591                 s->s3->tmp.new_cipher->algorithm_mac != SSL_AEAD
2592                 && s->s3->tmp.new_cipher->algorithm_enc != SSL_RC4)
2593                 s->s3->flags |= TLS1_FLAGS_ENCRYPT_THEN_MAC;
2594         } else if (type == TLSEXT_TYPE_extended_master_secret) {
2595             s->s3->flags |= TLS1_FLAGS_RECEIVED_EXTMS;
2596             if (!s->hit)
2597                 s->session->flags |= SSL_SESS_FLAG_EXTMS;
2598         }
2599         /*
2600          * If this extension type was not otherwise handled, but matches a
2601          * custom_cli_ext_record, then send it to the c callback
2602          */
2603         else if (custom_ext_parse(s, 0, type, data, size, al) <= 0)
2604             return 0;
2605     }
2606
2607     if (PACKET_remaining(pkt) != 0) {
2608         *al = SSL_AD_DECODE_ERROR;
2609         return 0;
2610     }
2611
2612     if (!s->hit && tlsext_servername == 1) {
2613         if (s->tlsext_hostname) {
2614             if (s->session->tlsext_hostname == NULL) {
2615                 s->session->tlsext_hostname =
2616                     OPENSSL_strdup(s->tlsext_hostname);
2617                 if (!s->session->tlsext_hostname) {
2618                     *al = SSL_AD_UNRECOGNIZED_NAME;
2619                     return 0;
2620                 }
2621             } else {
2622                 *al = SSL_AD_DECODE_ERROR;
2623                 return 0;
2624             }
2625         }
2626     }
2627
2628  ri_check:
2629
2630     /*
2631      * Determine if we need to see RI. Strictly speaking if we want to avoid
2632      * an attack we should *always* see RI even on initial server hello
2633      * because the client doesn't see any renegotiation during an attack.
2634      * However this would mean we could not connect to any server which
2635      * doesn't support RI so for the immediate future tolerate RI absence
2636      */
2637     if (!renegotiate_seen && !(s->options & SSL_OP_LEGACY_SERVER_CONNECT)
2638         && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)) {
2639         *al = SSL_AD_HANDSHAKE_FAILURE;
2640         SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT,
2641                SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
2642         return 0;
2643     }
2644
2645     if (s->hit) {
2646         /*
2647          * Check extended master secret extension is consistent with
2648          * original session.
2649          */
2650         if (!(s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) !=
2651             !(s->session->flags & SSL_SESS_FLAG_EXTMS)) {
2652             *al = SSL_AD_HANDSHAKE_FAILURE;
2653             SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT, SSL_R_INCONSISTENT_EXTMS);
2654             return 0;
2655         }
2656     }
2657
2658     return 1;
2659 }
2660
2661 int ssl_prepare_clienthello_tlsext(SSL *s)
2662 {
2663     s->s3->alpn_sent = 0;
2664     return 1;
2665 }
2666
2667 int ssl_prepare_serverhello_tlsext(SSL *s)
2668 {
2669     return 1;
2670 }
2671
2672 static int ssl_check_clienthello_tlsext_early(SSL *s)
2673 {
2674     int ret = SSL_TLSEXT_ERR_NOACK;
2675     int al = SSL_AD_UNRECOGNIZED_NAME;
2676
2677 #ifndef OPENSSL_NO_EC
2678     /*
2679      * The handling of the ECPointFormats extension is done elsewhere, namely
2680      * in ssl3_choose_cipher in s3_lib.c.
2681      */
2682     /*
2683      * The handling of the EllipticCurves extension is done elsewhere, namely
2684      * in ssl3_choose_cipher in s3_lib.c.
2685      */
2686 #endif
2687
2688     if (s->ctx != NULL && s->ctx->tlsext_servername_callback != 0)
2689         ret =
2690             s->ctx->tlsext_servername_callback(s, &al,
2691                                                s->ctx->tlsext_servername_arg);
2692     else if (s->initial_ctx != NULL
2693              && s->initial_ctx->tlsext_servername_callback != 0)
2694         ret =
2695             s->initial_ctx->tlsext_servername_callback(s, &al,
2696                                                        s->
2697                                                        initial_ctx->tlsext_servername_arg);
2698
2699     switch (ret) {
2700     case SSL_TLSEXT_ERR_ALERT_FATAL:
2701         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2702         return -1;
2703
2704     case SSL_TLSEXT_ERR_ALERT_WARNING:
2705         ssl3_send_alert(s, SSL3_AL_WARNING, al);
2706         return 1;
2707
2708     case SSL_TLSEXT_ERR_NOACK:
2709         s->servername_done = 0;
2710     default:
2711         return 1;
2712     }
2713 }
2714
2715 /* Initialise digests to default values */
2716 void ssl_set_default_md(SSL *s)
2717 {
2718     const EVP_MD **pmd = s->s3->tmp.md;
2719 #ifndef OPENSSL_NO_DSA
2720     pmd[SSL_PKEY_DSA_SIGN] = ssl_md(SSL_MD_SHA1_IDX);
2721 #endif
2722 #ifndef OPENSSL_NO_RSA
2723     if (SSL_USE_SIGALGS(s))
2724         pmd[SSL_PKEY_RSA_SIGN] = ssl_md(SSL_MD_SHA1_IDX);
2725     else
2726         pmd[SSL_PKEY_RSA_SIGN] = ssl_md(SSL_MD_MD5_SHA1_IDX);
2727     pmd[SSL_PKEY_RSA_ENC] = pmd[SSL_PKEY_RSA_SIGN];
2728 #endif
2729 #ifndef OPENSSL_NO_EC
2730     pmd[SSL_PKEY_ECC] = ssl_md(SSL_MD_SHA1_IDX);
2731 #endif
2732 #ifndef OPENSSL_NO_GOST
2733     pmd[SSL_PKEY_GOST01] = ssl_md(SSL_MD_GOST94_IDX);
2734     pmd[SSL_PKEY_GOST12_256] = ssl_md(SSL_MD_GOST12_256_IDX);
2735     pmd[SSL_PKEY_GOST12_512] = ssl_md(SSL_MD_GOST12_512_IDX);
2736 #endif
2737 }
2738
2739 int tls1_set_server_sigalgs(SSL *s)
2740 {
2741     int al;
2742     size_t i;
2743
2744     /* Clear any shared signature algorithms */
2745     OPENSSL_free(s->cert->shared_sigalgs);
2746     s->cert->shared_sigalgs = NULL;
2747     s->cert->shared_sigalgslen = 0;
2748     /* Clear certificate digests and validity flags */
2749     for (i = 0; i < SSL_PKEY_NUM; i++) {
2750         s->s3->tmp.md[i] = NULL;
2751         s->s3->tmp.valid_flags[i] = 0;
2752     }
2753
2754     /* If sigalgs received process it. */
2755     if (s->s3->tmp.peer_sigalgs) {
2756         if (!tls1_process_sigalgs(s)) {
2757             SSLerr(SSL_F_TLS1_SET_SERVER_SIGALGS, ERR_R_MALLOC_FAILURE);
2758             al = SSL_AD_INTERNAL_ERROR;
2759             goto err;
2760         }
2761         /* Fatal error is no shared signature algorithms */
2762         if (!s->cert->shared_sigalgs) {
2763             SSLerr(SSL_F_TLS1_SET_SERVER_SIGALGS,
2764                    SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS);
2765             al = SSL_AD_ILLEGAL_PARAMETER;
2766             goto err;
2767         }
2768     } else {
2769         ssl_set_default_md(s);
2770     }
2771     return 1;
2772  err:
2773     ssl3_send_alert(s, SSL3_AL_FATAL, al);
2774     return 0;
2775 }
2776
2777 /*
2778  * Upon success, returns 1.
2779  * Upon failure, returns 0 and sets |al| to the appropriate fatal alert.
2780  */
2781 int ssl_check_clienthello_tlsext_late(SSL *s, int *al)
2782 {
2783     s->tlsext_status_expected = 0;
2784
2785     /*
2786      * If status request then ask callback what to do. Note: this must be
2787      * called after servername callbacks in case the certificate has changed,
2788      * and must be called after the cipher has been chosen because this may
2789      * influence which certificate is sent
2790      */
2791     if ((s->tlsext_status_type != -1) && s->ctx && s->ctx->tlsext_status_cb) {
2792         int ret;
2793         CERT_PKEY *certpkey;
2794         certpkey = ssl_get_server_send_pkey(s);
2795         /* If no certificate can't return certificate status */
2796         if (certpkey != NULL) {
2797             /*
2798              * Set current certificate to one we will use so SSL_get_certificate
2799              * et al can pick it up.
2800              */
2801             s->cert->key = certpkey;
2802             ret = s->ctx->tlsext_status_cb(s, s->ctx->tlsext_status_arg);
2803             switch (ret) {
2804                 /* We don't want to send a status request response */
2805             case SSL_TLSEXT_ERR_NOACK:
2806                 s->tlsext_status_expected = 0;
2807                 break;
2808                 /* status request response should be sent */
2809             case SSL_TLSEXT_ERR_OK:
2810                 if (s->tlsext_ocsp_resp)
2811                     s->tlsext_status_expected = 1;
2812                 break;
2813                 /* something bad happened */
2814             case SSL_TLSEXT_ERR_ALERT_FATAL:
2815             default:
2816                 *al = SSL_AD_INTERNAL_ERROR;
2817                 return 0;
2818             }
2819         }
2820     }
2821
2822     if (!tls1_alpn_handle_client_hello_late(s, al)) {
2823         return 0;
2824     }
2825
2826     return 1;
2827 }
2828
2829 int ssl_check_serverhello_tlsext(SSL *s)
2830 {
2831     int ret = SSL_TLSEXT_ERR_NOACK;
2832     int al = SSL_AD_UNRECOGNIZED_NAME;
2833
2834 #ifndef OPENSSL_NO_EC
2835     /*
2836      * If we are client and using an elliptic curve cryptography cipher
2837      * suite, then if server returns an EC point formats lists extension it
2838      * must contain uncompressed.
2839      */
2840     unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
2841     unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
2842     if ((s->tlsext_ecpointformatlist != NULL)
2843         && (s->tlsext_ecpointformatlist_length > 0)
2844         && (s->session->tlsext_ecpointformatlist != NULL)
2845         && (s->session->tlsext_ecpointformatlist_length > 0)
2846         && ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))) {
2847         /* we are using an ECC cipher */
2848         size_t i;
2849         unsigned char *list;
2850         int found_uncompressed = 0;
2851         list = s->session->tlsext_ecpointformatlist;
2852         for (i = 0; i < s->session->tlsext_ecpointformatlist_length; i++) {
2853             if (*(list++) == TLSEXT_ECPOINTFORMAT_uncompressed) {
2854                 found_uncompressed = 1;
2855                 break;
2856             }
2857         }
2858         if (!found_uncompressed) {
2859             SSLerr(SSL_F_SSL_CHECK_SERVERHELLO_TLSEXT,
2860                    SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST);
2861             return -1;
2862         }
2863     }
2864     ret = SSL_TLSEXT_ERR_OK;
2865 #endif                          /* OPENSSL_NO_EC */
2866
2867     if (s->ctx != NULL && s->ctx->tlsext_servername_callback != 0)
2868         ret =
2869             s->ctx->tlsext_servername_callback(s, &al,
2870                                                s->ctx->tlsext_servername_arg);
2871     else if (s->initial_ctx != NULL
2872              && s->initial_ctx->tlsext_servername_callback != 0)
2873         ret =
2874             s->initial_ctx->tlsext_servername_callback(s, &al,
2875                                                        s->
2876                                                        initial_ctx->tlsext_servername_arg);
2877
2878     /*
2879      * Ensure we get sensible values passed to tlsext_status_cb in the event
2880      * that we don't receive a status message
2881      */
2882     OPENSSL_free(s->tlsext_ocsp_resp);
2883     s->tlsext_ocsp_resp = NULL;
2884     s->tlsext_ocsp_resplen = 0;
2885
2886     switch (ret) {
2887     case SSL_TLSEXT_ERR_ALERT_FATAL:
2888         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2889         return -1;
2890
2891     case SSL_TLSEXT_ERR_ALERT_WARNING:
2892         ssl3_send_alert(s, SSL3_AL_WARNING, al);
2893         return 1;
2894
2895     case SSL_TLSEXT_ERR_NOACK:
2896         s->servername_done = 0;
2897     default:
2898         return 1;
2899     }
2900 }
2901
2902 int ssl_parse_serverhello_tlsext(SSL *s, PACKET *pkt)
2903 {
2904     int al = -1;
2905     if (s->version < SSL3_VERSION)
2906         return 1;
2907     if (ssl_scan_serverhello_tlsext(s, pkt, &al) <= 0) {
2908         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2909         return 0;
2910     }
2911
2912     if (ssl_check_serverhello_tlsext(s) <= 0) {
2913         SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_TLSEXT, SSL_R_SERVERHELLO_TLSEXT);
2914         return 0;
2915     }
2916     return 1;
2917 }
2918
2919 /*
2920  * Given a list of extensions that we collected earlier, find one of a given
2921  * type and return it.
2922  *
2923  * |exts| is the set of extensions previously collected.
2924  * |numexts| is the number of extensions that we have.
2925  * |type| the type of the extension that we are looking for.
2926  *
2927  * Returns a pointer to the found RAW_EXTENSION data, or NULL if not found.
2928  */
2929 RAW_EXTENSION *tls_get_extension_by_type(RAW_EXTENSION *exts, size_t numexts,
2930                                          unsigned int type)
2931 {
2932     size_t loop;
2933
2934     for (loop = 0; loop < numexts; loop++) {
2935         if (exts[loop].type == type)
2936             return &exts[loop];
2937     }
2938
2939     return NULL;
2940 }
2941
2942 /*-
2943  * Gets the ticket information supplied by the client if any.
2944  *
2945  *   hello: The parsed ClientHello data
2946  *   ret: (output) on return, if a ticket was decrypted, then this is set to
2947  *       point to the resulting session.
2948  *
2949  * If s->tls_session_secret_cb is set then we are expecting a pre-shared key
2950  * ciphersuite, in which case we have no use for session tickets and one will
2951  * never be decrypted, nor will s->tlsext_ticket_expected be set to 1.
2952  *
2953  * Returns:
2954  *   -1: fatal error, either from parsing or decrypting the ticket.
2955  *    0: no ticket was found (or was ignored, based on settings).
2956  *    1: a zero length extension was found, indicating that the client supports
2957  *       session tickets but doesn't currently have one to offer.
2958  *    2: either s->tls_session_secret_cb was set, or a ticket was offered but
2959  *       couldn't be decrypted because of a non-fatal error.
2960  *    3: a ticket was successfully decrypted and *ret was set.
2961  *
2962  * Side effects:
2963  *   Sets s->tlsext_ticket_expected to 1 if the server will have to issue
2964  *   a new session ticket to the client because the client indicated support
2965  *   (and s->tls_session_secret_cb is NULL) but the client either doesn't have
2966  *   a session ticket or we couldn't use the one it gave us, or if
2967  *   s->ctx->tlsext_ticket_key_cb asked to renew the client's ticket.
2968  *   Otherwise, s->tlsext_ticket_expected is set to 0.
2969  */
2970 int tls_get_ticket_from_client(SSL *s, CLIENTHELLO_MSG *hello,
2971                                SSL_SESSION **ret)
2972 {
2973     int retv;
2974     const unsigned char *etick;
2975     size_t size;
2976     RAW_EXTENSION *ticketext;
2977
2978     *ret = NULL;
2979     s->tlsext_ticket_expected = 0;
2980
2981     /*
2982      * If tickets disabled behave as if no ticket present to permit stateful
2983      * resumption.
2984      */
2985     if (s->version <= SSL3_VERSION || !tls_use_ticket(s))
2986         return 0;
2987
2988     ticketext = tls_get_extension_by_type(hello->pre_proc_exts,
2989                                           hello->num_extensions,
2990                                           TLSEXT_TYPE_session_ticket);
2991     if (ticketext == NULL)
2992         return 0;
2993
2994     size = PACKET_remaining(&ticketext->data);
2995     if (size == 0) {
2996         /*
2997          * The client will accept a ticket but doesn't currently have
2998          * one.
2999          */
3000         s->tlsext_ticket_expected = 1;
3001         return 1;
3002     }
3003     if (s->tls_session_secret_cb) {
3004         /*
3005          * Indicate that the ticket couldn't be decrypted rather than
3006          * generating the session from ticket now, trigger
3007          * abbreviated handshake based on external mechanism to
3008          * calculate the master secret later.
3009          */
3010         return 2;
3011     }
3012     if (!PACKET_get_bytes(&ticketext->data, &etick, size)) {
3013         /* Shouldn't ever happen */
3014         return -1;
3015     }
3016     retv = tls_decrypt_ticket(s, etick, size, hello->session_id,
3017                            hello->session_id_len, ret);
3018     switch (retv) {
3019     case 2:            /* ticket couldn't be decrypted */
3020         s->tlsext_ticket_expected = 1;
3021         return 2;
3022
3023     case 3:            /* ticket was decrypted */
3024         return 3;
3025
3026     case 4:            /* ticket decrypted but need to renew */
3027         s->tlsext_ticket_expected = 1;
3028         return 3;
3029
3030     default:           /* fatal error */
3031         return -1;
3032     }
3033 }
3034
3035 /*
3036  * Sets the extended master secret flag if the extension is present in the
3037  * ClientHello
3038  * Returns:
3039  *  1 on success
3040  *  0 on error
3041  */
3042 int tls_check_client_ems_support(SSL *s, const CLIENTHELLO_MSG *hello)
3043 {
3044     RAW_EXTENSION *emsext;
3045
3046     s->s3->flags &= ~TLS1_FLAGS_RECEIVED_EXTMS;
3047
3048     if (s->version <= SSL3_VERSION)
3049         return 1;
3050
3051     emsext = tls_get_extension_by_type(hello->pre_proc_exts,
3052                                        hello->num_extensions,
3053                                        TLSEXT_TYPE_extended_master_secret);
3054
3055     /*
3056      * No extensions is a success - we have successfully discovered that the
3057      * client doesn't support EMS.
3058      */
3059     if (emsext == NULL)
3060         return 1;
3061
3062     /* The extensions must always be empty */
3063     if (PACKET_remaining(&emsext->data) != 0)
3064         return 0;
3065
3066     s->s3->flags |= TLS1_FLAGS_RECEIVED_EXTMS;
3067
3068     return 1;
3069 }
3070
3071 /*-
3072  * tls_decrypt_ticket attempts to decrypt a session ticket.
3073  *
3074  *   etick: points to the body of the session ticket extension.
3075  *   eticklen: the length of the session tickets extension.
3076  *   sess_id: points at the session ID.
3077  *   sesslen: the length of the session ID.
3078  *   psess: (output) on return, if a ticket was decrypted, then this is set to
3079  *       point to the resulting session.
3080  *
3081  * Returns:
3082  *   -2: fatal error, malloc failure.
3083  *   -1: fatal error, either from parsing or decrypting the ticket.
3084  *    2: the ticket couldn't be decrypted.
3085  *    3: a ticket was successfully decrypted and *psess was set.
3086  *    4: same as 3, but the ticket needs to be renewed.
3087  */
3088 static int tls_decrypt_ticket(SSL *s, const unsigned char *etick,
3089                               size_t eticklen, const unsigned char *sess_id,
3090                               size_t sesslen, SSL_SESSION **psess)
3091 {
3092     SSL_SESSION *sess;
3093     unsigned char *sdec;
3094     const unsigned char *p;
3095     int slen, renew_ticket = 0, ret = -1, declen;
3096     size_t mlen;
3097     unsigned char tick_hmac[EVP_MAX_MD_SIZE];
3098     HMAC_CTX *hctx = NULL;
3099     EVP_CIPHER_CTX *ctx;
3100     SSL_CTX *tctx = s->initial_ctx;
3101
3102     /* Initialize session ticket encryption and HMAC contexts */
3103     hctx = HMAC_CTX_new();
3104     if (hctx == NULL)
3105         return -2;
3106     ctx = EVP_CIPHER_CTX_new();
3107     if (ctx == NULL) {
3108         ret = -2;
3109         goto err;
3110     }
3111     if (tctx->tlsext_ticket_key_cb) {
3112         unsigned char *nctick = (unsigned char *)etick;
3113         int rv = tctx->tlsext_ticket_key_cb(s, nctick, nctick + 16,
3114                                             ctx, hctx, 0);
3115         if (rv < 0)
3116             goto err;
3117         if (rv == 0) {
3118             ret = 2;
3119             goto err;
3120         }
3121         if (rv == 2)
3122             renew_ticket = 1;
3123     } else {
3124         /* Check key name matches */
3125         if (memcmp(etick, tctx->tlsext_tick_key_name,
3126                    sizeof(tctx->tlsext_tick_key_name)) != 0) {
3127             ret = 2;
3128             goto err;
3129         }
3130         if (HMAC_Init_ex(hctx, tctx->tlsext_tick_hmac_key,
3131                          sizeof(tctx->tlsext_tick_hmac_key),
3132                          EVP_sha256(), NULL) <= 0
3133             || EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL,
3134                                   tctx->tlsext_tick_aes_key,
3135                                   etick + sizeof(tctx->tlsext_tick_key_name)) <=
3136             0) {
3137             goto err;
3138         }
3139     }
3140     /*
3141      * Attempt to process session ticket, first conduct sanity and integrity
3142      * checks on ticket.
3143      */
3144     mlen = HMAC_size(hctx);
3145     if (mlen == 0) {
3146         goto err;
3147     }
3148     /* Sanity check ticket length: must exceed keyname + IV + HMAC */
3149     if (eticklen <=
3150         TLSEXT_KEYNAME_LENGTH + EVP_CIPHER_CTX_iv_length(ctx) + mlen) {
3151         ret = 2;
3152         goto err;
3153     }
3154     eticklen -= mlen;
3155     /* Check HMAC of encrypted ticket */
3156     if (HMAC_Update(hctx, etick, eticklen) <= 0
3157         || HMAC_Final(hctx, tick_hmac, NULL) <= 0) {
3158         goto err;
3159     }
3160     HMAC_CTX_free(hctx);
3161     if (CRYPTO_memcmp(tick_hmac, etick + eticklen, mlen)) {
3162         EVP_CIPHER_CTX_free(ctx);
3163         return 2;
3164     }
3165     /* Attempt to decrypt session data */
3166     /* Move p after IV to start of encrypted ticket, update length */
3167     p = etick + 16 + EVP_CIPHER_CTX_iv_length(ctx);
3168     eticklen -= 16 + EVP_CIPHER_CTX_iv_length(ctx);
3169     sdec = OPENSSL_malloc(eticklen);
3170     if (sdec == NULL || EVP_DecryptUpdate(ctx, sdec, &slen, p,
3171                                           (int)eticklen) <= 0) {
3172         EVP_CIPHER_CTX_free(ctx);
3173         OPENSSL_free(sdec);
3174         return -1;
3175     }
3176     if (EVP_DecryptFinal(ctx, sdec + slen, &declen) <= 0) {
3177         EVP_CIPHER_CTX_free(ctx);
3178         OPENSSL_free(sdec);
3179         return 2;
3180     }
3181     slen += declen;
3182     EVP_CIPHER_CTX_free(ctx);
3183     ctx = NULL;
3184     p = sdec;
3185
3186     sess = d2i_SSL_SESSION(NULL, &p, slen);
3187     OPENSSL_free(sdec);
3188     if (sess) {
3189         /*
3190          * The session ID, if non-empty, is used by some clients to detect
3191          * that the ticket has been accepted. So we copy it to the session
3192          * structure. If it is empty set length to zero as required by
3193          * standard.
3194          */
3195         if (sesslen)
3196             memcpy(sess->session_id, sess_id, sesslen);
3197         sess->session_id_length = sesslen;
3198         *psess = sess;
3199         if (renew_ticket)
3200             return 4;
3201         else
3202             return 3;
3203     }
3204     ERR_clear_error();
3205     /*
3206      * For session parse failure, indicate that we need to send a new ticket.
3207      */
3208     return 2;
3209  err:
3210     EVP_CIPHER_CTX_free(ctx);
3211     HMAC_CTX_free(hctx);
3212     return ret;
3213 }
3214
3215 /* Tables to translate from NIDs to TLS v1.2 ids */
3216
3217 typedef struct {
3218     int nid;
3219     int id;
3220 } tls12_lookup;
3221
3222 static const tls12_lookup tls12_md[] = {
3223     {NID_md5, TLSEXT_hash_md5},
3224     {NID_sha1, TLSEXT_hash_sha1},
3225     {NID_sha224, TLSEXT_hash_sha224},
3226     {NID_sha256, TLSEXT_hash_sha256},
3227     {NID_sha384, TLSEXT_hash_sha384},
3228     {NID_sha512, TLSEXT_hash_sha512},
3229     {NID_id_GostR3411_94, TLSEXT_hash_gostr3411},
3230     {NID_id_GostR3411_2012_256, TLSEXT_hash_gostr34112012_256},
3231     {NID_id_GostR3411_2012_512, TLSEXT_hash_gostr34112012_512},
3232 };
3233
3234 static const tls12_lookup tls12_sig[] = {
3235     {EVP_PKEY_RSA, TLSEXT_signature_rsa},
3236     {EVP_PKEY_DSA, TLSEXT_signature_dsa},
3237     {EVP_PKEY_EC, TLSEXT_signature_ecdsa},
3238     {NID_id_GostR3410_2001, TLSEXT_signature_gostr34102001},
3239     {NID_id_GostR3410_2012_256, TLSEXT_signature_gostr34102012_256},
3240     {NID_id_GostR3410_2012_512, TLSEXT_signature_gostr34102012_512}
3241 };
3242
3243 static int tls12_find_id(int nid, const tls12_lookup *table, size_t tlen)
3244 {
3245     size_t i;
3246     for (i = 0; i < tlen; i++) {
3247         if (table[i].nid == nid)
3248             return table[i].id;
3249     }
3250     return -1;
3251 }
3252
3253 static int tls12_find_nid(int id, const tls12_lookup *table, size_t tlen)
3254 {
3255     size_t i;
3256     for (i = 0; i < tlen; i++) {
3257         if ((table[i].id) == id)
3258             return table[i].nid;
3259     }
3260     return NID_undef;
3261 }
3262
3263 int tls12_get_sigandhash(WPACKET *pkt, const EVP_PKEY *pk, const EVP_MD *md)
3264 {
3265     int sig_id, md_id;
3266
3267     if (md == NULL)
3268         return 0;
3269     md_id = tls12_find_id(EVP_MD_type(md), tls12_md, OSSL_NELEM(tls12_md));
3270     if (md_id == -1)
3271         return 0;
3272     sig_id = tls12_get_sigid(pk);
3273     if (sig_id == -1)
3274         return 0;
3275     if (!WPACKET_put_bytes_u8(pkt, md_id) || !WPACKET_put_bytes_u8(pkt, sig_id))
3276         return 0;
3277
3278     return 1;
3279 }
3280
3281 int tls12_get_sigid(const EVP_PKEY *pk)
3282 {
3283     return tls12_find_id(EVP_PKEY_id(pk), tls12_sig, OSSL_NELEM(tls12_sig));
3284 }
3285
3286 typedef struct {
3287     int nid;
3288     int secbits;
3289     int md_idx;
3290     unsigned char tlsext_hash;
3291 } tls12_hash_info;
3292
3293 static const tls12_hash_info tls12_md_info[] = {
3294     {NID_md5, 64, SSL_MD_MD5_IDX, TLSEXT_hash_md5},
3295     {NID_sha1, 80, SSL_MD_SHA1_IDX, TLSEXT_hash_sha1},
3296     {NID_sha224, 112, SSL_MD_SHA224_IDX, TLSEXT_hash_sha224},
3297     {NID_sha256, 128, SSL_MD_SHA256_IDX, TLSEXT_hash_sha256},
3298     {NID_sha384, 192, SSL_MD_SHA384_IDX, TLSEXT_hash_sha384},
3299     {NID_sha512, 256, SSL_MD_SHA512_IDX, TLSEXT_hash_sha512},
3300     {NID_id_GostR3411_94, 128, SSL_MD_GOST94_IDX, TLSEXT_hash_gostr3411},
3301     {NID_id_GostR3411_2012_256, 128, SSL_MD_GOST12_256_IDX,
3302      TLSEXT_hash_gostr34112012_256},
3303     {NID_id_GostR3411_2012_512, 256, SSL_MD_GOST12_512_IDX,
3304      TLSEXT_hash_gostr34112012_512},
3305 };
3306
3307 static const tls12_hash_info *tls12_get_hash_info(unsigned char hash_alg)
3308 {
3309     unsigned int i;
3310     if (hash_alg == 0)
3311         return NULL;
3312
3313     for (i = 0; i < OSSL_NELEM(tls12_md_info); i++) {
3314         if (tls12_md_info[i].tlsext_hash == hash_alg)
3315             return tls12_md_info + i;
3316     }
3317
3318     return NULL;
3319 }
3320
3321 const EVP_MD *tls12_get_hash(unsigned char hash_alg)
3322 {
3323     const tls12_hash_info *inf;
3324     if (hash_alg == TLSEXT_hash_md5 && FIPS_mode())
3325         return NULL;
3326     inf = tls12_get_hash_info(hash_alg);
3327     if (!inf)
3328         return NULL;
3329     return ssl_md(inf->md_idx);
3330 }
3331
3332 static int tls12_get_pkey_idx(unsigned char sig_alg)
3333 {
3334     switch (sig_alg) {
3335 #ifndef OPENSSL_NO_RSA
3336     case TLSEXT_signature_rsa:
3337         return SSL_PKEY_RSA_SIGN;
3338 #endif
3339 #ifndef OPENSSL_NO_DSA
3340     case TLSEXT_signature_dsa:
3341         return SSL_PKEY_DSA_SIGN;
3342 #endif
3343 #ifndef OPENSSL_NO_EC
3344     case TLSEXT_signature_ecdsa:
3345         return SSL_PKEY_ECC;
3346 #endif
3347 #ifndef OPENSSL_NO_GOST
3348     case TLSEXT_signature_gostr34102001:
3349         return SSL_PKEY_GOST01;
3350
3351     case TLSEXT_signature_gostr34102012_256:
3352         return SSL_PKEY_GOST12_256;
3353
3354     case TLSEXT_signature_gostr34102012_512:
3355         return SSL_PKEY_GOST12_512;
3356 #endif
3357     }
3358     return -1;
3359 }
3360
3361 /* Convert TLS 1.2 signature algorithm extension values into NIDs */
3362 static void tls1_lookup_sigalg(int *phash_nid, int *psign_nid,
3363                                int *psignhash_nid, const unsigned char *data)
3364 {
3365     int sign_nid = NID_undef, hash_nid = NID_undef;
3366     if (!phash_nid && !psign_nid && !psignhash_nid)
3367         return;
3368     if (phash_nid || psignhash_nid) {
3369         hash_nid = tls12_find_nid(data[0], tls12_md, OSSL_NELEM(tls12_md));
3370         if (phash_nid)
3371             *phash_nid = hash_nid;
3372     }
3373     if (psign_nid || psignhash_nid) {
3374         sign_nid = tls12_find_nid(data[1], tls12_sig, OSSL_NELEM(tls12_sig));
3375         if (psign_nid)
3376             *psign_nid = sign_nid;
3377     }
3378     if (psignhash_nid) {
3379         if (sign_nid == NID_undef || hash_nid == NID_undef
3380             || OBJ_find_sigid_by_algs(psignhash_nid, hash_nid, sign_nid) <= 0)
3381             *psignhash_nid = NID_undef;
3382     }
3383 }
3384
3385 /* Check to see if a signature algorithm is allowed */
3386 static int tls12_sigalg_allowed(SSL *s, int op, const unsigned char *ptmp)
3387 {
3388     /* See if we have an entry in the hash table and it is enabled */
3389     const tls12_hash_info *hinf = tls12_get_hash_info(ptmp[0]);
3390     if (hinf == NULL || ssl_md(hinf->md_idx) == NULL)
3391         return 0;
3392     /* See if public key algorithm allowed */
3393     if (tls12_get_pkey_idx(ptmp[1]) == -1)
3394         return 0;
3395     /* Finally see if security callback allows it */
3396     return ssl_security(s, op, hinf->secbits, hinf->nid, (void *)ptmp);
3397 }
3398
3399 /*
3400  * Get a mask of disabled public key algorithms based on supported signature
3401  * algorithms. For example if no signature algorithm supports RSA then RSA is
3402  * disabled.
3403  */
3404
3405 void ssl_set_sig_mask(uint32_t *pmask_a, SSL *s, int op)
3406 {
3407     const unsigned char *sigalgs;
3408     size_t i, sigalgslen;
3409     int have_rsa = 0, have_dsa = 0, have_ecdsa = 0;
3410     /*
3411      * Now go through all signature algorithms seeing if we support any for
3412      * RSA, DSA, ECDSA. Do this for all versions not just TLS 1.2. To keep
3413      * down calls to security callback only check if we have to.
3414      */
3415     sigalgslen = tls12_get_psigalgs(s, &sigalgs);
3416     for (i = 0; i < sigalgslen; i += 2, sigalgs += 2) {
3417         switch (sigalgs[1]) {
3418 #ifndef OPENSSL_NO_RSA
3419         case TLSEXT_signature_rsa:
3420             if (!have_rsa && tls12_sigalg_allowed(s, op, sigalgs))
3421                 have_rsa = 1;
3422             break;
3423 #endif
3424 #ifndef OPENSSL_NO_DSA
3425         case TLSEXT_signature_dsa:
3426             if (!have_dsa && tls12_sigalg_allowed(s, op, sigalgs))
3427                 have_dsa = 1;
3428             break;
3429 #endif
3430 #ifndef OPENSSL_NO_EC
3431         case TLSEXT_signature_ecdsa:
3432             if (!have_ecdsa && tls12_sigalg_allowed(s, op, sigalgs))
3433                 have_ecdsa = 1;
3434             break;
3435 #endif
3436         }
3437     }
3438     if (!have_rsa)
3439         *pmask_a |= SSL_aRSA;
3440     if (!have_dsa)
3441         *pmask_a |= SSL_aDSS;
3442     if (!have_ecdsa)
3443         *pmask_a |= SSL_aECDSA;
3444 }
3445
3446 int tls12_copy_sigalgs(SSL *s, WPACKET *pkt,
3447                        const unsigned char *psig, size_t psiglen)
3448 {
3449     size_t i;
3450
3451     for (i = 0; i < psiglen; i += 2, psig += 2) {
3452         if (tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SUPPORTED, psig)) {
3453             if (!WPACKET_put_bytes_u8(pkt, psig[0])
3454                     || !WPACKET_put_bytes_u8(pkt, psig[1]))
3455                 return 0;
3456         }
3457     }
3458     return 1;
3459 }
3460
3461 /* Given preference and allowed sigalgs set shared sigalgs */
3462 static size_t tls12_shared_sigalgs(SSL *s, TLS_SIGALGS *shsig,
3463                                    const unsigned char *pref, size_t preflen,
3464                                    const unsigned char *allow, size_t allowlen)
3465 {
3466     const unsigned char *ptmp, *atmp;
3467     size_t i, j, nmatch = 0;
3468     for (i = 0, ptmp = pref; i < preflen; i += 2, ptmp += 2) {
3469         /* Skip disabled hashes or signature algorithms */
3470         if (!tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SHARED, ptmp))
3471             continue;
3472         for (j = 0, atmp = allow; j < allowlen; j += 2, atmp += 2) {
3473             if (ptmp[0] == atmp[0] && ptmp[1] == atmp[1]) {
3474                 nmatch++;
3475                 if (shsig) {
3476                     shsig->rhash = ptmp[0];
3477                     shsig->rsign = ptmp[1];
3478                     tls1_lookup_sigalg(&shsig->hash_nid,
3479                                        &shsig->sign_nid,
3480                                        &shsig->signandhash_nid, ptmp);
3481                     shsig++;
3482                 }
3483                 break;
3484             }
3485         }
3486     }
3487     return nmatch;
3488 }
3489
3490 /* Set shared signature algorithms for SSL structures */
3491 static int tls1_set_shared_sigalgs(SSL *s)
3492 {
3493     const unsigned char *pref, *allow, *conf;
3494     size_t preflen, allowlen, conflen;
3495     size_t nmatch;
3496     TLS_SIGALGS *salgs = NULL;
3497     CERT *c = s->cert;
3498     unsigned int is_suiteb = tls1_suiteb(s);
3499
3500     OPENSSL_free(c->shared_sigalgs);
3501     c->shared_sigalgs = NULL;
3502     c->shared_sigalgslen = 0;
3503     /* If client use client signature algorithms if not NULL */
3504     if (!s->server && c->client_sigalgs && !is_suiteb) {
3505         conf = c->client_sigalgs;
3506         conflen = c->client_sigalgslen;
3507     } else if (c->conf_sigalgs && !is_suiteb) {
3508         conf = c->conf_sigalgs;
3509         conflen = c->conf_sigalgslen;
3510     } else
3511         conflen = tls12_get_psigalgs(s, &conf);
3512     if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE || is_suiteb) {
3513         pref = conf;
3514         preflen = conflen;
3515         allow = s->s3->tmp.peer_sigalgs;
3516         allowlen = s->s3->tmp.peer_sigalgslen;
3517     } else {
3518         allow = conf;
3519         allowlen = conflen;
3520         pref = s->s3->tmp.peer_sigalgs;
3521         preflen = s->s3->tmp.peer_sigalgslen;
3522     }
3523     nmatch = tls12_shared_sigalgs(s, NULL, pref, preflen, allow, allowlen);
3524     if (nmatch) {
3525         salgs = OPENSSL_malloc(nmatch * sizeof(TLS_SIGALGS));
3526         if (salgs == NULL)
3527             return 0;
3528         nmatch = tls12_shared_sigalgs(s, salgs, pref, preflen, allow, allowlen);
3529     } else {
3530         salgs = NULL;
3531     }
3532     c->shared_sigalgs = salgs;
3533     c->shared_sigalgslen = nmatch;
3534     return 1;
3535 }
3536
3537 /* Set preferred digest for each key type */
3538
3539 int tls1_save_sigalgs(SSL *s, const unsigned char *data, size_t dsize)
3540 {
3541     CERT *c = s->cert;
3542     /* Extension ignored for inappropriate versions */
3543     if (!SSL_USE_SIGALGS(s))
3544         return 1;
3545     /* Should never happen */
3546     if (!c)
3547         return 0;
3548
3549     OPENSSL_free(s->s3->tmp.peer_sigalgs);
3550     s->s3->tmp.peer_sigalgs = OPENSSL_malloc(dsize);
3551     if (s->s3->tmp.peer_sigalgs == NULL)
3552         return 0;
3553     s->s3->tmp.peer_sigalgslen = dsize;
3554     memcpy(s->s3->tmp.peer_sigalgs, data, dsize);
3555     return 1;
3556 }
3557
3558 int tls1_process_sigalgs(SSL *s)
3559 {
3560     int idx;
3561     size_t i;
3562     const EVP_MD *md;
3563     const EVP_MD **pmd = s->s3->tmp.md;
3564     uint32_t *pvalid = s->s3->tmp.valid_flags;
3565     CERT *c = s->cert;
3566     TLS_SIGALGS *sigptr;
3567     if (!tls1_set_shared_sigalgs(s))
3568         return 0;
3569
3570     for (i = 0, sigptr = c->shared_sigalgs;
3571          i < c->shared_sigalgslen; i++, sigptr++) {
3572         idx = tls12_get_pkey_idx(sigptr->rsign);
3573         if (idx > 0 && pmd[idx] == NULL) {
3574             md = tls12_get_hash(sigptr->rhash);
3575             pmd[idx] = md;
3576             pvalid[idx] = CERT_PKEY_EXPLICIT_SIGN;
3577             if (idx == SSL_PKEY_RSA_SIGN) {
3578                 pvalid[SSL_PKEY_RSA_ENC] = CERT_PKEY_EXPLICIT_SIGN;
3579                 pmd[SSL_PKEY_RSA_ENC] = md;
3580             }
3581         }
3582
3583     }
3584     /*
3585      * In strict mode leave unset digests as NULL to indicate we can't use
3586      * the certificate for signing.
3587      */
3588     if (!(s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)) {
3589         /*
3590          * Set any remaining keys to default values. NOTE: if alg is not
3591          * supported it stays as NULL.
3592          */
3593 #ifndef OPENSSL_NO_DSA
3594         if (pmd[SSL_PKEY_DSA_SIGN] == NULL)
3595             pmd[SSL_PKEY_DSA_SIGN] = EVP_sha1();
3596 #endif
3597 #ifndef OPENSSL_NO_RSA
3598         if (pmd[SSL_PKEY_RSA_SIGN] == NULL) {
3599             pmd[SSL_PKEY_RSA_SIGN] = EVP_sha1();
3600             pmd[SSL_PKEY_RSA_ENC] = EVP_sha1();
3601         }
3602 #endif
3603 #ifndef OPENSSL_NO_EC
3604         if (pmd[SSL_PKEY_ECC] == NULL)
3605             pmd[SSL_PKEY_ECC] = EVP_sha1();
3606 #endif
3607 #ifndef OPENSSL_NO_GOST
3608         if (pmd[SSL_PKEY_GOST01] == NULL)
3609             pmd[SSL_PKEY_GOST01] = EVP_get_digestbynid(NID_id_GostR3411_94);
3610         if (pmd[SSL_PKEY_GOST12_256] == NULL)
3611             pmd[SSL_PKEY_GOST12_256] =
3612                 EVP_get_digestbynid(NID_id_GostR3411_2012_256);
3613         if (pmd[SSL_PKEY_GOST12_512] == NULL)
3614             pmd[SSL_PKEY_GOST12_512] =
3615                 EVP_get_digestbynid(NID_id_GostR3411_2012_512);
3616 #endif
3617     }
3618     return 1;
3619 }
3620
3621 int SSL_get_sigalgs(SSL *s, int idx,
3622                     int *psign, int *phash, int *psignhash,
3623                     unsigned char *rsig, unsigned char *rhash)
3624 {
3625     const unsigned char *psig = s->s3->tmp.peer_sigalgs;
3626     size_t numsigalgs = s->s3->tmp.peer_sigalgslen / 2;
3627     if (psig == NULL || numsigalgs > INT_MAX)
3628         return 0;
3629     if (idx >= 0) {
3630         idx <<= 1;
3631         if (idx >= (int)s->s3->tmp.peer_sigalgslen)
3632             return 0;
3633         psig += idx;
3634         if (rhash)
3635             *rhash = psig[0];
3636         if (rsig)
3637             *rsig = psig[1];
3638         tls1_lookup_sigalg(phash, psign, psignhash, psig);
3639     }
3640     return (int)numsigalgs;
3641 }
3642
3643 int SSL_get_shared_sigalgs(SSL *s, int idx,
3644                            int *psign, int *phash, int *psignhash,
3645                            unsigned char *rsig, unsigned char *rhash)
3646 {
3647     TLS_SIGALGS *shsigalgs = s->cert->shared_sigalgs;
3648     if (!shsigalgs || idx >= (int)s->cert->shared_sigalgslen
3649             || s->cert->shared_sigalgslen > INT_MAX)
3650         return 0;
3651     shsigalgs += idx;
3652     if (phash)
3653         *phash = shsigalgs->hash_nid;
3654     if (psign)
3655         *psign = shsigalgs->sign_nid;
3656     if (psignhash)
3657         *psignhash = shsigalgs->signandhash_nid;
3658     if (rsig)
3659         *rsig = shsigalgs->rsign;
3660     if (rhash)
3661         *rhash = shsigalgs->rhash;
3662     return (int)s->cert->shared_sigalgslen;
3663 }
3664
3665 #define MAX_SIGALGLEN   (TLSEXT_hash_num * TLSEXT_signature_num * 2)
3666
3667 typedef struct {
3668     size_t sigalgcnt;
3669     int sigalgs[MAX_SIGALGLEN];
3670 } sig_cb_st;
3671
3672 static void get_sigorhash(int *psig, int *phash, const char *str)
3673 {
3674     if (strcmp(str, "RSA") == 0) {
3675         *psig = EVP_PKEY_RSA;
3676     } else if (strcmp(str, "DSA") == 0) {
3677         *psig = EVP_PKEY_DSA;
3678     } else if (strcmp(str, "ECDSA") == 0) {
3679         *psig = EVP_PKEY_EC;
3680     } else {
3681         *phash = OBJ_sn2nid(str);
3682         if (*phash == NID_undef)
3683             *phash = OBJ_ln2nid(str);
3684     }
3685 }
3686
3687 static int sig_cb(const char *elem, int len, void *arg)
3688 {
3689     sig_cb_st *sarg = arg;
3690     size_t i;
3691     char etmp[20], *p;
3692     int sig_alg = NID_undef, hash_alg = NID_undef;
3693     if (elem == NULL)
3694         return 0;
3695     if (sarg->sigalgcnt == MAX_SIGALGLEN)
3696         return 0;
3697     if (len > (int)(sizeof(etmp) - 1))
3698         return 0;
3699     memcpy(etmp, elem, len);
3700     etmp[len] = 0;
3701     p = strchr(etmp, '+');
3702     if (!p)
3703         return 0;
3704     *p = 0;
3705     p++;
3706     if (!*p)
3707         return 0;
3708
3709     get_sigorhash(&sig_alg, &hash_alg, etmp);
3710     get_sigorhash(&sig_alg, &hash_alg, p);
3711
3712     if (sig_alg == NID_undef || hash_alg == NID_undef)
3713         return 0;
3714
3715     for (i = 0; i < sarg->sigalgcnt; i += 2) {
3716         if (sarg->sigalgs[i] == sig_alg && sarg->sigalgs[i + 1] == hash_alg)
3717             return 0;
3718     }
3719     sarg->sigalgs[sarg->sigalgcnt++] = hash_alg;
3720     sarg->sigalgs[sarg->sigalgcnt++] = sig_alg;
3721     return 1;
3722 }
3723
3724 /*
3725  * Set supported signature algorithms based on a colon separated list of the
3726  * form sig+hash e.g. RSA+SHA512:DSA+SHA512
3727  */
3728 int tls1_set_sigalgs_list(CERT *c, const char *str, int client)
3729 {
3730     sig_cb_st sig;
3731     sig.sigalgcnt = 0;
3732     if (!CONF_parse_list(str, ':', 1, sig_cb, &sig))
3733         return 0;
3734     if (c == NULL)
3735         return 1;
3736     return tls1_set_sigalgs(c, sig.sigalgs, sig.sigalgcnt, client);
3737 }
3738
3739 int tls1_set_sigalgs(CERT *c, const int *psig_nids, size_t salglen, int client)
3740 {
3741     unsigned char *sigalgs, *sptr;
3742     int rhash, rsign;
3743     size_t i;
3744     if (salglen & 1)
3745         return 0;
3746     sigalgs = OPENSSL_malloc(salglen);
3747     if (sigalgs == NULL)
3748         return 0;
3749     for (i = 0, sptr = sigalgs; i < salglen; i += 2) {
3750         rhash = tls12_find_id(*psig_nids++, tls12_md, OSSL_NELEM(tls12_md));
3751         rsign = tls12_find_id(*psig_nids++, tls12_sig, OSSL_NELEM(tls12_sig));
3752
3753         if (rhash == -1 || rsign == -1)
3754             goto err;
3755         *sptr++ = rhash;
3756         *sptr++ = rsign;
3757     }
3758
3759     if (client) {
3760         OPENSSL_free(c->client_sigalgs);
3761         c->client_sigalgs = sigalgs;
3762         c->client_sigalgslen = salglen;
3763     } else {
3764         OPENSSL_free(c->conf_sigalgs);
3765         c->conf_sigalgs = sigalgs;
3766         c->conf_sigalgslen = salglen;
3767     }
3768
3769     return 1;
3770
3771  err:
3772     OPENSSL_free(sigalgs);
3773     return 0;
3774 }
3775
3776 static int tls1_check_sig_alg(CERT *c, X509 *x, int default_nid)
3777 {
3778     int sig_nid;
3779     size_t i;
3780     if (default_nid == -1)
3781         return 1;
3782     sig_nid = X509_get_signature_nid(x);
3783     if (default_nid)
3784         return sig_nid == default_nid ? 1 : 0;
3785     for (i = 0; i < c->shared_sigalgslen; i++)
3786         if (sig_nid == c->shared_sigalgs[i].signandhash_nid)
3787             return 1;
3788     return 0;
3789 }
3790
3791 /* Check to see if a certificate issuer name matches list of CA names */
3792 static int ssl_check_ca_name(STACK_OF(X509_NAME) *names, X509 *x)
3793 {
3794     X509_NAME *nm;
3795     int i;
3796     nm = X509_get_issuer_name(x);
3797     for (i = 0; i < sk_X509_NAME_num(names); i++) {
3798         if (!X509_NAME_cmp(nm, sk_X509_NAME_value(names, i)))
3799             return 1;
3800     }
3801     return 0;
3802 }
3803
3804 /*
3805  * Check certificate chain is consistent with TLS extensions and is usable by
3806  * server. This servers two purposes: it allows users to check chains before
3807  * passing them to the server and it allows the server to check chains before
3808  * attempting to use them.
3809  */
3810
3811 /* Flags which need to be set for a certificate when stict mode not set */
3812
3813 #define CERT_PKEY_VALID_FLAGS \
3814         (CERT_PKEY_EE_SIGNATURE|CERT_PKEY_EE_PARAM)
3815 /* Strict mode flags */
3816 #define CERT_PKEY_STRICT_FLAGS \
3817          (CERT_PKEY_VALID_FLAGS|CERT_PKEY_CA_SIGNATURE|CERT_PKEY_CA_PARAM \
3818          | CERT_PKEY_ISSUER_NAME|CERT_PKEY_CERT_TYPE)
3819
3820 int tls1_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain,
3821                      int idx)
3822 {
3823     int i;
3824     int rv = 0;
3825     int check_flags = 0, strict_mode;
3826     CERT_PKEY *cpk = NULL;
3827     CERT *c = s->cert;
3828     uint32_t *pvalid;
3829     unsigned int suiteb_flags = tls1_suiteb(s);
3830     /* idx == -1 means checking server chains */
3831     if (idx != -1) {
3832         /* idx == -2 means checking client certificate chains */
3833         if (idx == -2) {
3834             cpk = c->key;
3835             idx = (int)(cpk - c->pkeys);
3836         } else
3837             cpk = c->pkeys + idx;
3838         pvalid = s->s3->tmp.valid_flags + idx;
3839         x = cpk->x509;
3840         pk = cpk->privatekey;
3841         chain = cpk->chain;
3842         strict_mode = c->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT;
3843         /* If no cert or key, forget it */
3844         if (!x || !pk)
3845             goto end;
3846     } else {
3847         if (!x || !pk)
3848             return 0;
3849         idx = ssl_cert_type(x, pk);
3850         if (idx == -1)
3851             return 0;
3852         pvalid = s->s3->tmp.valid_flags + idx;
3853
3854         if (c->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)
3855             check_flags = CERT_PKEY_STRICT_FLAGS;
3856         else
3857             check_flags = CERT_PKEY_VALID_FLAGS;
3858         strict_mode = 1;
3859     }
3860
3861     if (suiteb_flags) {
3862         int ok;
3863         if (check_flags)
3864             check_flags |= CERT_PKEY_SUITEB;
3865         ok = X509_chain_check_suiteb(NULL, x, chain, suiteb_flags);
3866         if (ok == X509_V_OK)
3867             rv |= CERT_PKEY_SUITEB;
3868         else if (!check_flags)
3869             goto end;
3870     }
3871
3872     /*
3873      * Check all signature algorithms are consistent with signature
3874      * algorithms extension if TLS 1.2 or later and strict mode.
3875      */
3876     if (TLS1_get_version(s) >= TLS1_2_VERSION && strict_mode) {
3877         int default_nid;
3878         unsigned char rsign = 0;
3879         if (s->s3->tmp.peer_sigalgs)
3880             default_nid = 0;
3881         /* If no sigalgs extension use defaults from RFC5246 */
3882         else {
3883             switch (idx) {
3884             case SSL_PKEY_RSA_ENC:
3885             case SSL_PKEY_RSA_SIGN:
3886                 rsign = TLSEXT_signature_rsa;
3887                 default_nid = NID_sha1WithRSAEncryption;
3888                 break;
3889
3890             case SSL_PKEY_DSA_SIGN:
3891                 rsign = TLSEXT_signature_dsa;
3892                 default_nid = NID_dsaWithSHA1;
3893                 break;
3894
3895             case SSL_PKEY_ECC:
3896                 rsign = TLSEXT_signature_ecdsa;
3897                 default_nid = NID_ecdsa_with_SHA1;
3898                 break;
3899
3900             case SSL_PKEY_GOST01:
3901                 rsign = TLSEXT_signature_gostr34102001;
3902                 default_nid = NID_id_GostR3411_94_with_GostR3410_2001;
3903                 break;
3904
3905             case SSL_PKEY_GOST12_256:
3906                 rsign = TLSEXT_signature_gostr34102012_256;
3907                 default_nid = NID_id_tc26_signwithdigest_gost3410_2012_256;
3908                 break;
3909
3910             case SSL_PKEY_GOST12_512:
3911                 rsign = TLSEXT_signature_gostr34102012_512;
3912                 default_nid = NID_id_tc26_signwithdigest_gost3410_2012_512;
3913                 break;
3914
3915             default:
3916                 default_nid = -1;
3917                 break;
3918             }
3919         }
3920         /*
3921          * If peer sent no signature algorithms extension and we have set
3922          * preferred signature algorithms check we support sha1.
3923          */
3924         if (default_nid > 0 && c->conf_sigalgs) {
3925             size_t j;
3926             const unsigned char *p = c->conf_sigalgs;
3927             for (j = 0; j < c->conf_sigalgslen; j += 2, p += 2) {
3928                 if (p[0] == TLSEXT_hash_sha1 && p[1] == rsign)
3929                     break;
3930             }
3931             if (j == c->conf_sigalgslen) {
3932                 if (check_flags)
3933                     goto skip_sigs;
3934                 else
3935                     goto end;
3936             }
3937         }
3938         /* Check signature algorithm of each cert in chain */
3939         if (!tls1_check_sig_alg(c, x, default_nid)) {
3940             if (!check_flags)
3941                 goto end;
3942         } else
3943             rv |= CERT_PKEY_EE_SIGNATURE;
3944         rv |= CERT_PKEY_CA_SIGNATURE;
3945         for (i = 0; i < sk_X509_num(chain); i++) {
3946             if (!tls1_check_sig_alg(c, sk_X509_value(chain, i), default_nid)) {
3947                 if (check_flags) {
3948                     rv &= ~CERT_PKEY_CA_SIGNATURE;
3949                     break;
3950                 } else
3951                     goto end;
3952             }
3953         }
3954     }
3955     /* Else not TLS 1.2, so mark EE and CA signing algorithms OK */
3956     else if (check_flags)
3957         rv |= CERT_PKEY_EE_SIGNATURE | CERT_PKEY_CA_SIGNATURE;
3958  skip_sigs:
3959     /* Check cert parameters are consistent */
3960     if (tls1_check_cert_param(s, x, check_flags ? 1 : 2))
3961         rv |= CERT_PKEY_EE_PARAM;
3962     else if (!check_flags)
3963         goto end;
3964     if (!s->server)
3965         rv |= CERT_PKEY_CA_PARAM;
3966     /* In strict mode check rest of chain too */
3967     else if (strict_mode) {
3968         rv |= CERT_PKEY_CA_PARAM;
3969         for (i = 0; i < sk_X509_num(chain); i++) {
3970             X509 *ca = sk_X509_value(chain, i);
3971             if (!tls1_check_cert_param(s, ca, 0)) {
3972                 if (check_flags) {
3973                     rv &= ~CERT_PKEY_CA_PARAM;
3974                     break;
3975                 } else
3976                     goto end;
3977             }
3978         }
3979     }
3980     if (!s->server && strict_mode) {
3981         STACK_OF(X509_NAME) *ca_dn;
3982         int check_type = 0;
3983         switch (EVP_PKEY_id(pk)) {
3984         case EVP_PKEY_RSA:
3985             check_type = TLS_CT_RSA_SIGN;
3986             break;
3987         case EVP_PKEY_DSA:
3988             check_type = TLS_CT_DSS_SIGN;
3989             break;
3990         case EVP_PKEY_EC:
3991             check_type = TLS_CT_ECDSA_SIGN;
3992             break;
3993         }
3994         if (check_type) {
3995             const unsigned char *ctypes;
3996             int ctypelen;
3997             if (c->ctypes) {
3998                 ctypes = c->ctypes;
3999                 ctypelen = (int)c->ctype_num;
4000             } else {
4001                 ctypes = (unsigned char *)s->s3->tmp.ctype;
4002                 ctypelen = s->s3->tmp.ctype_num;
4003             }
4004             for (i = 0; i < ctypelen; i++) {
4005                 if (ctypes[i] == check_type) {
4006                     rv |= CERT_PKEY_CERT_TYPE;
4007                     break;
4008                 }
4009             }
4010             if (!(rv & CERT_PKEY_CERT_TYPE) && !check_flags)
4011                 goto end;
4012         } else
4013             rv |= CERT_PKEY_CERT_TYPE;
4014
4015         ca_dn = s->s3->tmp.ca_names;
4016
4017         if (!sk_X509_NAME_num(ca_dn))
4018             rv |= CERT_PKEY_ISSUER_NAME;
4019
4020         if (!(rv & CERT_PKEY_ISSUER_NAME)) {
4021             if (ssl_check_ca_name(ca_dn, x))
4022                 rv |= CERT_PKEY_ISSUER_NAME;
4023         }
4024         if (!(rv & CERT_PKEY_ISSUER_NAME)) {
4025             for (i = 0; i < sk_X509_num(chain); i++) {
4026                 X509 *xtmp = sk_X509_value(chain, i);
4027                 if (ssl_check_ca_name(ca_dn, xtmp)) {
4028                     rv |= CERT_PKEY_ISSUER_NAME;
4029                     break;
4030                 }
4031             }
4032         }
4033         if (!check_flags && !(rv & CERT_PKEY_ISSUER_NAME))
4034             goto end;
4035     } else
4036         rv |= CERT_PKEY_ISSUER_NAME | CERT_PKEY_CERT_TYPE;
4037
4038     if (!check_flags || (rv & check_flags) == check_flags)
4039         rv |= CERT_PKEY_VALID;
4040
4041  end:
4042
4043     if (TLS1_get_version(s) >= TLS1_2_VERSION) {
4044         if (*pvalid & CERT_PKEY_EXPLICIT_SIGN)
4045             rv |= CERT_PKEY_EXPLICIT_SIGN | CERT_PKEY_SIGN;
4046         else if (s->s3->tmp.md[idx] != NULL)
4047             rv |= CERT_PKEY_SIGN;
4048     } else
4049         rv |= CERT_PKEY_SIGN | CERT_PKEY_EXPLICIT_SIGN;
4050
4051     /*
4052      * When checking a CERT_PKEY structure all flags are irrelevant if the
4053      * chain is invalid.
4054      */
4055     if (!check_flags) {
4056         if (rv & CERT_PKEY_VALID)
4057             *pvalid = rv;
4058         else {
4059             /* Preserve explicit sign flag, clear rest */
4060             *pvalid &= CERT_PKEY_EXPLICIT_SIGN;
4061             return 0;
4062         }
4063     }
4064     return rv;
4065 }
4066
4067 /* Set validity of certificates in an SSL structure */
4068 void tls1_set_cert_validity(SSL *s)
4069 {
4070     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_RSA_ENC);
4071     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_RSA_SIGN);
4072     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_DSA_SIGN);
4073     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_ECC);
4074     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_GOST01);
4075     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_GOST12_256);
4076     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_GOST12_512);
4077 }
4078
4079 /* User level utiity function to check a chain is suitable */
4080 int SSL_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain)
4081 {
4082     return tls1_check_chain(s, x, pk, chain, -1);
4083 }
4084
4085 #ifndef OPENSSL_NO_DH
4086 DH *ssl_get_auto_dh(SSL *s)
4087 {
4088     int dh_secbits = 80;
4089     if (s->cert->dh_tmp_auto == 2)
4090         return DH_get_1024_160();
4091     if (s->s3->tmp.new_cipher->algorithm_auth & (SSL_aNULL | SSL_aPSK)) {
4092         if (s->s3->tmp.new_cipher->strength_bits == 256)
4093             dh_secbits = 128;
4094         else
4095             dh_secbits = 80;
4096     } else {
4097         CERT_PKEY *cpk = ssl_get_server_send_pkey(s);
4098         dh_secbits = EVP_PKEY_security_bits(cpk->privatekey);
4099     }
4100
4101     if (dh_secbits >= 128) {
4102         DH *dhp = DH_new();
4103         BIGNUM *p, *g;
4104         if (dhp == NULL)
4105             return NULL;
4106         g = BN_new();
4107         if (g != NULL)
4108             BN_set_word(g, 2);
4109         if (dh_secbits >= 192)
4110             p = BN_get_rfc3526_prime_8192(NULL);
4111         else
4112             p = BN_get_rfc3526_prime_3072(NULL);
4113         if (p == NULL || g == NULL || !DH_set0_pqg(dhp, p, NULL, g)) {
4114             DH_free(dhp);
4115             BN_free(p);
4116             BN_free(g);
4117             return NULL;
4118         }
4119         return dhp;
4120     }
4121     if (dh_secbits >= 112)
4122         return DH_get_2048_224();
4123     return DH_get_1024_160();
4124 }
4125 #endif
4126
4127 static int ssl_security_cert_key(SSL *s, SSL_CTX *ctx, X509 *x, int op)
4128 {
4129     int secbits = -1;
4130     EVP_PKEY *pkey = X509_get0_pubkey(x);
4131     if (pkey) {
4132         /*
4133          * If no parameters this will return -1 and fail using the default
4134          * security callback for any non-zero security level. This will
4135          * reject keys which omit parameters but this only affects DSA and
4136          * omission of parameters is never (?) done in practice.
4137          */
4138         secbits = EVP_PKEY_security_bits(pkey);
4139     }
4140     if (s)
4141         return ssl_security(s, op, secbits, 0, x);
4142     else
4143         return ssl_ctx_security(ctx, op, secbits, 0, x);
4144 }
4145
4146 static int ssl_security_cert_sig(SSL *s, SSL_CTX *ctx, X509 *x, int op)
4147 {
4148     /* Lookup signature algorithm digest */
4149     int secbits = -1, md_nid = NID_undef, sig_nid;
4150     /* Don't check signature if self signed */
4151     if ((X509_get_extension_flags(x) & EXFLAG_SS) != 0)
4152         return 1;
4153     sig_nid = X509_get_signature_nid(x);
4154     if (sig_nid && OBJ_find_sigid_algs(sig_nid, &md_nid, NULL)) {
4155         const EVP_MD *md;
4156         if (md_nid && (md = EVP_get_digestbynid(md_nid)))
4157             secbits = EVP_MD_size(md) * 4;
4158     }
4159     if (s)
4160         return ssl_security(s, op, secbits, md_nid, x);
4161     else
4162         return ssl_ctx_security(ctx, op, secbits, md_nid, x);
4163 }
4164
4165 int ssl_security_cert(SSL *s, SSL_CTX *ctx, X509 *x, int vfy, int is_ee)
4166 {
4167     if (vfy)
4168         vfy = SSL_SECOP_PEER;
4169     if (is_ee) {
4170         if (!ssl_security_cert_key(s, ctx, x, SSL_SECOP_EE_KEY | vfy))
4171             return SSL_R_EE_KEY_TOO_SMALL;
4172     } else {
4173         if (!ssl_security_cert_key(s, ctx, x, SSL_SECOP_CA_KEY | vfy))
4174             return SSL_R_CA_KEY_TOO_SMALL;
4175     }
4176     if (!ssl_security_cert_sig(s, ctx, x, SSL_SECOP_CA_MD | vfy))
4177         return SSL_R_CA_MD_TOO_WEAK;
4178     return 1;
4179 }
4180
4181 /*
4182  * Check security of a chain, if sk includes the end entity certificate then
4183  * x is NULL. If vfy is 1 then we are verifying a peer chain and not sending
4184  * one to the peer. Return values: 1 if ok otherwise error code to use
4185  */
4186
4187 int ssl_security_cert_chain(SSL *s, STACK_OF(X509) *sk, X509 *x, int vfy)
4188 {
4189     int rv, start_idx, i;
4190     if (x == NULL) {
4191         x = sk_X509_value(sk, 0);
4192         start_idx = 1;
4193     } else
4194         start_idx = 0;
4195
4196     rv = ssl_security_cert(s, NULL, x, vfy, 1);
4197     if (rv != 1)
4198         return rv;
4199
4200     for (i = start_idx; i < sk_X509_num(sk); i++) {
4201         x = sk_X509_value(sk, i);
4202         rv = ssl_security_cert(s, NULL, x, vfy, 0);
4203         if (rv != 1)
4204             return rv;
4205     }
4206     return 1;
4207 }