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     /* See if we support any ECC ciphersuites */
1030     int using_ecc = 0;
1031     if (s->version >= TLS1_VERSION || SSL_IS_DTLS(s)) {
1032         int i;
1033         unsigned long alg_k, alg_a;
1034         STACK_OF(SSL_CIPHER) *cipher_stack = SSL_get_ciphers(s);
1035
1036         for (i = 0; i < sk_SSL_CIPHER_num(cipher_stack); i++) {
1037             const SSL_CIPHER *c = sk_SSL_CIPHER_value(cipher_stack, i);
1038
1039             alg_k = c->algorithm_mkey;
1040             alg_a = c->algorithm_auth;
1041             if ((alg_k & (SSL_kECDHE | SSL_kECDHEPSK))
1042                 || (alg_a & SSL_aECDSA)) {
1043                 using_ecc = 1;
1044                 break;
1045             }
1046         }
1047     }
1048 #endif
1049
1050     /* Add RI if renegotiating */
1051     if (s->renegotiate) {
1052         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate)
1053                 || !WPACKET_start_sub_packet_u16(pkt)
1054                 || !WPACKET_sub_memcpy_u8(pkt, s->s3->previous_client_finished,
1055                                    s->s3->previous_client_finished_len)
1056                 || !WPACKET_close(pkt)) {
1057             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1058             return 0;
1059         }
1060     }
1061     /* Only add RI for SSLv3 */
1062     if (s->client_version == SSL3_VERSION)
1063         goto done;
1064
1065     if (s->tlsext_hostname != NULL) {
1066         /* Add TLS extension servername to the Client Hello message */
1067         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name)
1068                    /* Sub-packet for server_name extension */
1069                 || !WPACKET_start_sub_packet_u16(pkt)
1070                    /* Sub-packet for servername list (always 1 hostname)*/
1071                 || !WPACKET_start_sub_packet_u16(pkt)
1072                 || !WPACKET_put_bytes_u8(pkt, TLSEXT_NAMETYPE_host_name)
1073                 || !WPACKET_sub_memcpy_u16(pkt, s->tlsext_hostname,
1074                                            strlen(s->tlsext_hostname))
1075                 || !WPACKET_close(pkt)
1076                 || !WPACKET_close(pkt)) {
1077             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1078             return 0;
1079         }
1080     }
1081 #ifndef OPENSSL_NO_SRP
1082     /* Add SRP username if there is one */
1083     if (s->srp_ctx.login != NULL) {
1084         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_srp)
1085                    /* Sub-packet for SRP extension */
1086                 || !WPACKET_start_sub_packet_u16(pkt)
1087                 || !WPACKET_start_sub_packet_u8(pkt)
1088                    /* login must not be zero...internal error if so */
1089                 || !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
1090                 || !WPACKET_memcpy(pkt, s->srp_ctx.login,
1091                                    strlen(s->srp_ctx.login))
1092                 || !WPACKET_close(pkt)
1093                 || !WPACKET_close(pkt)) {
1094             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1095             return 0;
1096         }
1097     }
1098 #endif
1099
1100 #ifndef OPENSSL_NO_EC
1101     if (using_ecc) {
1102         /*
1103          * Add TLS extension ECPointFormats to the ClientHello message
1104          */
1105         const unsigned char *pcurves, *pformats;
1106         size_t num_curves, num_formats;
1107         size_t i;
1108
1109         tls1_get_formatlist(s, &pformats, &num_formats);
1110
1111         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats)
1112                    /* Sub-packet for formats extension */
1113                 || !WPACKET_start_sub_packet_u16(pkt)
1114                 || !WPACKET_sub_memcpy_u8(pkt, pformats, num_formats)
1115                 || !WPACKET_close(pkt)) {
1116             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1117             return 0;
1118         }
1119
1120         /*
1121          * Add TLS extension supported_groups to the ClientHello message
1122          */
1123         /* TODO(TLS1.3): Add support for DHE groups */
1124         pcurves = s->tlsext_supportedgroupslist;
1125         if (!tls1_get_curvelist(s, 0, &pcurves, &num_curves)) {
1126             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1127             return 0;
1128         }
1129
1130         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_groups)
1131                    /* Sub-packet for supported_groups extension */
1132                 || !WPACKET_start_sub_packet_u16(pkt)
1133                 || !WPACKET_start_sub_packet_u16(pkt)) {
1134             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1135             return 0;
1136         }
1137         /* Copy curve ID if supported */
1138         for (i = 0; i < num_curves; i++, pcurves += 2) {
1139             if (tls_curve_allowed(s, pcurves, SSL_SECOP_CURVE_SUPPORTED)) {
1140                 if (!WPACKET_put_bytes_u8(pkt, pcurves[0])
1141                     || !WPACKET_put_bytes_u8(pkt, pcurves[1])) {
1142                         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT,
1143                                ERR_R_INTERNAL_ERROR);
1144                         return 0;
1145                     }
1146             }
1147         }
1148         if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
1149             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1150             return 0;
1151         }
1152     }
1153 #endif                          /* OPENSSL_NO_EC */
1154
1155     if (tls_use_ticket(s)) {
1156         size_t ticklen;
1157         if (!s->new_session && s->session && s->session->tlsext_tick)
1158             ticklen = s->session->tlsext_ticklen;
1159         else if (s->session && s->tlsext_session_ticket &&
1160                  s->tlsext_session_ticket->data) {
1161             ticklen = s->tlsext_session_ticket->length;
1162             s->session->tlsext_tick = OPENSSL_malloc(ticklen);
1163             if (s->session->tlsext_tick == NULL) {
1164                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1165                 return 0;
1166             }
1167             memcpy(s->session->tlsext_tick,
1168                    s->tlsext_session_ticket->data, ticklen);
1169             s->session->tlsext_ticklen = ticklen;
1170         } else
1171             ticklen = 0;
1172         if (ticklen == 0 && s->tlsext_session_ticket &&
1173             s->tlsext_session_ticket->data == NULL)
1174             goto skip_ext;
1175
1176         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket)
1177                 || !WPACKET_sub_memcpy_u16(pkt, s->session->tlsext_tick,
1178                                            ticklen)) {
1179             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1180             return 0;
1181         }
1182     }
1183  skip_ext:
1184
1185     if (SSL_CLIENT_USE_SIGALGS(s)) {
1186         size_t salglen;
1187         const unsigned char *salg;
1188
1189         salglen = tls12_get_psigalgs(s, &salg);
1190
1191         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signature_algorithms)
1192                    /* Sub-packet for sig-algs extension */
1193                 || !WPACKET_start_sub_packet_u16(pkt)
1194                    /* Sub-packet for the actual list */
1195                 || !WPACKET_start_sub_packet_u16(pkt)
1196                 || !tls12_copy_sigalgs(s, pkt, salg, salglen)
1197                 || !WPACKET_close(pkt)
1198                 || !WPACKET_close(pkt)) {
1199             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1200             return 0;
1201         }
1202     }
1203 #ifndef OPENSSL_NO_OCSP
1204     if (s->tlsext_status_type == TLSEXT_STATUSTYPE_ocsp) {
1205         int i;
1206
1207         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request)
1208                    /* Sub-packet for status request extension */
1209                 || !WPACKET_start_sub_packet_u16(pkt)
1210                 || !WPACKET_put_bytes_u8(pkt, TLSEXT_STATUSTYPE_ocsp)
1211                    /* Sub-packet for the ids */
1212                 || !WPACKET_start_sub_packet_u16(pkt)) {
1213             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1214             return 0;
1215         }
1216         for (i = 0; i < sk_OCSP_RESPID_num(s->tlsext_ocsp_ids); i++) {
1217             unsigned char *idbytes;
1218             int idlen;
1219             OCSP_RESPID *id;
1220
1221             id = sk_OCSP_RESPID_value(s->tlsext_ocsp_ids, i);
1222             idlen = i2d_OCSP_RESPID(id, NULL);
1223             if (idlen <= 0
1224                        /* Sub-packet for an individual id */
1225                     || !WPACKET_sub_allocate_bytes_u16(pkt, idlen, &idbytes)
1226                     || i2d_OCSP_RESPID(id, &idbytes) != idlen) {
1227                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1228                 return 0;
1229             }
1230         }
1231         if (!WPACKET_close(pkt)
1232                 || !WPACKET_start_sub_packet_u16(pkt)) {
1233             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1234             return 0;
1235         }
1236         if (s->tlsext_ocsp_exts) {
1237             unsigned char *extbytes;
1238             int extlen = i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts, NULL);
1239
1240             if (extlen < 0) {
1241                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1242                 return 0;
1243             }
1244             if (!WPACKET_allocate_bytes(pkt, extlen, &extbytes)
1245                     || i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts, &extbytes)
1246                        != extlen) {
1247                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1248                 return 0;
1249            }
1250         }
1251         if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
1252             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1253             return 0;
1254         }
1255     }
1256 #endif
1257 #ifndef OPENSSL_NO_HEARTBEATS
1258     if (SSL_IS_DTLS(s)) {
1259         unsigned int mode;
1260
1261         /*-
1262          * Set mode:
1263          * 1: peer may send requests
1264          * 2: peer not allowed to send requests
1265          */
1266         if (s->tlsext_heartbeat & SSL_DTLSEXT_HB_DONT_RECV_REQUESTS)
1267             mode = SSL_DTLSEXT_HB_DONT_SEND_REQUESTS;
1268         else
1269             mode = SSL_DTLSEXT_HB_ENABLED;
1270
1271         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_heartbeat)
1272                    /* Sub-packet for Hearbeat extension */
1273                 || !WPACKET_start_sub_packet_u16(pkt)
1274                 || !WPACKET_put_bytes_u8(pkt, mode)
1275                 || !WPACKET_close(pkt)) {
1276             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1277             return 0;
1278         }
1279     }
1280 #endif
1281
1282 #ifndef OPENSSL_NO_NEXTPROTONEG
1283     if (s->ctx->next_proto_select_cb && !s->s3->tmp.finish_md_len) {
1284         /*
1285          * The client advertises an empty extension to indicate its support
1286          * for Next Protocol Negotiation
1287          */
1288         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg)
1289                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1290             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1291             return 0;
1292         }
1293     }
1294 #endif
1295
1296     /*
1297      * finish_md_len is non-zero during a renegotiation, so
1298      * this avoids sending ALPN during the renegotiation
1299      * (see longer comment below)
1300      */
1301     if (s->alpn_client_proto_list && !s->s3->tmp.finish_md_len) {
1302         if (!WPACKET_put_bytes_u16(pkt,
1303                     TLSEXT_TYPE_application_layer_protocol_negotiation)
1304                    /* Sub-packet ALPN extension */
1305                 || !WPACKET_start_sub_packet_u16(pkt)
1306                 || !WPACKET_sub_memcpy_u16(pkt, s->alpn_client_proto_list,
1307                                            s->alpn_client_proto_list_len)
1308                 || !WPACKET_close(pkt)) {
1309             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1310             return 0;
1311         }
1312         s->s3->alpn_sent = 1;
1313     }
1314 #ifndef OPENSSL_NO_SRTP
1315     if (SSL_IS_DTLS(s) && SSL_get_srtp_profiles(s)) {
1316         STACK_OF(SRTP_PROTECTION_PROFILE) *clnt = SSL_get_srtp_profiles(s);
1317         SRTP_PROTECTION_PROFILE *prof;
1318         int i, ct;
1319
1320         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp)
1321                    /* Sub-packet for SRTP extension */
1322                 || !WPACKET_start_sub_packet_u16(pkt)
1323                    /* Sub-packet for the protection profile list */
1324                 || !WPACKET_start_sub_packet_u16(pkt)) {
1325             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1326             return 0;
1327         }
1328         ct = sk_SRTP_PROTECTION_PROFILE_num(clnt);
1329         for (i = 0; i < ct; i++) {
1330             prof = sk_SRTP_PROTECTION_PROFILE_value(clnt, i);
1331             if (prof == NULL || !WPACKET_put_bytes_u16(pkt, prof->id)) {
1332                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1333                 return 0;
1334             }
1335         }
1336         if (!WPACKET_close(pkt)
1337                    /* Add an empty use_mki value */
1338                 || !WPACKET_put_bytes_u8(pkt, 0)
1339                 || !WPACKET_close(pkt)) {
1340             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1341             return 0;
1342         }
1343     }
1344 #endif
1345     custom_ext_init(&s->cert->cli_ext);
1346     /* Add custom TLS Extensions to ClientHello */
1347     if (!custom_ext_add(s, 0, pkt, al)) {
1348         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1349         return 0;
1350     }
1351
1352     if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)) {
1353         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac)
1354             || !WPACKET_put_bytes_u16(pkt, 0)) {
1355             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1356             return 0;
1357         }
1358     }
1359
1360 #ifndef OPENSSL_NO_CT
1361     if (s->ct_validation_callback != NULL) {
1362         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signed_certificate_timestamp)
1363                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1364             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1365             return 0;
1366         }
1367     }
1368 #endif
1369
1370     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret)
1371             || !WPACKET_put_bytes_u16(pkt, 0)) {
1372         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1373         return 0;
1374     }
1375
1376     if (SSL_IS_TLS13(s)) {
1377         int min_version, max_version, reason, currv;
1378         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_versions)
1379                 || !WPACKET_start_sub_packet_u16(pkt)
1380                 || !WPACKET_start_sub_packet_u8(pkt)) {
1381             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1382             return 0;
1383         }
1384         reason = ssl_get_client_min_max_version(s, &min_version, &max_version);
1385         if (reason != 0) {
1386             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, reason);
1387             return 0;
1388         }
1389         /*
1390          * TODO(TLS1.3): There is some discussion on the TLS list as to wheter
1391          * we should include versions <TLS1.2. For the moment we do. To be
1392          * reviewed later.
1393          */
1394         for (currv = max_version; currv >= min_version; currv--) {
1395             /* TODO(TLS1.3): Remove this first if clause prior to release!! */
1396             if (currv == TLS1_3_VERSION) {
1397                 if (!WPACKET_put_bytes_u16(pkt, TLS1_3_VERSION_DRAFT)) {
1398                     SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT,
1399                            ERR_R_INTERNAL_ERROR);
1400                     return 0;
1401                 }
1402             } else if (!WPACKET_put_bytes_u16(pkt, currv)) {
1403                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1404                 return 0;
1405             }
1406         }
1407         if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
1408             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1409             return 0;
1410         }
1411     }
1412
1413     /*
1414      * Add padding to workaround bugs in F5 terminators. See
1415      * https://tools.ietf.org/html/draft-agl-tls-padding-03 NB: because this
1416      * code works out the length of all existing extensions it MUST always
1417      * appear last.
1418      */
1419     if (s->options & SSL_OP_TLSEXT_PADDING) {
1420         unsigned char *padbytes;
1421         size_t hlen;
1422
1423         if (!WPACKET_get_total_written(pkt, &hlen)) {
1424             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1425             return 0;
1426         }
1427
1428         if (hlen > 0xff && hlen < 0x200) {
1429             hlen = 0x200 - hlen;
1430             if (hlen >= 4)
1431                 hlen -= 4;
1432             else
1433                 hlen = 0;
1434
1435             if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_padding)
1436                     || !WPACKET_sub_allocate_bytes_u16(pkt, hlen, &padbytes)) {
1437                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1438                 return 0;
1439             }
1440             memset(padbytes, 0, hlen);
1441         }
1442     }
1443
1444  done:
1445     return 1;
1446 }
1447
1448 int ssl_add_serverhello_tlsext(SSL *s, WPACKET *pkt, int *al)
1449 {
1450 #ifndef OPENSSL_NO_NEXTPROTONEG
1451     int next_proto_neg_seen;
1452 #endif
1453 #ifndef OPENSSL_NO_EC
1454     unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
1455     unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
1456     int using_ecc = (alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA);
1457     using_ecc = using_ecc && (s->session->tlsext_ecpointformatlist != NULL);
1458 #endif
1459
1460     if (!WPACKET_start_sub_packet_u16(pkt)
1461             || !WPACKET_set_flags(pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH)) {
1462         SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1463         return 0;
1464     }
1465
1466     if (s->s3->send_connection_binding &&
1467             !ssl_add_serverhello_renegotiate_ext(s, pkt)) {
1468         SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1469         return 0;
1470     }
1471
1472     /* Only add RI for SSLv3 */
1473     if (s->version == SSL3_VERSION)
1474         goto done;
1475
1476     if (!s->hit && s->servername_done == 1
1477             && s->session->tlsext_hostname != NULL) {
1478         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name)
1479                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1480             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1481             return 0;
1482         }
1483     }
1484 #ifndef OPENSSL_NO_EC
1485     if (using_ecc) {
1486         const unsigned char *plist;
1487         size_t plistlen;
1488         /*
1489          * Add TLS extension ECPointFormats to the ServerHello message
1490          */
1491         tls1_get_formatlist(s, &plist, &plistlen);
1492
1493         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats)
1494                 || !WPACKET_start_sub_packet_u16(pkt)
1495                 || !WPACKET_sub_memcpy_u8(pkt, plist, plistlen)
1496                 || !WPACKET_close(pkt)) {
1497             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1498             return 0;
1499         }
1500     }
1501     /*
1502      * Currently the server should not respond with a SupportedCurves
1503      * extension
1504      */
1505 #endif                          /* OPENSSL_NO_EC */
1506
1507     if (s->tlsext_ticket_expected && tls_use_ticket(s)) {
1508         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket)
1509                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1510             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1511             return 0;
1512         }
1513     } else {
1514         /*
1515          * if we don't add the above TLSEXT, we can't add a session ticket
1516          * later
1517          */
1518         s->tlsext_ticket_expected = 0;
1519     }
1520
1521     if (s->tlsext_status_expected) {
1522         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request)
1523                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1524             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1525             return 0;
1526         }
1527     }
1528 #ifndef OPENSSL_NO_SRTP
1529     if (SSL_IS_DTLS(s) && s->srtp_profile) {
1530         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp)
1531                 || !WPACKET_start_sub_packet_u16(pkt)
1532                 || !WPACKET_put_bytes_u16(pkt, 2)
1533                 || !WPACKET_put_bytes_u16(pkt, s->srtp_profile->id)
1534                 || !WPACKET_put_bytes_u8(pkt, 0)
1535                 || !WPACKET_close(pkt)) {
1536             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1537             return 0;
1538         }
1539     }
1540 #endif
1541
1542     if (((s->s3->tmp.new_cipher->id & 0xFFFF) == 0x80
1543          || (s->s3->tmp.new_cipher->id & 0xFFFF) == 0x81)
1544         && (SSL_get_options(s) & SSL_OP_CRYPTOPRO_TLSEXT_BUG)) {
1545         const unsigned char cryptopro_ext[36] = {
1546             0xfd, 0xe8,         /* 65000 */
1547             0x00, 0x20,         /* 32 bytes length */
1548             0x30, 0x1e, 0x30, 0x08, 0x06, 0x06, 0x2a, 0x85,
1549             0x03, 0x02, 0x02, 0x09, 0x30, 0x08, 0x06, 0x06,
1550             0x2a, 0x85, 0x03, 0x02, 0x02, 0x16, 0x30, 0x08,
1551             0x06, 0x06, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x17
1552         };
1553         if (!WPACKET_memcpy(pkt, cryptopro_ext, sizeof(cryptopro_ext))) {
1554             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1555             return 0;
1556         }
1557     }
1558 #ifndef OPENSSL_NO_HEARTBEATS
1559     /* Add Heartbeat extension if we've received one */
1560     if (SSL_IS_DTLS(s) && (s->tlsext_heartbeat & SSL_DTLSEXT_HB_ENABLED)) {
1561         unsigned int mode;
1562         /*-
1563          * Set mode:
1564          * 1: peer may send requests
1565          * 2: peer not allowed to send requests
1566          */
1567         if (s->tlsext_heartbeat & SSL_DTLSEXT_HB_DONT_RECV_REQUESTS)
1568             mode = SSL_DTLSEXT_HB_DONT_SEND_REQUESTS;
1569         else
1570             mode = SSL_DTLSEXT_HB_ENABLED;
1571
1572         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_heartbeat)
1573                 || !WPACKET_start_sub_packet_u16(pkt)
1574                 || !WPACKET_put_bytes_u8(pkt, mode)
1575                 || !WPACKET_close(pkt)) {
1576             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1577             return 0;
1578         }
1579
1580     }
1581 #endif
1582
1583 #ifndef OPENSSL_NO_NEXTPROTONEG
1584     next_proto_neg_seen = s->s3->next_proto_neg_seen;
1585     s->s3->next_proto_neg_seen = 0;
1586     if (next_proto_neg_seen && s->ctx->next_protos_advertised_cb) {
1587         const unsigned char *npa;
1588         unsigned int npalen;
1589         int r;
1590
1591         r = s->ctx->next_protos_advertised_cb(s, &npa, &npalen,
1592                                               s->
1593                                               ctx->next_protos_advertised_cb_arg);
1594         if (r == SSL_TLSEXT_ERR_OK) {
1595             if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg)
1596                     || !WPACKET_sub_memcpy_u16(pkt, npa, npalen)) {
1597                 SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1598                 return 0;
1599             }
1600             s->s3->next_proto_neg_seen = 1;
1601         }
1602     }
1603 #endif
1604     if (!custom_ext_add(s, 1, pkt, al)) {
1605         SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1606         return 0;
1607     }
1608
1609     if (s->s3->flags & TLS1_FLAGS_ENCRYPT_THEN_MAC) {
1610         /*
1611          * Don't use encrypt_then_mac if AEAD or RC4 might want to disable
1612          * for other cases too.
1613          */
1614         if (s->s3->tmp.new_cipher->algorithm_mac == SSL_AEAD
1615             || s->s3->tmp.new_cipher->algorithm_enc == SSL_RC4
1616             || s->s3->tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT
1617             || s->s3->tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT12)
1618             s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
1619         else {
1620             if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac)
1621                     || !WPACKET_put_bytes_u16(pkt, 0)) {
1622                 SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1623                 return 0;
1624             }
1625         }
1626     }
1627     if (s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) {
1628         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret)
1629                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1630             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1631             return 0;
1632         }
1633     }
1634
1635     if (s->s3->alpn_selected != NULL) {
1636         if (!WPACKET_put_bytes_u16(pkt,
1637                     TLSEXT_TYPE_application_layer_protocol_negotiation)
1638                 || !WPACKET_start_sub_packet_u16(pkt)
1639                 || !WPACKET_start_sub_packet_u16(pkt)
1640                 || !WPACKET_sub_memcpy_u8(pkt, s->s3->alpn_selected,
1641                                           s->s3->alpn_selected_len)
1642                 || !WPACKET_close(pkt)
1643                 || !WPACKET_close(pkt)) {
1644             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1645             return 0;
1646         }
1647     }
1648
1649  done:
1650     if (!WPACKET_close(pkt)) {
1651         SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1652         return 0;
1653     }
1654     return 1;
1655 }
1656
1657 /*
1658  * Save the ALPN extension in a ClientHello.
1659  * pkt: the contents of the ALPN extension, not including type and length.
1660  * al: a pointer to the  alert value to send in the event of a failure.
1661  * returns: 1 on success, 0 on error.
1662  */
1663 static int tls1_alpn_handle_client_hello(SSL *s, PACKET *pkt, int *al)
1664 {
1665     PACKET protocol_list, save_protocol_list, protocol;
1666
1667     *al = SSL_AD_DECODE_ERROR;
1668
1669     if (!PACKET_as_length_prefixed_2(pkt, &protocol_list)
1670         || PACKET_remaining(&protocol_list) < 2) {
1671         return 0;
1672     }
1673
1674     save_protocol_list = protocol_list;
1675     do {
1676         /* Protocol names can't be empty. */
1677         if (!PACKET_get_length_prefixed_1(&protocol_list, &protocol)
1678             || PACKET_remaining(&protocol) == 0) {
1679             return 0;
1680         }
1681     } while (PACKET_remaining(&protocol_list) != 0);
1682
1683     if (!PACKET_memdup(&save_protocol_list,
1684                        &s->s3->alpn_proposed, &s->s3->alpn_proposed_len)) {
1685         *al = TLS1_AD_INTERNAL_ERROR;
1686         return 0;
1687     }
1688
1689     return 1;
1690 }
1691
1692 /*
1693  * Process the ALPN extension in a ClientHello.
1694  * al: a pointer to the alert value to send in the event of a failure.
1695  * returns 1 on success, 0 on error.
1696  */
1697 static int tls1_alpn_handle_client_hello_late(SSL *s, int *al)
1698 {
1699     const unsigned char *selected = NULL;
1700     unsigned char selected_len = 0;
1701
1702     if (s->ctx->alpn_select_cb != NULL && s->s3->alpn_proposed != NULL) {
1703         int r = s->ctx->alpn_select_cb(s, &selected, &selected_len,
1704                                        s->s3->alpn_proposed,
1705                                        (unsigned int)s->s3->alpn_proposed_len,
1706                                        s->ctx->alpn_select_cb_arg);
1707
1708         if (r == SSL_TLSEXT_ERR_OK) {
1709             OPENSSL_free(s->s3->alpn_selected);
1710             s->s3->alpn_selected = OPENSSL_memdup(selected, selected_len);
1711             if (s->s3->alpn_selected == NULL) {
1712                 *al = SSL_AD_INTERNAL_ERROR;
1713                 return 0;
1714             }
1715             s->s3->alpn_selected_len = selected_len;
1716 #ifndef OPENSSL_NO_NEXTPROTONEG
1717             /* ALPN takes precedence over NPN. */
1718             s->s3->next_proto_neg_seen = 0;
1719 #endif
1720         } else {
1721             *al = SSL_AD_NO_APPLICATION_PROTOCOL;
1722             return 0;
1723         }
1724     }
1725
1726     return 1;
1727 }
1728
1729 #ifndef OPENSSL_NO_EC
1730 /*-
1731  * ssl_check_for_safari attempts to fingerprint Safari using OS X
1732  * SecureTransport using the TLS extension block in |hello|.
1733  * Safari, since 10.6, sends exactly these extensions, in this order:
1734  *   SNI,
1735  *   elliptic_curves
1736  *   ec_point_formats
1737  *
1738  * We wish to fingerprint Safari because they broke ECDHE-ECDSA support in 10.8,
1739  * but they advertise support. So enabling ECDHE-ECDSA ciphers breaks them.
1740  * Sadly we cannot differentiate 10.6, 10.7 and 10.8.4 (which work), from
1741  * 10.8..10.8.3 (which don't work).
1742  */
1743 static void ssl_check_for_safari(SSL *s, const CLIENTHELLO_MSG *hello)
1744 {
1745     unsigned int type;
1746     PACKET sni, tmppkt;
1747     size_t ext_len;
1748
1749     static const unsigned char kSafariExtensionsBlock[] = {
1750         0x00, 0x0a,             /* elliptic_curves extension */
1751         0x00, 0x08,             /* 8 bytes */
1752         0x00, 0x06,             /* 6 bytes of curve ids */
1753         0x00, 0x17,             /* P-256 */
1754         0x00, 0x18,             /* P-384 */
1755         0x00, 0x19,             /* P-521 */
1756
1757         0x00, 0x0b,             /* ec_point_formats */
1758         0x00, 0x02,             /* 2 bytes */
1759         0x01,                   /* 1 point format */
1760         0x00,                   /* uncompressed */
1761         /* The following is only present in TLS 1.2 */
1762         0x00, 0x0d,             /* signature_algorithms */
1763         0x00, 0x0c,             /* 12 bytes */
1764         0x00, 0x0a,             /* 10 bytes */
1765         0x05, 0x01,             /* SHA-384/RSA */
1766         0x04, 0x01,             /* SHA-256/RSA */
1767         0x02, 0x01,             /* SHA-1/RSA */
1768         0x04, 0x03,             /* SHA-256/ECDSA */
1769         0x02, 0x03,             /* SHA-1/ECDSA */
1770     };
1771
1772     /* Length of the common prefix (first two extensions). */
1773     static const size_t kSafariCommonExtensionsLength = 18;
1774
1775     tmppkt = hello->extensions;
1776
1777     if (!PACKET_forward(&tmppkt, 2)
1778         || !PACKET_get_net_2(&tmppkt, &type)
1779         || !PACKET_get_length_prefixed_2(&tmppkt, &sni)) {
1780         return;
1781     }
1782
1783     if (type != TLSEXT_TYPE_server_name)
1784         return;
1785
1786     ext_len = TLS1_get_client_version(s) >= TLS1_2_VERSION ?
1787         sizeof(kSafariExtensionsBlock) : kSafariCommonExtensionsLength;
1788
1789     s->s3->is_probably_safari = PACKET_equal(&tmppkt, kSafariExtensionsBlock,
1790                                              ext_len);
1791 }
1792 #endif                          /* !OPENSSL_NO_EC */
1793
1794 /*
1795  * Loop through all remaining ClientHello extensions that we collected earlier
1796  * and haven't already processed. For each one parse it and update the SSL
1797  * object as required.
1798  *
1799  * Behaviour upon resumption is extension-specific. If the extension has no
1800  * effect during resumption, it is parsed (to verify its format) but otherwise
1801  * ignored.
1802  *
1803  * Returns 1 on success and 0 on failure.
1804  * Upon failure, sets |al| to the appropriate alert.
1805  */
1806 static int ssl_scan_clienthello_tlsext(SSL *s, CLIENTHELLO_MSG *hello, int *al)
1807 {
1808     size_t loop;
1809     int renegotiate_seen = 0;
1810
1811     *al = SSL_AD_DECODE_ERROR;
1812     s->servername_done = 0;
1813     s->tlsext_status_type = -1;
1814 #ifndef OPENSSL_NO_NEXTPROTONEG
1815     s->s3->next_proto_neg_seen = 0;
1816 #endif
1817
1818     OPENSSL_free(s->s3->alpn_selected);
1819     s->s3->alpn_selected = NULL;
1820     s->s3->alpn_selected_len = 0;
1821     OPENSSL_free(s->s3->alpn_proposed);
1822     s->s3->alpn_proposed = NULL;
1823     s->s3->alpn_proposed_len = 0;
1824 #ifndef OPENSSL_NO_HEARTBEATS
1825     s->tlsext_heartbeat &= ~(SSL_DTLSEXT_HB_ENABLED |
1826                              SSL_DTLSEXT_HB_DONT_SEND_REQUESTS);
1827 #endif
1828
1829 #ifndef OPENSSL_NO_EC
1830     if (s->options & SSL_OP_SAFARI_ECDHE_ECDSA_BUG)
1831         ssl_check_for_safari(s, hello);
1832 #endif                          /* !OPENSSL_NO_EC */
1833
1834     /* Clear any signature algorithms extension received */
1835     OPENSSL_free(s->s3->tmp.peer_sigalgs);
1836     s->s3->tmp.peer_sigalgs = NULL;
1837     s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
1838
1839 #ifndef OPENSSL_NO_SRP
1840     OPENSSL_free(s->srp_ctx.login);
1841     s->srp_ctx.login = NULL;
1842 #endif
1843
1844     s->srtp_profile = NULL;
1845
1846     /*
1847      * We parse all extensions to ensure the ClientHello is well-formed but,
1848      * unless an extension specifies otherwise, we ignore extensions upon
1849      * resumption.
1850      */
1851     for (loop = 0; loop < hello->num_extensions; loop++) {
1852         RAW_EXTENSION *currext = &hello->pre_proc_exts[loop];
1853
1854         if (s->tlsext_debug_cb)
1855             s->tlsext_debug_cb(s, 0, currext->type,
1856                                PACKET_data(&currext->data),
1857                                PACKET_remaining(&currext->data),
1858                                s->tlsext_debug_arg);
1859
1860         if (currext->type == TLSEXT_TYPE_renegotiate) {
1861             if (!ssl_parse_clienthello_renegotiate_ext(s,
1862                     &currext->data, al))
1863                 return 0;
1864             renegotiate_seen = 1;
1865         } else if (s->version == SSL3_VERSION) {
1866         }
1867 /*-
1868  * The servername extension is treated as follows:
1869  *
1870  * - Only the hostname type is supported with a maximum length of 255.
1871  * - The servername is rejected if too long or if it contains zeros,
1872  *   in which case an fatal alert is generated.
1873  * - The servername field is maintained together with the session cache.
1874  * - When a session is resumed, the servername call back invoked in order
1875  *   to allow the application to position itself to the right context.
1876  * - The servername is acknowledged if it is new for a session or when
1877  *   it is identical to a previously used for the same session.
1878  *   Applications can control the behaviour.  They can at any time
1879  *   set a 'desirable' servername for a new SSL object. This can be the
1880  *   case for example with HTTPS when a Host: header field is received and
1881  *   a renegotiation is requested. In this case, a possible servername
1882  *   presented in the new client hello is only acknowledged if it matches
1883  *   the value of the Host: field.
1884  * - Applications must  use SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
1885  *   if they provide for changing an explicit servername context for the
1886  *   session, i.e. when the session has been established with a servername
1887  *   extension.
1888  * - On session reconnect, the servername extension may be absent.
1889  *
1890  */
1891
1892         else if (currext->type == TLSEXT_TYPE_server_name) {
1893             unsigned int servname_type;
1894             PACKET sni, hostname;
1895
1896             if (!PACKET_as_length_prefixed_2(&currext->data, &sni)
1897                 /* ServerNameList must be at least 1 byte long. */
1898                 || PACKET_remaining(&sni) == 0) {
1899                 return 0;
1900             }
1901
1902             /*
1903              * Although the server_name extension was intended to be
1904              * extensible to new name types, RFC 4366 defined the
1905              * syntax inextensibility and OpenSSL 1.0.x parses it as
1906              * such.
1907              * RFC 6066 corrected the mistake but adding new name types
1908              * is nevertheless no longer feasible, so act as if no other
1909              * SNI types can exist, to simplify parsing.
1910              *
1911              * Also note that the RFC permits only one SNI value per type,
1912              * i.e., we can only have a single hostname.
1913              */
1914             if (!PACKET_get_1(&sni, &servname_type)
1915                 || servname_type != TLSEXT_NAMETYPE_host_name
1916                 || !PACKET_as_length_prefixed_2(&sni, &hostname)) {
1917                 return 0;
1918             }
1919
1920             if (!s->hit) {
1921                 if (PACKET_remaining(&hostname) > TLSEXT_MAXLEN_host_name) {
1922                     *al = TLS1_AD_UNRECOGNIZED_NAME;
1923                     return 0;
1924                 }
1925
1926                 if (PACKET_contains_zero_byte(&hostname)) {
1927                     *al = TLS1_AD_UNRECOGNIZED_NAME;
1928                     return 0;
1929                 }
1930
1931                 if (!PACKET_strndup(&hostname, &s->session->tlsext_hostname)) {
1932                     *al = TLS1_AD_INTERNAL_ERROR;
1933                     return 0;
1934                 }
1935
1936                 s->servername_done = 1;
1937             } else {
1938                 /*
1939                  * TODO(openssl-team): if the SNI doesn't match, we MUST
1940                  * fall back to a full handshake.
1941                  */
1942                 s->servername_done = s->session->tlsext_hostname
1943                     && PACKET_equal(&hostname, s->session->tlsext_hostname,
1944                                     strlen(s->session->tlsext_hostname));
1945             }
1946         }
1947 #ifndef OPENSSL_NO_SRP
1948         else if (currext->type == TLSEXT_TYPE_srp) {
1949             PACKET srp_I;
1950
1951             if (!PACKET_as_length_prefixed_1(&currext->data, &srp_I))
1952                 return 0;
1953
1954             if (PACKET_contains_zero_byte(&srp_I))
1955                 return 0;
1956
1957             /*
1958              * TODO(openssl-team): currently, we re-authenticate the user
1959              * upon resumption. Instead, we MUST ignore the login.
1960              */
1961             if (!PACKET_strndup(&srp_I, &s->srp_ctx.login)) {
1962                 *al = TLS1_AD_INTERNAL_ERROR;
1963                 return 0;
1964             }
1965         }
1966 #endif
1967
1968 #ifndef OPENSSL_NO_EC
1969         else if (currext->type == TLSEXT_TYPE_ec_point_formats) {
1970             PACKET ec_point_format_list;
1971
1972             if (!PACKET_as_length_prefixed_1(&currext->data,
1973                                              &ec_point_format_list)
1974                 || PACKET_remaining(&ec_point_format_list) == 0) {
1975                 return 0;
1976             }
1977
1978             if (!s->hit) {
1979                 if (!PACKET_memdup(&ec_point_format_list,
1980                                    &s->session->tlsext_ecpointformatlist,
1981                                    &s->
1982                                    session->tlsext_ecpointformatlist_length)) {
1983                     *al = TLS1_AD_INTERNAL_ERROR;
1984                     return 0;
1985                 }
1986             }
1987         } else if (currext->type == TLSEXT_TYPE_supported_groups) {
1988             PACKET supported_groups_list;
1989
1990             /* Each group is 2 bytes and we must have at least 1. */
1991             if (!PACKET_as_length_prefixed_2(&currext->data,
1992                                              &supported_groups_list)
1993                 || PACKET_remaining(&supported_groups_list) == 0
1994                 || (PACKET_remaining(&supported_groups_list) % 2) != 0) {
1995                 return 0;
1996             }
1997
1998             if (!s->hit) {
1999                 if (!PACKET_memdup(&supported_groups_list,
2000                                    &s->session->tlsext_supportedgroupslist,
2001                                    &s->
2002                                    session->tlsext_supportedgroupslist_length)) {
2003                     *al = TLS1_AD_INTERNAL_ERROR;
2004                     return 0;
2005                 }
2006             }
2007         }
2008 #endif                          /* OPENSSL_NO_EC */
2009         else if (currext->type == TLSEXT_TYPE_session_ticket) {
2010             if (s->tls_session_ticket_ext_cb &&
2011                 !s->tls_session_ticket_ext_cb(s,
2012                     PACKET_data(&currext->data),
2013                     PACKET_remaining(&currext->data),
2014                     s->tls_session_ticket_ext_cb_arg)) {
2015                 *al = TLS1_AD_INTERNAL_ERROR;
2016                 return 0;
2017             }
2018         } else if (currext->type == TLSEXT_TYPE_signature_algorithms) {
2019             PACKET supported_sig_algs;
2020
2021             if (!PACKET_as_length_prefixed_2(&currext->data,
2022                                              &supported_sig_algs)
2023                 || (PACKET_remaining(&supported_sig_algs) % 2) != 0
2024                 || PACKET_remaining(&supported_sig_algs) == 0) {
2025                 return 0;
2026             }
2027
2028             if (!s->hit) {
2029                 if (!tls1_save_sigalgs(s, PACKET_data(&supported_sig_algs),
2030                                        PACKET_remaining(&supported_sig_algs))) {
2031                     return 0;
2032                 }
2033             }
2034         } else if (currext->type == TLSEXT_TYPE_status_request) {
2035             if (!PACKET_get_1(&currext->data,
2036                               (unsigned int *)&s->tlsext_status_type)) {
2037                 return 0;
2038             }
2039 #ifndef OPENSSL_NO_OCSP
2040             if (s->tlsext_status_type == TLSEXT_STATUSTYPE_ocsp) {
2041                 const unsigned char *ext_data;
2042                 PACKET responder_id_list, exts;
2043                 if (!PACKET_get_length_prefixed_2
2044                     (&currext->data, &responder_id_list))
2045                     return 0;
2046
2047                 /*
2048                  * We remove any OCSP_RESPIDs from a previous handshake
2049                  * to prevent unbounded memory growth - CVE-2016-6304
2050                  */
2051                 sk_OCSP_RESPID_pop_free(s->tlsext_ocsp_ids,
2052                                         OCSP_RESPID_free);
2053                 if (PACKET_remaining(&responder_id_list) > 0) {
2054                     s->tlsext_ocsp_ids = sk_OCSP_RESPID_new_null();
2055                     if (s->tlsext_ocsp_ids == NULL) {
2056                         *al = SSL_AD_INTERNAL_ERROR;
2057                         return 0;
2058                     }
2059                 } else {
2060                     s->tlsext_ocsp_ids = NULL;
2061                 }
2062
2063                 while (PACKET_remaining(&responder_id_list) > 0) {
2064                     OCSP_RESPID *id;
2065                     PACKET responder_id;
2066                     const unsigned char *id_data;
2067
2068                     if (!PACKET_get_length_prefixed_2(&responder_id_list,
2069                                                       &responder_id)
2070                         || PACKET_remaining(&responder_id) == 0) {
2071                         return 0;
2072                     }
2073
2074                     id_data = PACKET_data(&responder_id);
2075                     /* TODO(size_t): Convert d2i_* to size_t */
2076                     id = d2i_OCSP_RESPID(NULL, &id_data,
2077                                          (int)PACKET_remaining(&responder_id));
2078                     if (id == NULL)
2079                         return 0;
2080
2081                     if (id_data != PACKET_end(&responder_id)) {
2082                         OCSP_RESPID_free(id);
2083                         return 0;
2084                     }
2085
2086                     if (!sk_OCSP_RESPID_push(s->tlsext_ocsp_ids, id)) {
2087                         OCSP_RESPID_free(id);
2088                         *al = SSL_AD_INTERNAL_ERROR;
2089                         return 0;
2090                     }
2091                 }
2092
2093                 /* Read in request_extensions */
2094                 if (!PACKET_as_length_prefixed_2(
2095                         &currext->data, &exts))
2096                     return 0;
2097
2098                 if (PACKET_remaining(&exts) > 0) {
2099                     ext_data = PACKET_data(&exts);
2100                     sk_X509_EXTENSION_pop_free(s->tlsext_ocsp_exts,
2101                                                X509_EXTENSION_free);
2102                     s->tlsext_ocsp_exts =
2103                         d2i_X509_EXTENSIONS(NULL, &ext_data,
2104                                             (int)PACKET_remaining(&exts));
2105                     if (s->tlsext_ocsp_exts == NULL
2106                         || ext_data != PACKET_end(&exts)) {
2107                         return 0;
2108                     }
2109                 }
2110             } else
2111 #endif
2112             {
2113                 /*
2114                  * We don't know what to do with any other type so ignore it.
2115                  */
2116                 s->tlsext_status_type = -1;
2117             }
2118         }
2119 #ifndef OPENSSL_NO_HEARTBEATS
2120         else if (SSL_IS_DTLS(s) && currext->type == TLSEXT_TYPE_heartbeat) {
2121             unsigned int hbtype;
2122
2123             if (!PACKET_get_1(&currext->data, &hbtype)
2124                 || PACKET_remaining(&currext->data)) {
2125                 *al = SSL_AD_DECODE_ERROR;
2126                 return 0;
2127             }
2128             switch (hbtype) {
2129             case 0x01:         /* Client allows us to send HB requests */
2130                 s->tlsext_heartbeat |= SSL_DTLSEXT_HB_ENABLED;
2131                 break;
2132             case 0x02:         /* Client doesn't accept HB requests */
2133                 s->tlsext_heartbeat |= SSL_DTLSEXT_HB_ENABLED;
2134                 s->tlsext_heartbeat |= SSL_DTLSEXT_HB_DONT_SEND_REQUESTS;
2135                 break;
2136             default:
2137                 *al = SSL_AD_ILLEGAL_PARAMETER;
2138                 return 0;
2139             }
2140         }
2141 #endif
2142 #ifndef OPENSSL_NO_NEXTPROTONEG
2143         else if (currext->type == TLSEXT_TYPE_next_proto_neg
2144                  && s->s3->tmp.finish_md_len == 0) {
2145             /*-
2146              * We shouldn't accept this extension on a
2147              * renegotiation.
2148              *
2149              * s->new_session will be set on renegotiation, but we
2150              * probably shouldn't rely that it couldn't be set on
2151              * the initial renegotiation too in certain cases (when
2152              * there's some other reason to disallow resuming an
2153              * earlier session -- the current code won't be doing
2154              * anything like that, but this might change).
2155              *
2156              * A valid sign that there's been a previous handshake
2157              * in this connection is if s->s3->tmp.finish_md_len >
2158              * 0.  (We are talking about a check that will happen
2159              * in the Hello protocol round, well before a new
2160              * Finished message could have been computed.)
2161              */
2162             s->s3->next_proto_neg_seen = 1;
2163         }
2164 #endif
2165
2166         else if (currext->type
2167                      == TLSEXT_TYPE_application_layer_protocol_negotiation
2168                  && s->s3->tmp.finish_md_len == 0) {
2169             if (!tls1_alpn_handle_client_hello(s,
2170                     &currext->data, al))
2171                 return 0;
2172         }
2173
2174         /* session ticket processed earlier */
2175 #ifndef OPENSSL_NO_SRTP
2176         else if (SSL_IS_DTLS(s) && SSL_get_srtp_profiles(s)
2177                  && currext->type == TLSEXT_TYPE_use_srtp) {
2178             if (ssl_parse_clienthello_use_srtp_ext(s,
2179                     &currext->data, al))
2180                 return 0;
2181         }
2182 #endif
2183         else if (currext->type == TLSEXT_TYPE_encrypt_then_mac
2184                  && !(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC))
2185             s->s3->flags |= TLS1_FLAGS_ENCRYPT_THEN_MAC;
2186         /*
2187          * Note: extended master secret extension handled in
2188          * tls_check_client_ems_support()
2189          */
2190
2191         /*
2192          * If this ClientHello extension was unhandled and this is a
2193          * nonresumed connection, check whether the extension is a custom
2194          * TLS Extension (has a custom_srv_ext_record), and if so call the
2195          * callback and record the extension number so that an appropriate
2196          * ServerHello may be later returned.
2197          */
2198         else if (!s->hit) {
2199             if (custom_ext_parse(s, 1, currext->type,
2200                     PACKET_data(&currext->data),
2201                     PACKET_remaining(&currext->data), al) <= 0)
2202                 return 0;
2203         }
2204     }
2205
2206     /* Need RI if renegotiating */
2207
2208     if (!renegotiate_seen && s->renegotiate &&
2209         !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)) {
2210         *al = SSL_AD_HANDSHAKE_FAILURE;
2211         SSLerr(SSL_F_SSL_SCAN_CLIENTHELLO_TLSEXT,
2212                SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
2213         return 0;
2214     }
2215
2216     /*
2217      * This function currently has no state to clean up, so it returns directly.
2218      * If parsing fails at any point, the function returns early.
2219      * The SSL object may be left with partial data from extensions, but it must
2220      * then no longer be used, and clearing it up will free the leftovers.
2221      */
2222     return 1;
2223 }
2224
2225 int ssl_parse_clienthello_tlsext(SSL *s, CLIENTHELLO_MSG *hello)
2226 {
2227     int al = -1;
2228     custom_ext_init(&s->cert->srv_ext);
2229     if (ssl_scan_clienthello_tlsext(s, hello, &al) <= 0) {
2230         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2231         return 0;
2232     }
2233     if (ssl_check_clienthello_tlsext_early(s) <= 0) {
2234         SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_TLSEXT, SSL_R_CLIENTHELLO_TLSEXT);
2235         return 0;
2236     }
2237     return 1;
2238 }
2239
2240 #ifndef OPENSSL_NO_NEXTPROTONEG
2241 /*
2242  * ssl_next_proto_validate validates a Next Protocol Negotiation block. No
2243  * elements of zero length are allowed and the set of elements must exactly
2244  * fill the length of the block.
2245  */
2246 static char ssl_next_proto_validate(PACKET *pkt)
2247 {
2248     PACKET tmp_protocol;
2249
2250     while (PACKET_remaining(pkt)) {
2251         if (!PACKET_get_length_prefixed_1(pkt, &tmp_protocol)
2252             || PACKET_remaining(&tmp_protocol) == 0)
2253             return 0;
2254     }
2255
2256     return 1;
2257 }
2258 #endif
2259
2260 static int ssl_scan_serverhello_tlsext(SSL *s, PACKET *pkt, int *al)
2261 {
2262     unsigned int length, type, size;
2263     int tlsext_servername = 0;
2264     int renegotiate_seen = 0;
2265
2266 #ifndef OPENSSL_NO_NEXTPROTONEG
2267     s->s3->next_proto_neg_seen = 0;
2268 #endif
2269     s->tlsext_ticket_expected = 0;
2270
2271     OPENSSL_free(s->s3->alpn_selected);
2272     s->s3->alpn_selected = NULL;
2273 #ifndef OPENSSL_NO_HEARTBEATS
2274     s->tlsext_heartbeat &= ~(SSL_DTLSEXT_HB_ENABLED |
2275                              SSL_DTLSEXT_HB_DONT_SEND_REQUESTS);
2276 #endif
2277
2278     s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
2279
2280     s->s3->flags &= ~TLS1_FLAGS_RECEIVED_EXTMS;
2281
2282     if (!PACKET_get_net_2(pkt, &length))
2283         goto ri_check;
2284
2285     if (PACKET_remaining(pkt) != length) {
2286         *al = SSL_AD_DECODE_ERROR;
2287         return 0;
2288     }
2289
2290     if (!tls1_check_duplicate_extensions(pkt)) {
2291         *al = SSL_AD_DECODE_ERROR;
2292         return 0;
2293     }
2294
2295     while (PACKET_get_net_2(pkt, &type) && PACKET_get_net_2(pkt, &size)) {
2296         const unsigned char *data;
2297         PACKET spkt;
2298
2299         if (!PACKET_get_sub_packet(pkt, &spkt, size)
2300             || !PACKET_peek_bytes(&spkt, &data, size))
2301             goto ri_check;
2302
2303         if (s->tlsext_debug_cb)
2304             s->tlsext_debug_cb(s, 1, type, data, size, s->tlsext_debug_arg);
2305
2306         if (type == TLSEXT_TYPE_renegotiate) {
2307             if (!ssl_parse_serverhello_renegotiate_ext(s, &spkt, al))
2308                 return 0;
2309             renegotiate_seen = 1;
2310         } else if (s->version == SSL3_VERSION) {
2311         } else if (type == TLSEXT_TYPE_server_name) {
2312             if (s->tlsext_hostname == NULL || size > 0) {
2313                 *al = TLS1_AD_UNRECOGNIZED_NAME;
2314                 return 0;
2315             }
2316             tlsext_servername = 1;
2317         }
2318 #ifndef OPENSSL_NO_EC
2319         else if (type == TLSEXT_TYPE_ec_point_formats) {
2320             unsigned int ecpointformatlist_length;
2321             if (!PACKET_get_1(&spkt, &ecpointformatlist_length)
2322                 || ecpointformatlist_length != size - 1) {
2323                 *al = TLS1_AD_DECODE_ERROR;
2324                 return 0;
2325             }
2326             if (!s->hit) {
2327                 s->session->tlsext_ecpointformatlist_length = 0;
2328                 OPENSSL_free(s->session->tlsext_ecpointformatlist);
2329                 if ((s->session->tlsext_ecpointformatlist =
2330                      OPENSSL_malloc(ecpointformatlist_length)) == NULL) {
2331                     *al = TLS1_AD_INTERNAL_ERROR;
2332                     return 0;
2333                 }
2334                 s->session->tlsext_ecpointformatlist_length =
2335                     ecpointformatlist_length;
2336                 if (!PACKET_copy_bytes(&spkt,
2337                                        s->session->tlsext_ecpointformatlist,
2338                                        ecpointformatlist_length)) {
2339                     *al = TLS1_AD_DECODE_ERROR;
2340                     return 0;
2341                 }
2342
2343             }
2344         }
2345 #endif                          /* OPENSSL_NO_EC */
2346
2347         else if (type == TLSEXT_TYPE_session_ticket) {
2348             if (s->tls_session_ticket_ext_cb &&
2349                 !s->tls_session_ticket_ext_cb(s, data, size,
2350                                               s->tls_session_ticket_ext_cb_arg))
2351             {
2352                 *al = TLS1_AD_INTERNAL_ERROR;
2353                 return 0;
2354             }
2355             if (!tls_use_ticket(s) || (size > 0)) {
2356                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
2357                 return 0;
2358             }
2359             s->tlsext_ticket_expected = 1;
2360         } else if (type == TLSEXT_TYPE_status_request) {
2361             /*
2362              * MUST be empty and only sent if we've requested a status
2363              * request message.
2364              */
2365             if ((s->tlsext_status_type == -1) || (size > 0)) {
2366                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
2367                 return 0;
2368             }
2369             /* Set flag to expect CertificateStatus message */
2370             s->tlsext_status_expected = 1;
2371         }
2372 #ifndef OPENSSL_NO_CT
2373         /*
2374          * Only take it if we asked for it - i.e if there is no CT validation
2375          * callback set, then a custom extension MAY be processing it, so we
2376          * need to let control continue to flow to that.
2377          */
2378         else if (type == TLSEXT_TYPE_signed_certificate_timestamp &&
2379                  s->ct_validation_callback != NULL) {
2380             /* Simply copy it off for later processing */
2381             if (s->tlsext_scts != NULL) {
2382                 OPENSSL_free(s->tlsext_scts);
2383                 s->tlsext_scts = NULL;
2384             }
2385             s->tlsext_scts_len = size;
2386             if (size > 0) {
2387                 s->tlsext_scts = OPENSSL_malloc(size);
2388                 if (s->tlsext_scts == NULL) {
2389                     *al = TLS1_AD_INTERNAL_ERROR;
2390                     return 0;
2391                 }
2392                 memcpy(s->tlsext_scts, data, size);
2393             }
2394         }
2395 #endif
2396 #ifndef OPENSSL_NO_NEXTPROTONEG
2397         else if (type == TLSEXT_TYPE_next_proto_neg &&
2398                  s->s3->tmp.finish_md_len == 0) {
2399             unsigned char *selected;
2400             unsigned char selected_len;
2401             /* We must have requested it. */
2402             if (s->ctx->next_proto_select_cb == NULL) {
2403                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
2404                 return 0;
2405             }
2406             /* The data must be valid */
2407             if (!ssl_next_proto_validate(&spkt)) {
2408                 *al = TLS1_AD_DECODE_ERROR;
2409                 return 0;
2410             }
2411             if (s->ctx->next_proto_select_cb(s, &selected, &selected_len, data,
2412                                              size,
2413                                              s->
2414                                              ctx->next_proto_select_cb_arg) !=
2415                 SSL_TLSEXT_ERR_OK) {
2416                 *al = TLS1_AD_INTERNAL_ERROR;
2417                 return 0;
2418             }
2419             /*
2420              * Could be non-NULL if server has sent multiple NPN extensions in
2421              * a single Serverhello
2422              */
2423             OPENSSL_free(s->next_proto_negotiated);
2424             s->next_proto_negotiated = OPENSSL_malloc(selected_len);
2425             if (s->next_proto_negotiated == NULL) {
2426                 *al = TLS1_AD_INTERNAL_ERROR;
2427                 return 0;
2428             }
2429             memcpy(s->next_proto_negotiated, selected, selected_len);
2430             s->next_proto_negotiated_len = selected_len;
2431             s->s3->next_proto_neg_seen = 1;
2432         }
2433 #endif
2434
2435         else if (type == TLSEXT_TYPE_application_layer_protocol_negotiation) {
2436             unsigned len;
2437             /* We must have requested it. */
2438             if (!s->s3->alpn_sent) {
2439                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
2440                 return 0;
2441             }
2442             /*-
2443              * The extension data consists of:
2444              *   uint16 list_length
2445              *   uint8 proto_length;
2446              *   uint8 proto[proto_length];
2447              */
2448             if (!PACKET_get_net_2(&spkt, &len)
2449                 || PACKET_remaining(&spkt) != len || !PACKET_get_1(&spkt, &len)
2450                 || PACKET_remaining(&spkt) != len) {
2451                 *al = TLS1_AD_DECODE_ERROR;
2452                 return 0;
2453             }
2454             OPENSSL_free(s->s3->alpn_selected);
2455             s->s3->alpn_selected = OPENSSL_malloc(len);
2456             if (s->s3->alpn_selected == NULL) {
2457                 *al = TLS1_AD_INTERNAL_ERROR;
2458                 return 0;
2459             }
2460             if (!PACKET_copy_bytes(&spkt, s->s3->alpn_selected, len)) {
2461                 *al = TLS1_AD_DECODE_ERROR;
2462                 return 0;
2463             }
2464             s->s3->alpn_selected_len = len;
2465         }
2466 #ifndef OPENSSL_NO_HEARTBEATS
2467         else if (SSL_IS_DTLS(s) && type == TLSEXT_TYPE_heartbeat) {
2468             unsigned int hbtype;
2469             if (!PACKET_get_1(&spkt, &hbtype)) {
2470                 *al = SSL_AD_DECODE_ERROR;
2471                 return 0;
2472             }
2473             switch (hbtype) {
2474             case 0x01:         /* Server allows us to send HB requests */
2475                 s->tlsext_heartbeat |= SSL_DTLSEXT_HB_ENABLED;
2476                 break;
2477             case 0x02:         /* Server doesn't accept HB requests */
2478                 s->tlsext_heartbeat |= SSL_DTLSEXT_HB_ENABLED;
2479                 s->tlsext_heartbeat |= SSL_DTLSEXT_HB_DONT_SEND_REQUESTS;
2480                 break;
2481             default:
2482                 *al = SSL_AD_ILLEGAL_PARAMETER;
2483                 return 0;
2484             }
2485         }
2486 #endif
2487 #ifndef OPENSSL_NO_SRTP
2488         else if (SSL_IS_DTLS(s) && type == TLSEXT_TYPE_use_srtp) {
2489             if (ssl_parse_serverhello_use_srtp_ext(s, &spkt, al))
2490                 return 0;
2491         }
2492 #endif
2493         else if (type == TLSEXT_TYPE_encrypt_then_mac) {
2494             /* Ignore if inappropriate ciphersuite */
2495             if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC) &&
2496                 s->s3->tmp.new_cipher->algorithm_mac != SSL_AEAD
2497                 && s->s3->tmp.new_cipher->algorithm_enc != SSL_RC4)
2498                 s->s3->flags |= TLS1_FLAGS_ENCRYPT_THEN_MAC;
2499         } else if (type == TLSEXT_TYPE_extended_master_secret) {
2500             s->s3->flags |= TLS1_FLAGS_RECEIVED_EXTMS;
2501             if (!s->hit)
2502                 s->session->flags |= SSL_SESS_FLAG_EXTMS;
2503         }
2504         /*
2505          * If this extension type was not otherwise handled, but matches a
2506          * custom_cli_ext_record, then send it to the c callback
2507          */
2508         else if (custom_ext_parse(s, 0, type, data, size, al) <= 0)
2509             return 0;
2510     }
2511
2512     if (PACKET_remaining(pkt) != 0) {
2513         *al = SSL_AD_DECODE_ERROR;
2514         return 0;
2515     }
2516
2517     if (!s->hit && tlsext_servername == 1) {
2518         if (s->tlsext_hostname) {
2519             if (s->session->tlsext_hostname == NULL) {
2520                 s->session->tlsext_hostname =
2521                     OPENSSL_strdup(s->tlsext_hostname);
2522                 if (!s->session->tlsext_hostname) {
2523                     *al = SSL_AD_UNRECOGNIZED_NAME;
2524                     return 0;
2525                 }
2526             } else {
2527                 *al = SSL_AD_DECODE_ERROR;
2528                 return 0;
2529             }
2530         }
2531     }
2532
2533  ri_check:
2534
2535     /*
2536      * Determine if we need to see RI. Strictly speaking if we want to avoid
2537      * an attack we should *always* see RI even on initial server hello
2538      * because the client doesn't see any renegotiation during an attack.
2539      * However this would mean we could not connect to any server which
2540      * doesn't support RI so for the immediate future tolerate RI absence
2541      */
2542     if (!renegotiate_seen && !(s->options & SSL_OP_LEGACY_SERVER_CONNECT)
2543         && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)) {
2544         *al = SSL_AD_HANDSHAKE_FAILURE;
2545         SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT,
2546                SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
2547         return 0;
2548     }
2549
2550     if (s->hit) {
2551         /*
2552          * Check extended master secret extension is consistent with
2553          * original session.
2554          */
2555         if (!(s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) !=
2556             !(s->session->flags & SSL_SESS_FLAG_EXTMS)) {
2557             *al = SSL_AD_HANDSHAKE_FAILURE;
2558             SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT, SSL_R_INCONSISTENT_EXTMS);
2559             return 0;
2560         }
2561     }
2562
2563     return 1;
2564 }
2565
2566 int ssl_prepare_clienthello_tlsext(SSL *s)
2567 {
2568     s->s3->alpn_sent = 0;
2569     return 1;
2570 }
2571
2572 int ssl_prepare_serverhello_tlsext(SSL *s)
2573 {
2574     return 1;
2575 }
2576
2577 static int ssl_check_clienthello_tlsext_early(SSL *s)
2578 {
2579     int ret = SSL_TLSEXT_ERR_NOACK;
2580     int al = SSL_AD_UNRECOGNIZED_NAME;
2581
2582 #ifndef OPENSSL_NO_EC
2583     /*
2584      * The handling of the ECPointFormats extension is done elsewhere, namely
2585      * in ssl3_choose_cipher in s3_lib.c.
2586      */
2587     /*
2588      * The handling of the EllipticCurves extension is done elsewhere, namely
2589      * in ssl3_choose_cipher in s3_lib.c.
2590      */
2591 #endif
2592
2593     if (s->ctx != NULL && s->ctx->tlsext_servername_callback != 0)
2594         ret =
2595             s->ctx->tlsext_servername_callback(s, &al,
2596                                                s->ctx->tlsext_servername_arg);
2597     else if (s->initial_ctx != NULL
2598              && s->initial_ctx->tlsext_servername_callback != 0)
2599         ret =
2600             s->initial_ctx->tlsext_servername_callback(s, &al,
2601                                                        s->
2602                                                        initial_ctx->tlsext_servername_arg);
2603
2604     switch (ret) {
2605     case SSL_TLSEXT_ERR_ALERT_FATAL:
2606         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2607         return -1;
2608
2609     case SSL_TLSEXT_ERR_ALERT_WARNING:
2610         ssl3_send_alert(s, SSL3_AL_WARNING, al);
2611         return 1;
2612
2613     case SSL_TLSEXT_ERR_NOACK:
2614         s->servername_done = 0;
2615     default:
2616         return 1;
2617     }
2618 }
2619
2620 /* Initialise digests to default values */
2621 void ssl_set_default_md(SSL *s)
2622 {
2623     const EVP_MD **pmd = s->s3->tmp.md;
2624 #ifndef OPENSSL_NO_DSA
2625     pmd[SSL_PKEY_DSA_SIGN] = ssl_md(SSL_MD_SHA1_IDX);
2626 #endif
2627 #ifndef OPENSSL_NO_RSA
2628     if (SSL_USE_SIGALGS(s))
2629         pmd[SSL_PKEY_RSA_SIGN] = ssl_md(SSL_MD_SHA1_IDX);
2630     else
2631         pmd[SSL_PKEY_RSA_SIGN] = ssl_md(SSL_MD_MD5_SHA1_IDX);
2632     pmd[SSL_PKEY_RSA_ENC] = pmd[SSL_PKEY_RSA_SIGN];
2633 #endif
2634 #ifndef OPENSSL_NO_EC
2635     pmd[SSL_PKEY_ECC] = ssl_md(SSL_MD_SHA1_IDX);
2636 #endif
2637 #ifndef OPENSSL_NO_GOST
2638     pmd[SSL_PKEY_GOST01] = ssl_md(SSL_MD_GOST94_IDX);
2639     pmd[SSL_PKEY_GOST12_256] = ssl_md(SSL_MD_GOST12_256_IDX);
2640     pmd[SSL_PKEY_GOST12_512] = ssl_md(SSL_MD_GOST12_512_IDX);
2641 #endif
2642 }
2643
2644 int tls1_set_server_sigalgs(SSL *s)
2645 {
2646     int al;
2647     size_t i;
2648
2649     /* Clear any shared signature algorithms */
2650     OPENSSL_free(s->cert->shared_sigalgs);
2651     s->cert->shared_sigalgs = NULL;
2652     s->cert->shared_sigalgslen = 0;
2653     /* Clear certificate digests and validity flags */
2654     for (i = 0; i < SSL_PKEY_NUM; i++) {
2655         s->s3->tmp.md[i] = NULL;
2656         s->s3->tmp.valid_flags[i] = 0;
2657     }
2658
2659     /* If sigalgs received process it. */
2660     if (s->s3->tmp.peer_sigalgs) {
2661         if (!tls1_process_sigalgs(s)) {
2662             SSLerr(SSL_F_TLS1_SET_SERVER_SIGALGS, ERR_R_MALLOC_FAILURE);
2663             al = SSL_AD_INTERNAL_ERROR;
2664             goto err;
2665         }
2666         /* Fatal error is no shared signature algorithms */
2667         if (!s->cert->shared_sigalgs) {
2668             SSLerr(SSL_F_TLS1_SET_SERVER_SIGALGS,
2669                    SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS);
2670             al = SSL_AD_ILLEGAL_PARAMETER;
2671             goto err;
2672         }
2673     } else {
2674         ssl_set_default_md(s);
2675     }
2676     return 1;
2677  err:
2678     ssl3_send_alert(s, SSL3_AL_FATAL, al);
2679     return 0;
2680 }
2681
2682 /*
2683  * Upon success, returns 1.
2684  * Upon failure, returns 0 and sets |al| to the appropriate fatal alert.
2685  */
2686 int ssl_check_clienthello_tlsext_late(SSL *s, int *al)
2687 {
2688     s->tlsext_status_expected = 0;
2689
2690     /*
2691      * If status request then ask callback what to do. Note: this must be
2692      * called after servername callbacks in case the certificate has changed,
2693      * and must be called after the cipher has been chosen because this may
2694      * influence which certificate is sent
2695      */
2696     if ((s->tlsext_status_type != -1) && s->ctx && s->ctx->tlsext_status_cb) {
2697         int ret;
2698         CERT_PKEY *certpkey;
2699         certpkey = ssl_get_server_send_pkey(s);
2700         /* If no certificate can't return certificate status */
2701         if (certpkey != NULL) {
2702             /*
2703              * Set current certificate to one we will use so SSL_get_certificate
2704              * et al can pick it up.
2705              */
2706             s->cert->key = certpkey;
2707             ret = s->ctx->tlsext_status_cb(s, s->ctx->tlsext_status_arg);
2708             switch (ret) {
2709                 /* We don't want to send a status request response */
2710             case SSL_TLSEXT_ERR_NOACK:
2711                 s->tlsext_status_expected = 0;
2712                 break;
2713                 /* status request response should be sent */
2714             case SSL_TLSEXT_ERR_OK:
2715                 if (s->tlsext_ocsp_resp)
2716                     s->tlsext_status_expected = 1;
2717                 break;
2718                 /* something bad happened */
2719             case SSL_TLSEXT_ERR_ALERT_FATAL:
2720             default:
2721                 *al = SSL_AD_INTERNAL_ERROR;
2722                 return 0;
2723             }
2724         }
2725     }
2726
2727     if (!tls1_alpn_handle_client_hello_late(s, al)) {
2728         return 0;
2729     }
2730
2731     return 1;
2732 }
2733
2734 int ssl_check_serverhello_tlsext(SSL *s)
2735 {
2736     int ret = SSL_TLSEXT_ERR_NOACK;
2737     int al = SSL_AD_UNRECOGNIZED_NAME;
2738
2739 #ifndef OPENSSL_NO_EC
2740     /*
2741      * If we are client and using an elliptic curve cryptography cipher
2742      * suite, then if server returns an EC point formats lists extension it
2743      * must contain uncompressed.
2744      */
2745     unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
2746     unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
2747     if ((s->tlsext_ecpointformatlist != NULL)
2748         && (s->tlsext_ecpointformatlist_length > 0)
2749         && (s->session->tlsext_ecpointformatlist != NULL)
2750         && (s->session->tlsext_ecpointformatlist_length > 0)
2751         && ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))) {
2752         /* we are using an ECC cipher */
2753         size_t i;
2754         unsigned char *list;
2755         int found_uncompressed = 0;
2756         list = s->session->tlsext_ecpointformatlist;
2757         for (i = 0; i < s->session->tlsext_ecpointformatlist_length; i++) {
2758             if (*(list++) == TLSEXT_ECPOINTFORMAT_uncompressed) {
2759                 found_uncompressed = 1;
2760                 break;
2761             }
2762         }
2763         if (!found_uncompressed) {
2764             SSLerr(SSL_F_SSL_CHECK_SERVERHELLO_TLSEXT,
2765                    SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST);
2766             return -1;
2767         }
2768     }
2769     ret = SSL_TLSEXT_ERR_OK;
2770 #endif                          /* OPENSSL_NO_EC */
2771
2772     if (s->ctx != NULL && s->ctx->tlsext_servername_callback != 0)
2773         ret =
2774             s->ctx->tlsext_servername_callback(s, &al,
2775                                                s->ctx->tlsext_servername_arg);
2776     else if (s->initial_ctx != NULL
2777              && s->initial_ctx->tlsext_servername_callback != 0)
2778         ret =
2779             s->initial_ctx->tlsext_servername_callback(s, &al,
2780                                                        s->
2781                                                        initial_ctx->tlsext_servername_arg);
2782
2783     /*
2784      * Ensure we get sensible values passed to tlsext_status_cb in the event
2785      * that we don't receive a status message
2786      */
2787     OPENSSL_free(s->tlsext_ocsp_resp);
2788     s->tlsext_ocsp_resp = NULL;
2789     s->tlsext_ocsp_resplen = 0;
2790
2791     switch (ret) {
2792     case SSL_TLSEXT_ERR_ALERT_FATAL:
2793         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2794         return -1;
2795
2796     case SSL_TLSEXT_ERR_ALERT_WARNING:
2797         ssl3_send_alert(s, SSL3_AL_WARNING, al);
2798         return 1;
2799
2800     case SSL_TLSEXT_ERR_NOACK:
2801         s->servername_done = 0;
2802     default:
2803         return 1;
2804     }
2805 }
2806
2807 int ssl_parse_serverhello_tlsext(SSL *s, PACKET *pkt)
2808 {
2809     int al = -1;
2810     if (s->version < SSL3_VERSION)
2811         return 1;
2812     if (ssl_scan_serverhello_tlsext(s, pkt, &al) <= 0) {
2813         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2814         return 0;
2815     }
2816
2817     if (ssl_check_serverhello_tlsext(s) <= 0) {
2818         SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_TLSEXT, SSL_R_SERVERHELLO_TLSEXT);
2819         return 0;
2820     }
2821     return 1;
2822 }
2823
2824 /*
2825  * Given a list of extensions that we collected earlier, find one of a given
2826  * type and return it.
2827  *
2828  * |exts| is the set of extensions previously collected.
2829  * |numexts| is the number of extensions that we have.
2830  * |type| the type of the extension that we are looking for.
2831  *
2832  * Returns a pointer to the found RAW_EXTENSION data, or NULL if not found.
2833  */
2834 RAW_EXTENSION *tls_get_extension_by_type(RAW_EXTENSION *exts, size_t numexts,
2835                                          unsigned int type)
2836 {
2837     size_t loop;
2838
2839     for (loop = 0; loop < numexts; loop++) {
2840         if (exts[loop].type == type)
2841             return &exts[loop];
2842     }
2843
2844     return NULL;
2845 }
2846
2847 /*-
2848  * Gets the ticket information supplied by the client if any.
2849  *
2850  *   hello: The parsed ClientHello data
2851  *   ret: (output) on return, if a ticket was decrypted, then this is set to
2852  *       point to the resulting session.
2853  *
2854  * If s->tls_session_secret_cb is set then we are expecting a pre-shared key
2855  * ciphersuite, in which case we have no use for session tickets and one will
2856  * never be decrypted, nor will s->tlsext_ticket_expected be set to 1.
2857  *
2858  * Returns:
2859  *   -1: fatal error, either from parsing or decrypting the ticket.
2860  *    0: no ticket was found (or was ignored, based on settings).
2861  *    1: a zero length extension was found, indicating that the client supports
2862  *       session tickets but doesn't currently have one to offer.
2863  *    2: either s->tls_session_secret_cb was set, or a ticket was offered but
2864  *       couldn't be decrypted because of a non-fatal error.
2865  *    3: a ticket was successfully decrypted and *ret was set.
2866  *
2867  * Side effects:
2868  *   Sets s->tlsext_ticket_expected to 1 if the server will have to issue
2869  *   a new session ticket to the client because the client indicated support
2870  *   (and s->tls_session_secret_cb is NULL) but the client either doesn't have
2871  *   a session ticket or we couldn't use the one it gave us, or if
2872  *   s->ctx->tlsext_ticket_key_cb asked to renew the client's ticket.
2873  *   Otherwise, s->tlsext_ticket_expected is set to 0.
2874  */
2875 int tls_get_ticket_from_client(SSL *s, CLIENTHELLO_MSG *hello,
2876                                SSL_SESSION **ret)
2877 {
2878     int retv;
2879     const unsigned char *etick;
2880     size_t size;
2881     RAW_EXTENSION *ticketext;
2882
2883     *ret = NULL;
2884     s->tlsext_ticket_expected = 0;
2885
2886     /*
2887      * If tickets disabled behave as if no ticket present to permit stateful
2888      * resumption.
2889      */
2890     if (s->version <= SSL3_VERSION || !tls_use_ticket(s))
2891         return 0;
2892
2893     ticketext = tls_get_extension_by_type(hello->pre_proc_exts,
2894                                           hello->num_extensions,
2895                                           TLSEXT_TYPE_session_ticket);
2896     if (ticketext == NULL)
2897         return 0;
2898
2899     size = PACKET_remaining(&ticketext->data);
2900     if (size == 0) {
2901         /*
2902          * The client will accept a ticket but doesn't currently have
2903          * one.
2904          */
2905         s->tlsext_ticket_expected = 1;
2906         return 1;
2907     }
2908     if (s->tls_session_secret_cb) {
2909         /*
2910          * Indicate that the ticket couldn't be decrypted rather than
2911          * generating the session from ticket now, trigger
2912          * abbreviated handshake based on external mechanism to
2913          * calculate the master secret later.
2914          */
2915         return 2;
2916     }
2917     if (!PACKET_get_bytes(&ticketext->data, &etick, size)) {
2918         /* Shouldn't ever happen */
2919         return -1;
2920     }
2921     retv = tls_decrypt_ticket(s, etick, size, hello->session_id,
2922                            hello->session_id_len, ret);
2923     switch (retv) {
2924     case 2:            /* ticket couldn't be decrypted */
2925         s->tlsext_ticket_expected = 1;
2926         return 2;
2927
2928     case 3:            /* ticket was decrypted */
2929         return 3;
2930
2931     case 4:            /* ticket decrypted but need to renew */
2932         s->tlsext_ticket_expected = 1;
2933         return 3;
2934
2935     default:           /* fatal error */
2936         return -1;
2937     }
2938 }
2939
2940 /*
2941  * Sets the extended master secret flag if the extension is present in the
2942  * ClientHello
2943  * Returns:
2944  *  1 on success
2945  *  0 on error
2946  */
2947 int tls_check_client_ems_support(SSL *s, const CLIENTHELLO_MSG *hello)
2948 {
2949     RAW_EXTENSION *emsext;
2950
2951     s->s3->flags &= ~TLS1_FLAGS_RECEIVED_EXTMS;
2952
2953     if (s->version <= SSL3_VERSION)
2954         return 1;
2955
2956     emsext = tls_get_extension_by_type(hello->pre_proc_exts,
2957                                        hello->num_extensions,
2958                                        TLSEXT_TYPE_extended_master_secret);
2959
2960     /*
2961      * No extensions is a success - we have successfully discovered that the
2962      * client doesn't support EMS.
2963      */
2964     if (emsext == NULL)
2965         return 1;
2966
2967     /* The extensions must always be empty */
2968     if (PACKET_remaining(&emsext->data) != 0)
2969         return 0;
2970
2971     s->s3->flags |= TLS1_FLAGS_RECEIVED_EXTMS;
2972
2973     return 1;
2974 }
2975
2976 /*-
2977  * tls_decrypt_ticket attempts to decrypt a session ticket.
2978  *
2979  *   etick: points to the body of the session ticket extension.
2980  *   eticklen: the length of the session tickets extension.
2981  *   sess_id: points at the session ID.
2982  *   sesslen: the length of the session ID.
2983  *   psess: (output) on return, if a ticket was decrypted, then this is set to
2984  *       point to the resulting session.
2985  *
2986  * Returns:
2987  *   -2: fatal error, malloc failure.
2988  *   -1: fatal error, either from parsing or decrypting the ticket.
2989  *    2: the ticket couldn't be decrypted.
2990  *    3: a ticket was successfully decrypted and *psess was set.
2991  *    4: same as 3, but the ticket needs to be renewed.
2992  */
2993 static int tls_decrypt_ticket(SSL *s, const unsigned char *etick,
2994                               size_t eticklen, const unsigned char *sess_id,
2995                               size_t sesslen, SSL_SESSION **psess)
2996 {
2997     SSL_SESSION *sess;
2998     unsigned char *sdec;
2999     const unsigned char *p;
3000     int slen, renew_ticket = 0, ret = -1, declen;
3001     size_t mlen;
3002     unsigned char tick_hmac[EVP_MAX_MD_SIZE];
3003     HMAC_CTX *hctx = NULL;
3004     EVP_CIPHER_CTX *ctx;
3005     SSL_CTX *tctx = s->initial_ctx;
3006
3007     /* Initialize session ticket encryption and HMAC contexts */
3008     hctx = HMAC_CTX_new();
3009     if (hctx == NULL)
3010         return -2;
3011     ctx = EVP_CIPHER_CTX_new();
3012     if (ctx == NULL) {
3013         ret = -2;
3014         goto err;
3015     }
3016     if (tctx->tlsext_ticket_key_cb) {
3017         unsigned char *nctick = (unsigned char *)etick;
3018         int rv = tctx->tlsext_ticket_key_cb(s, nctick, nctick + 16,
3019                                             ctx, hctx, 0);
3020         if (rv < 0)
3021             goto err;
3022         if (rv == 0) {
3023             ret = 2;
3024             goto err;
3025         }
3026         if (rv == 2)
3027             renew_ticket = 1;
3028     } else {
3029         /* Check key name matches */
3030         if (memcmp(etick, tctx->tlsext_tick_key_name,
3031                    sizeof(tctx->tlsext_tick_key_name)) != 0) {
3032             ret = 2;
3033             goto err;
3034         }
3035         if (HMAC_Init_ex(hctx, tctx->tlsext_tick_hmac_key,
3036                          sizeof(tctx->tlsext_tick_hmac_key),
3037                          EVP_sha256(), NULL) <= 0
3038             || EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL,
3039                                   tctx->tlsext_tick_aes_key,
3040                                   etick + sizeof(tctx->tlsext_tick_key_name)) <=
3041             0) {
3042             goto err;
3043         }
3044     }
3045     /*
3046      * Attempt to process session ticket, first conduct sanity and integrity
3047      * checks on ticket.
3048      */
3049     mlen = HMAC_size(hctx);
3050     if (mlen == 0) {
3051         goto err;
3052     }
3053     /* Sanity check ticket length: must exceed keyname + IV + HMAC */
3054     if (eticklen <=
3055         TLSEXT_KEYNAME_LENGTH + EVP_CIPHER_CTX_iv_length(ctx) + mlen) {
3056         ret = 2;
3057         goto err;
3058     }
3059     eticklen -= mlen;
3060     /* Check HMAC of encrypted ticket */
3061     if (HMAC_Update(hctx, etick, eticklen) <= 0
3062         || HMAC_Final(hctx, tick_hmac, NULL) <= 0) {
3063         goto err;
3064     }
3065     HMAC_CTX_free(hctx);
3066     if (CRYPTO_memcmp(tick_hmac, etick + eticklen, mlen)) {
3067         EVP_CIPHER_CTX_free(ctx);
3068         return 2;
3069     }
3070     /* Attempt to decrypt session data */
3071     /* Move p after IV to start of encrypted ticket, update length */
3072     p = etick + 16 + EVP_CIPHER_CTX_iv_length(ctx);
3073     eticklen -= 16 + EVP_CIPHER_CTX_iv_length(ctx);
3074     sdec = OPENSSL_malloc(eticklen);
3075     if (sdec == NULL || EVP_DecryptUpdate(ctx, sdec, &slen, p,
3076                                           (int)eticklen) <= 0) {
3077         EVP_CIPHER_CTX_free(ctx);
3078         OPENSSL_free(sdec);
3079         return -1;
3080     }
3081     if (EVP_DecryptFinal(ctx, sdec + slen, &declen) <= 0) {
3082         EVP_CIPHER_CTX_free(ctx);
3083         OPENSSL_free(sdec);
3084         return 2;
3085     }
3086     slen += declen;
3087     EVP_CIPHER_CTX_free(ctx);
3088     ctx = NULL;
3089     p = sdec;
3090
3091     sess = d2i_SSL_SESSION(NULL, &p, slen);
3092     OPENSSL_free(sdec);
3093     if (sess) {
3094         /*
3095          * The session ID, if non-empty, is used by some clients to detect
3096          * that the ticket has been accepted. So we copy it to the session
3097          * structure. If it is empty set length to zero as required by
3098          * standard.
3099          */
3100         if (sesslen)
3101             memcpy(sess->session_id, sess_id, sesslen);
3102         sess->session_id_length = sesslen;
3103         *psess = sess;
3104         if (renew_ticket)
3105             return 4;
3106         else
3107             return 3;
3108     }
3109     ERR_clear_error();
3110     /*
3111      * For session parse failure, indicate that we need to send a new ticket.
3112      */
3113     return 2;
3114  err:
3115     EVP_CIPHER_CTX_free(ctx);
3116     HMAC_CTX_free(hctx);
3117     return ret;
3118 }
3119
3120 /* Tables to translate from NIDs to TLS v1.2 ids */
3121
3122 typedef struct {
3123     int nid;
3124     int id;
3125 } tls12_lookup;
3126
3127 static const tls12_lookup tls12_md[] = {
3128     {NID_md5, TLSEXT_hash_md5},
3129     {NID_sha1, TLSEXT_hash_sha1},
3130     {NID_sha224, TLSEXT_hash_sha224},
3131     {NID_sha256, TLSEXT_hash_sha256},
3132     {NID_sha384, TLSEXT_hash_sha384},
3133     {NID_sha512, TLSEXT_hash_sha512},
3134     {NID_id_GostR3411_94, TLSEXT_hash_gostr3411},
3135     {NID_id_GostR3411_2012_256, TLSEXT_hash_gostr34112012_256},
3136     {NID_id_GostR3411_2012_512, TLSEXT_hash_gostr34112012_512},
3137 };
3138
3139 static const tls12_lookup tls12_sig[] = {
3140     {EVP_PKEY_RSA, TLSEXT_signature_rsa},
3141     {EVP_PKEY_DSA, TLSEXT_signature_dsa},
3142     {EVP_PKEY_EC, TLSEXT_signature_ecdsa},
3143     {NID_id_GostR3410_2001, TLSEXT_signature_gostr34102001},
3144     {NID_id_GostR3410_2012_256, TLSEXT_signature_gostr34102012_256},
3145     {NID_id_GostR3410_2012_512, TLSEXT_signature_gostr34102012_512}
3146 };
3147
3148 static int tls12_find_id(int nid, const tls12_lookup *table, size_t tlen)
3149 {
3150     size_t i;
3151     for (i = 0; i < tlen; i++) {
3152         if (table[i].nid == nid)
3153             return table[i].id;
3154     }
3155     return -1;
3156 }
3157
3158 static int tls12_find_nid(int id, const tls12_lookup *table, size_t tlen)
3159 {
3160     size_t i;
3161     for (i = 0; i < tlen; i++) {
3162         if ((table[i].id) == id)
3163             return table[i].nid;
3164     }
3165     return NID_undef;
3166 }
3167
3168 int tls12_get_sigandhash(WPACKET *pkt, const EVP_PKEY *pk, const EVP_MD *md)
3169 {
3170     int sig_id, md_id;
3171
3172     if (md == NULL)
3173         return 0;
3174     md_id = tls12_find_id(EVP_MD_type(md), tls12_md, OSSL_NELEM(tls12_md));
3175     if (md_id == -1)
3176         return 0;
3177     sig_id = tls12_get_sigid(pk);
3178     if (sig_id == -1)
3179         return 0;
3180     if (!WPACKET_put_bytes_u8(pkt, md_id) || !WPACKET_put_bytes_u8(pkt, sig_id))
3181         return 0;
3182
3183     return 1;
3184 }
3185
3186 int tls12_get_sigid(const EVP_PKEY *pk)
3187 {
3188     return tls12_find_id(EVP_PKEY_id(pk), tls12_sig, OSSL_NELEM(tls12_sig));
3189 }
3190
3191 typedef struct {
3192     int nid;
3193     int secbits;
3194     int md_idx;
3195     unsigned char tlsext_hash;
3196 } tls12_hash_info;
3197
3198 static const tls12_hash_info tls12_md_info[] = {
3199     {NID_md5, 64, SSL_MD_MD5_IDX, TLSEXT_hash_md5},
3200     {NID_sha1, 80, SSL_MD_SHA1_IDX, TLSEXT_hash_sha1},
3201     {NID_sha224, 112, SSL_MD_SHA224_IDX, TLSEXT_hash_sha224},
3202     {NID_sha256, 128, SSL_MD_SHA256_IDX, TLSEXT_hash_sha256},
3203     {NID_sha384, 192, SSL_MD_SHA384_IDX, TLSEXT_hash_sha384},
3204     {NID_sha512, 256, SSL_MD_SHA512_IDX, TLSEXT_hash_sha512},
3205     {NID_id_GostR3411_94, 128, SSL_MD_GOST94_IDX, TLSEXT_hash_gostr3411},
3206     {NID_id_GostR3411_2012_256, 128, SSL_MD_GOST12_256_IDX,
3207      TLSEXT_hash_gostr34112012_256},
3208     {NID_id_GostR3411_2012_512, 256, SSL_MD_GOST12_512_IDX,
3209      TLSEXT_hash_gostr34112012_512},
3210 };
3211
3212 static const tls12_hash_info *tls12_get_hash_info(unsigned char hash_alg)
3213 {
3214     unsigned int i;
3215     if (hash_alg == 0)
3216         return NULL;
3217
3218     for (i = 0; i < OSSL_NELEM(tls12_md_info); i++) {
3219         if (tls12_md_info[i].tlsext_hash == hash_alg)
3220             return tls12_md_info + i;
3221     }
3222
3223     return NULL;
3224 }
3225
3226 const EVP_MD *tls12_get_hash(unsigned char hash_alg)
3227 {
3228     const tls12_hash_info *inf;
3229     if (hash_alg == TLSEXT_hash_md5 && FIPS_mode())
3230         return NULL;
3231     inf = tls12_get_hash_info(hash_alg);
3232     if (!inf)
3233         return NULL;
3234     return ssl_md(inf->md_idx);
3235 }
3236
3237 static int tls12_get_pkey_idx(unsigned char sig_alg)
3238 {
3239     switch (sig_alg) {
3240 #ifndef OPENSSL_NO_RSA
3241     case TLSEXT_signature_rsa:
3242         return SSL_PKEY_RSA_SIGN;
3243 #endif
3244 #ifndef OPENSSL_NO_DSA
3245     case TLSEXT_signature_dsa:
3246         return SSL_PKEY_DSA_SIGN;
3247 #endif
3248 #ifndef OPENSSL_NO_EC
3249     case TLSEXT_signature_ecdsa:
3250         return SSL_PKEY_ECC;
3251 #endif
3252 #ifndef OPENSSL_NO_GOST
3253     case TLSEXT_signature_gostr34102001:
3254         return SSL_PKEY_GOST01;
3255
3256     case TLSEXT_signature_gostr34102012_256:
3257         return SSL_PKEY_GOST12_256;
3258
3259     case TLSEXT_signature_gostr34102012_512:
3260         return SSL_PKEY_GOST12_512;
3261 #endif
3262     }
3263     return -1;
3264 }
3265
3266 /* Convert TLS 1.2 signature algorithm extension values into NIDs */
3267 static void tls1_lookup_sigalg(int *phash_nid, int *psign_nid,
3268                                int *psignhash_nid, const unsigned char *data)
3269 {
3270     int sign_nid = NID_undef, hash_nid = NID_undef;
3271     if (!phash_nid && !psign_nid && !psignhash_nid)
3272         return;
3273     if (phash_nid || psignhash_nid) {
3274         hash_nid = tls12_find_nid(data[0], tls12_md, OSSL_NELEM(tls12_md));
3275         if (phash_nid)
3276             *phash_nid = hash_nid;
3277     }
3278     if (psign_nid || psignhash_nid) {
3279         sign_nid = tls12_find_nid(data[1], tls12_sig, OSSL_NELEM(tls12_sig));
3280         if (psign_nid)
3281             *psign_nid = sign_nid;
3282     }
3283     if (psignhash_nid) {
3284         if (sign_nid == NID_undef || hash_nid == NID_undef
3285             || OBJ_find_sigid_by_algs(psignhash_nid, hash_nid, sign_nid) <= 0)
3286             *psignhash_nid = NID_undef;
3287     }
3288 }
3289
3290 /* Check to see if a signature algorithm is allowed */
3291 static int tls12_sigalg_allowed(SSL *s, int op, const unsigned char *ptmp)
3292 {
3293     /* See if we have an entry in the hash table and it is enabled */
3294     const tls12_hash_info *hinf = tls12_get_hash_info(ptmp[0]);
3295     if (hinf == NULL || ssl_md(hinf->md_idx) == NULL)
3296         return 0;
3297     /* See if public key algorithm allowed */
3298     if (tls12_get_pkey_idx(ptmp[1]) == -1)
3299         return 0;
3300     /* Finally see if security callback allows it */
3301     return ssl_security(s, op, hinf->secbits, hinf->nid, (void *)ptmp);
3302 }
3303
3304 /*
3305  * Get a mask of disabled public key algorithms based on supported signature
3306  * algorithms. For example if no signature algorithm supports RSA then RSA is
3307  * disabled.
3308  */
3309
3310 void ssl_set_sig_mask(uint32_t *pmask_a, SSL *s, int op)
3311 {
3312     const unsigned char *sigalgs;
3313     size_t i, sigalgslen;
3314     int have_rsa = 0, have_dsa = 0, have_ecdsa = 0;
3315     /*
3316      * Now go through all signature algorithms seeing if we support any for
3317      * RSA, DSA, ECDSA. Do this for all versions not just TLS 1.2. To keep
3318      * down calls to security callback only check if we have to.
3319      */
3320     sigalgslen = tls12_get_psigalgs(s, &sigalgs);
3321     for (i = 0; i < sigalgslen; i += 2, sigalgs += 2) {
3322         switch (sigalgs[1]) {
3323 #ifndef OPENSSL_NO_RSA
3324         case TLSEXT_signature_rsa:
3325             if (!have_rsa && tls12_sigalg_allowed(s, op, sigalgs))
3326                 have_rsa = 1;
3327             break;
3328 #endif
3329 #ifndef OPENSSL_NO_DSA
3330         case TLSEXT_signature_dsa:
3331             if (!have_dsa && tls12_sigalg_allowed(s, op, sigalgs))
3332                 have_dsa = 1;
3333             break;
3334 #endif
3335 #ifndef OPENSSL_NO_EC
3336         case TLSEXT_signature_ecdsa:
3337             if (!have_ecdsa && tls12_sigalg_allowed(s, op, sigalgs))
3338                 have_ecdsa = 1;
3339             break;
3340 #endif
3341         }
3342     }
3343     if (!have_rsa)
3344         *pmask_a |= SSL_aRSA;
3345     if (!have_dsa)
3346         *pmask_a |= SSL_aDSS;
3347     if (!have_ecdsa)
3348         *pmask_a |= SSL_aECDSA;
3349 }
3350
3351 int tls12_copy_sigalgs(SSL *s, WPACKET *pkt,
3352                        const unsigned char *psig, size_t psiglen)
3353 {
3354     size_t i;
3355
3356     for (i = 0; i < psiglen; i += 2, psig += 2) {
3357         if (tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SUPPORTED, psig)) {
3358             if (!WPACKET_put_bytes_u8(pkt, psig[0])
3359                     || !WPACKET_put_bytes_u8(pkt, psig[1]))
3360                 return 0;
3361         }
3362     }
3363     return 1;
3364 }
3365
3366 /* Given preference and allowed sigalgs set shared sigalgs */
3367 static size_t tls12_shared_sigalgs(SSL *s, TLS_SIGALGS *shsig,
3368                                    const unsigned char *pref, size_t preflen,
3369                                    const unsigned char *allow, size_t allowlen)
3370 {
3371     const unsigned char *ptmp, *atmp;
3372     size_t i, j, nmatch = 0;
3373     for (i = 0, ptmp = pref; i < preflen; i += 2, ptmp += 2) {
3374         /* Skip disabled hashes or signature algorithms */
3375         if (!tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SHARED, ptmp))
3376             continue;
3377         for (j = 0, atmp = allow; j < allowlen; j += 2, atmp += 2) {
3378             if (ptmp[0] == atmp[0] && ptmp[1] == atmp[1]) {
3379                 nmatch++;
3380                 if (shsig) {
3381                     shsig->rhash = ptmp[0];
3382                     shsig->rsign = ptmp[1];
3383                     tls1_lookup_sigalg(&shsig->hash_nid,
3384                                        &shsig->sign_nid,
3385                                        &shsig->signandhash_nid, ptmp);
3386                     shsig++;
3387                 }
3388                 break;
3389             }
3390         }
3391     }
3392     return nmatch;
3393 }
3394
3395 /* Set shared signature algorithms for SSL structures */
3396 static int tls1_set_shared_sigalgs(SSL *s)
3397 {
3398     const unsigned char *pref, *allow, *conf;
3399     size_t preflen, allowlen, conflen;
3400     size_t nmatch;
3401     TLS_SIGALGS *salgs = NULL;
3402     CERT *c = s->cert;
3403     unsigned int is_suiteb = tls1_suiteb(s);
3404
3405     OPENSSL_free(c->shared_sigalgs);
3406     c->shared_sigalgs = NULL;
3407     c->shared_sigalgslen = 0;
3408     /* If client use client signature algorithms if not NULL */
3409     if (!s->server && c->client_sigalgs && !is_suiteb) {
3410         conf = c->client_sigalgs;
3411         conflen = c->client_sigalgslen;
3412     } else if (c->conf_sigalgs && !is_suiteb) {
3413         conf = c->conf_sigalgs;
3414         conflen = c->conf_sigalgslen;
3415     } else
3416         conflen = tls12_get_psigalgs(s, &conf);
3417     if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE || is_suiteb) {
3418         pref = conf;
3419         preflen = conflen;
3420         allow = s->s3->tmp.peer_sigalgs;
3421         allowlen = s->s3->tmp.peer_sigalgslen;
3422     } else {
3423         allow = conf;
3424         allowlen = conflen;
3425         pref = s->s3->tmp.peer_sigalgs;
3426         preflen = s->s3->tmp.peer_sigalgslen;
3427     }
3428     nmatch = tls12_shared_sigalgs(s, NULL, pref, preflen, allow, allowlen);
3429     if (nmatch) {
3430         salgs = OPENSSL_malloc(nmatch * sizeof(TLS_SIGALGS));
3431         if (salgs == NULL)
3432             return 0;
3433         nmatch = tls12_shared_sigalgs(s, salgs, pref, preflen, allow, allowlen);
3434     } else {
3435         salgs = NULL;
3436     }
3437     c->shared_sigalgs = salgs;
3438     c->shared_sigalgslen = nmatch;
3439     return 1;
3440 }
3441
3442 /* Set preferred digest for each key type */
3443
3444 int tls1_save_sigalgs(SSL *s, const unsigned char *data, size_t dsize)
3445 {
3446     CERT *c = s->cert;
3447     /* Extension ignored for inappropriate versions */
3448     if (!SSL_USE_SIGALGS(s))
3449         return 1;
3450     /* Should never happen */
3451     if (!c)
3452         return 0;
3453
3454     OPENSSL_free(s->s3->tmp.peer_sigalgs);
3455     s->s3->tmp.peer_sigalgs = OPENSSL_malloc(dsize);
3456     if (s->s3->tmp.peer_sigalgs == NULL)
3457         return 0;
3458     s->s3->tmp.peer_sigalgslen = dsize;
3459     memcpy(s->s3->tmp.peer_sigalgs, data, dsize);
3460     return 1;
3461 }
3462
3463 int tls1_process_sigalgs(SSL *s)
3464 {
3465     int idx;
3466     size_t i;
3467     const EVP_MD *md;
3468     const EVP_MD **pmd = s->s3->tmp.md;
3469     uint32_t *pvalid = s->s3->tmp.valid_flags;
3470     CERT *c = s->cert;
3471     TLS_SIGALGS *sigptr;
3472     if (!tls1_set_shared_sigalgs(s))
3473         return 0;
3474
3475     for (i = 0, sigptr = c->shared_sigalgs;
3476          i < c->shared_sigalgslen; i++, sigptr++) {
3477         idx = tls12_get_pkey_idx(sigptr->rsign);
3478         if (idx > 0 && pmd[idx] == NULL) {
3479             md = tls12_get_hash(sigptr->rhash);
3480             pmd[idx] = md;
3481             pvalid[idx] = CERT_PKEY_EXPLICIT_SIGN;
3482             if (idx == SSL_PKEY_RSA_SIGN) {
3483                 pvalid[SSL_PKEY_RSA_ENC] = CERT_PKEY_EXPLICIT_SIGN;
3484                 pmd[SSL_PKEY_RSA_ENC] = md;
3485             }
3486         }
3487
3488     }
3489     /*
3490      * In strict mode leave unset digests as NULL to indicate we can't use
3491      * the certificate for signing.
3492      */
3493     if (!(s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)) {
3494         /*
3495          * Set any remaining keys to default values. NOTE: if alg is not
3496          * supported it stays as NULL.
3497          */
3498 #ifndef OPENSSL_NO_DSA
3499         if (pmd[SSL_PKEY_DSA_SIGN] == NULL)
3500             pmd[SSL_PKEY_DSA_SIGN] = EVP_sha1();
3501 #endif
3502 #ifndef OPENSSL_NO_RSA
3503         if (pmd[SSL_PKEY_RSA_SIGN] == NULL) {
3504             pmd[SSL_PKEY_RSA_SIGN] = EVP_sha1();
3505             pmd[SSL_PKEY_RSA_ENC] = EVP_sha1();
3506         }
3507 #endif
3508 #ifndef OPENSSL_NO_EC
3509         if (pmd[SSL_PKEY_ECC] == NULL)
3510             pmd[SSL_PKEY_ECC] = EVP_sha1();
3511 #endif
3512 #ifndef OPENSSL_NO_GOST
3513         if (pmd[SSL_PKEY_GOST01] == NULL)
3514             pmd[SSL_PKEY_GOST01] = EVP_get_digestbynid(NID_id_GostR3411_94);
3515         if (pmd[SSL_PKEY_GOST12_256] == NULL)
3516             pmd[SSL_PKEY_GOST12_256] =
3517                 EVP_get_digestbynid(NID_id_GostR3411_2012_256);
3518         if (pmd[SSL_PKEY_GOST12_512] == NULL)
3519             pmd[SSL_PKEY_GOST12_512] =
3520                 EVP_get_digestbynid(NID_id_GostR3411_2012_512);
3521 #endif
3522     }
3523     return 1;
3524 }
3525
3526 int SSL_get_sigalgs(SSL *s, int idx,
3527                     int *psign, int *phash, int *psignhash,
3528                     unsigned char *rsig, unsigned char *rhash)
3529 {
3530     const unsigned char *psig = s->s3->tmp.peer_sigalgs;
3531     size_t numsigalgs = s->s3->tmp.peer_sigalgslen / 2;
3532     if (psig == NULL || numsigalgs > INT_MAX)
3533         return 0;
3534     if (idx >= 0) {
3535         idx <<= 1;
3536         if (idx >= (int)s->s3->tmp.peer_sigalgslen)
3537             return 0;
3538         psig += idx;
3539         if (rhash)
3540             *rhash = psig[0];
3541         if (rsig)
3542             *rsig = psig[1];
3543         tls1_lookup_sigalg(phash, psign, psignhash, psig);
3544     }
3545     return (int)numsigalgs;
3546 }
3547
3548 int SSL_get_shared_sigalgs(SSL *s, int idx,
3549                            int *psign, int *phash, int *psignhash,
3550                            unsigned char *rsig, unsigned char *rhash)
3551 {
3552     TLS_SIGALGS *shsigalgs = s->cert->shared_sigalgs;
3553     if (!shsigalgs || idx >= (int)s->cert->shared_sigalgslen
3554             || s->cert->shared_sigalgslen > INT_MAX)
3555         return 0;
3556     shsigalgs += idx;
3557     if (phash)
3558         *phash = shsigalgs->hash_nid;
3559     if (psign)
3560         *psign = shsigalgs->sign_nid;
3561     if (psignhash)
3562         *psignhash = shsigalgs->signandhash_nid;
3563     if (rsig)
3564         *rsig = shsigalgs->rsign;
3565     if (rhash)
3566         *rhash = shsigalgs->rhash;
3567     return (int)s->cert->shared_sigalgslen;
3568 }
3569
3570 #define MAX_SIGALGLEN   (TLSEXT_hash_num * TLSEXT_signature_num * 2)
3571
3572 typedef struct {
3573     size_t sigalgcnt;
3574     int sigalgs[MAX_SIGALGLEN];
3575 } sig_cb_st;
3576
3577 static void get_sigorhash(int *psig, int *phash, const char *str)
3578 {
3579     if (strcmp(str, "RSA") == 0) {
3580         *psig = EVP_PKEY_RSA;
3581     } else if (strcmp(str, "DSA") == 0) {
3582         *psig = EVP_PKEY_DSA;
3583     } else if (strcmp(str, "ECDSA") == 0) {
3584         *psig = EVP_PKEY_EC;
3585     } else {
3586         *phash = OBJ_sn2nid(str);
3587         if (*phash == NID_undef)
3588             *phash = OBJ_ln2nid(str);
3589     }
3590 }
3591
3592 static int sig_cb(const char *elem, int len, void *arg)
3593 {
3594     sig_cb_st *sarg = arg;
3595     size_t i;
3596     char etmp[20], *p;
3597     int sig_alg = NID_undef, hash_alg = NID_undef;
3598     if (elem == NULL)
3599         return 0;
3600     if (sarg->sigalgcnt == MAX_SIGALGLEN)
3601         return 0;
3602     if (len > (int)(sizeof(etmp) - 1))
3603         return 0;
3604     memcpy(etmp, elem, len);
3605     etmp[len] = 0;
3606     p = strchr(etmp, '+');
3607     if (!p)
3608         return 0;
3609     *p = 0;
3610     p++;
3611     if (!*p)
3612         return 0;
3613
3614     get_sigorhash(&sig_alg, &hash_alg, etmp);
3615     get_sigorhash(&sig_alg, &hash_alg, p);
3616
3617     if (sig_alg == NID_undef || hash_alg == NID_undef)
3618         return 0;
3619
3620     for (i = 0; i < sarg->sigalgcnt; i += 2) {
3621         if (sarg->sigalgs[i] == sig_alg && sarg->sigalgs[i + 1] == hash_alg)
3622             return 0;
3623     }
3624     sarg->sigalgs[sarg->sigalgcnt++] = hash_alg;
3625     sarg->sigalgs[sarg->sigalgcnt++] = sig_alg;
3626     return 1;
3627 }
3628
3629 /*
3630  * Set supported signature algorithms based on a colon separated list of the
3631  * form sig+hash e.g. RSA+SHA512:DSA+SHA512
3632  */
3633 int tls1_set_sigalgs_list(CERT *c, const char *str, int client)
3634 {
3635     sig_cb_st sig;
3636     sig.sigalgcnt = 0;
3637     if (!CONF_parse_list(str, ':', 1, sig_cb, &sig))
3638         return 0;
3639     if (c == NULL)
3640         return 1;
3641     return tls1_set_sigalgs(c, sig.sigalgs, sig.sigalgcnt, client);
3642 }
3643
3644 int tls1_set_sigalgs(CERT *c, const int *psig_nids, size_t salglen, int client)
3645 {
3646     unsigned char *sigalgs, *sptr;
3647     int rhash, rsign;
3648     size_t i;
3649     if (salglen & 1)
3650         return 0;
3651     sigalgs = OPENSSL_malloc(salglen);
3652     if (sigalgs == NULL)
3653         return 0;
3654     for (i = 0, sptr = sigalgs; i < salglen; i += 2) {
3655         rhash = tls12_find_id(*psig_nids++, tls12_md, OSSL_NELEM(tls12_md));
3656         rsign = tls12_find_id(*psig_nids++, tls12_sig, OSSL_NELEM(tls12_sig));
3657
3658         if (rhash == -1 || rsign == -1)
3659             goto err;
3660         *sptr++ = rhash;
3661         *sptr++ = rsign;
3662     }
3663
3664     if (client) {
3665         OPENSSL_free(c->client_sigalgs);
3666         c->client_sigalgs = sigalgs;
3667         c->client_sigalgslen = salglen;
3668     } else {
3669         OPENSSL_free(c->conf_sigalgs);
3670         c->conf_sigalgs = sigalgs;
3671         c->conf_sigalgslen = salglen;
3672     }
3673
3674     return 1;
3675
3676  err:
3677     OPENSSL_free(sigalgs);
3678     return 0;
3679 }
3680
3681 static int tls1_check_sig_alg(CERT *c, X509 *x, int default_nid)
3682 {
3683     int sig_nid;
3684     size_t i;
3685     if (default_nid == -1)
3686         return 1;
3687     sig_nid = X509_get_signature_nid(x);
3688     if (default_nid)
3689         return sig_nid == default_nid ? 1 : 0;
3690     for (i = 0; i < c->shared_sigalgslen; i++)
3691         if (sig_nid == c->shared_sigalgs[i].signandhash_nid)
3692             return 1;
3693     return 0;
3694 }
3695
3696 /* Check to see if a certificate issuer name matches list of CA names */
3697 static int ssl_check_ca_name(STACK_OF(X509_NAME) *names, X509 *x)
3698 {
3699     X509_NAME *nm;
3700     int i;
3701     nm = X509_get_issuer_name(x);
3702     for (i = 0; i < sk_X509_NAME_num(names); i++) {
3703         if (!X509_NAME_cmp(nm, sk_X509_NAME_value(names, i)))
3704             return 1;
3705     }
3706     return 0;
3707 }
3708
3709 /*
3710  * Check certificate chain is consistent with TLS extensions and is usable by
3711  * server. This servers two purposes: it allows users to check chains before
3712  * passing them to the server and it allows the server to check chains before
3713  * attempting to use them.
3714  */
3715
3716 /* Flags which need to be set for a certificate when stict mode not set */
3717
3718 #define CERT_PKEY_VALID_FLAGS \
3719         (CERT_PKEY_EE_SIGNATURE|CERT_PKEY_EE_PARAM)
3720 /* Strict mode flags */
3721 #define CERT_PKEY_STRICT_FLAGS \
3722          (CERT_PKEY_VALID_FLAGS|CERT_PKEY_CA_SIGNATURE|CERT_PKEY_CA_PARAM \
3723          | CERT_PKEY_ISSUER_NAME|CERT_PKEY_CERT_TYPE)
3724
3725 int tls1_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain,
3726                      int idx)
3727 {
3728     int i;
3729     int rv = 0;
3730     int check_flags = 0, strict_mode;
3731     CERT_PKEY *cpk = NULL;
3732     CERT *c = s->cert;
3733     uint32_t *pvalid;
3734     unsigned int suiteb_flags = tls1_suiteb(s);
3735     /* idx == -1 means checking server chains */
3736     if (idx != -1) {
3737         /* idx == -2 means checking client certificate chains */
3738         if (idx == -2) {
3739             cpk = c->key;
3740             idx = (int)(cpk - c->pkeys);
3741         } else
3742             cpk = c->pkeys + idx;
3743         pvalid = s->s3->tmp.valid_flags + idx;
3744         x = cpk->x509;
3745         pk = cpk->privatekey;
3746         chain = cpk->chain;
3747         strict_mode = c->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT;
3748         /* If no cert or key, forget it */
3749         if (!x || !pk)
3750             goto end;
3751     } else {
3752         if (!x || !pk)
3753             return 0;
3754         idx = ssl_cert_type(x, pk);
3755         if (idx == -1)
3756             return 0;
3757         pvalid = s->s3->tmp.valid_flags + idx;
3758
3759         if (c->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)
3760             check_flags = CERT_PKEY_STRICT_FLAGS;
3761         else
3762             check_flags = CERT_PKEY_VALID_FLAGS;
3763         strict_mode = 1;
3764     }
3765
3766     if (suiteb_flags) {
3767         int ok;
3768         if (check_flags)
3769             check_flags |= CERT_PKEY_SUITEB;
3770         ok = X509_chain_check_suiteb(NULL, x, chain, suiteb_flags);
3771         if (ok == X509_V_OK)
3772             rv |= CERT_PKEY_SUITEB;
3773         else if (!check_flags)
3774             goto end;
3775     }
3776
3777     /*
3778      * Check all signature algorithms are consistent with signature
3779      * algorithms extension if TLS 1.2 or later and strict mode.
3780      */
3781     if (TLS1_get_version(s) >= TLS1_2_VERSION && strict_mode) {
3782         int default_nid;
3783         unsigned char rsign = 0;
3784         if (s->s3->tmp.peer_sigalgs)
3785             default_nid = 0;
3786         /* If no sigalgs extension use defaults from RFC5246 */
3787         else {
3788             switch (idx) {
3789             case SSL_PKEY_RSA_ENC:
3790             case SSL_PKEY_RSA_SIGN:
3791                 rsign = TLSEXT_signature_rsa;
3792                 default_nid = NID_sha1WithRSAEncryption;
3793                 break;
3794
3795             case SSL_PKEY_DSA_SIGN:
3796                 rsign = TLSEXT_signature_dsa;
3797                 default_nid = NID_dsaWithSHA1;
3798                 break;
3799
3800             case SSL_PKEY_ECC:
3801                 rsign = TLSEXT_signature_ecdsa;
3802                 default_nid = NID_ecdsa_with_SHA1;
3803                 break;
3804
3805             case SSL_PKEY_GOST01:
3806                 rsign = TLSEXT_signature_gostr34102001;
3807                 default_nid = NID_id_GostR3411_94_with_GostR3410_2001;
3808                 break;
3809
3810             case SSL_PKEY_GOST12_256:
3811                 rsign = TLSEXT_signature_gostr34102012_256;
3812                 default_nid = NID_id_tc26_signwithdigest_gost3410_2012_256;
3813                 break;
3814
3815             case SSL_PKEY_GOST12_512:
3816                 rsign = TLSEXT_signature_gostr34102012_512;
3817                 default_nid = NID_id_tc26_signwithdigest_gost3410_2012_512;
3818                 break;
3819
3820             default:
3821                 default_nid = -1;
3822                 break;
3823             }
3824         }
3825         /*
3826          * If peer sent no signature algorithms extension and we have set
3827          * preferred signature algorithms check we support sha1.
3828          */
3829         if (default_nid > 0 && c->conf_sigalgs) {
3830             size_t j;
3831             const unsigned char *p = c->conf_sigalgs;
3832             for (j = 0; j < c->conf_sigalgslen; j += 2, p += 2) {
3833                 if (p[0] == TLSEXT_hash_sha1 && p[1] == rsign)
3834                     break;
3835             }
3836             if (j == c->conf_sigalgslen) {
3837                 if (check_flags)
3838                     goto skip_sigs;
3839                 else
3840                     goto end;
3841             }
3842         }
3843         /* Check signature algorithm of each cert in chain */
3844         if (!tls1_check_sig_alg(c, x, default_nid)) {
3845             if (!check_flags)
3846                 goto end;
3847         } else
3848             rv |= CERT_PKEY_EE_SIGNATURE;
3849         rv |= CERT_PKEY_CA_SIGNATURE;
3850         for (i = 0; i < sk_X509_num(chain); i++) {
3851             if (!tls1_check_sig_alg(c, sk_X509_value(chain, i), default_nid)) {
3852                 if (check_flags) {
3853                     rv &= ~CERT_PKEY_CA_SIGNATURE;
3854                     break;
3855                 } else
3856                     goto end;
3857             }
3858         }
3859     }
3860     /* Else not TLS 1.2, so mark EE and CA signing algorithms OK */
3861     else if (check_flags)
3862         rv |= CERT_PKEY_EE_SIGNATURE | CERT_PKEY_CA_SIGNATURE;
3863  skip_sigs:
3864     /* Check cert parameters are consistent */
3865     if (tls1_check_cert_param(s, x, check_flags ? 1 : 2))
3866         rv |= CERT_PKEY_EE_PARAM;
3867     else if (!check_flags)
3868         goto end;
3869     if (!s->server)
3870         rv |= CERT_PKEY_CA_PARAM;
3871     /* In strict mode check rest of chain too */
3872     else if (strict_mode) {
3873         rv |= CERT_PKEY_CA_PARAM;
3874         for (i = 0; i < sk_X509_num(chain); i++) {
3875             X509 *ca = sk_X509_value(chain, i);
3876             if (!tls1_check_cert_param(s, ca, 0)) {
3877                 if (check_flags) {
3878                     rv &= ~CERT_PKEY_CA_PARAM;
3879                     break;
3880                 } else
3881                     goto end;
3882             }
3883         }
3884     }
3885     if (!s->server && strict_mode) {
3886         STACK_OF(X509_NAME) *ca_dn;
3887         int check_type = 0;
3888         switch (EVP_PKEY_id(pk)) {
3889         case EVP_PKEY_RSA:
3890             check_type = TLS_CT_RSA_SIGN;
3891             break;
3892         case EVP_PKEY_DSA:
3893             check_type = TLS_CT_DSS_SIGN;
3894             break;
3895         case EVP_PKEY_EC:
3896             check_type = TLS_CT_ECDSA_SIGN;
3897             break;
3898         }
3899         if (check_type) {
3900             const unsigned char *ctypes;
3901             int ctypelen;
3902             if (c->ctypes) {
3903                 ctypes = c->ctypes;
3904                 ctypelen = (int)c->ctype_num;
3905             } else {
3906                 ctypes = (unsigned char *)s->s3->tmp.ctype;
3907                 ctypelen = s->s3->tmp.ctype_num;
3908             }
3909             for (i = 0; i < ctypelen; i++) {
3910                 if (ctypes[i] == check_type) {
3911                     rv |= CERT_PKEY_CERT_TYPE;
3912                     break;
3913                 }
3914             }
3915             if (!(rv & CERT_PKEY_CERT_TYPE) && !check_flags)
3916                 goto end;
3917         } else
3918             rv |= CERT_PKEY_CERT_TYPE;
3919
3920         ca_dn = s->s3->tmp.ca_names;
3921
3922         if (!sk_X509_NAME_num(ca_dn))
3923             rv |= CERT_PKEY_ISSUER_NAME;
3924
3925         if (!(rv & CERT_PKEY_ISSUER_NAME)) {
3926             if (ssl_check_ca_name(ca_dn, x))
3927                 rv |= CERT_PKEY_ISSUER_NAME;
3928         }
3929         if (!(rv & CERT_PKEY_ISSUER_NAME)) {
3930             for (i = 0; i < sk_X509_num(chain); i++) {
3931                 X509 *xtmp = sk_X509_value(chain, i);
3932                 if (ssl_check_ca_name(ca_dn, xtmp)) {
3933                     rv |= CERT_PKEY_ISSUER_NAME;
3934                     break;
3935                 }
3936             }
3937         }
3938         if (!check_flags && !(rv & CERT_PKEY_ISSUER_NAME))
3939             goto end;
3940     } else
3941         rv |= CERT_PKEY_ISSUER_NAME | CERT_PKEY_CERT_TYPE;
3942
3943     if (!check_flags || (rv & check_flags) == check_flags)
3944         rv |= CERT_PKEY_VALID;
3945
3946  end:
3947
3948     if (TLS1_get_version(s) >= TLS1_2_VERSION) {
3949         if (*pvalid & CERT_PKEY_EXPLICIT_SIGN)
3950             rv |= CERT_PKEY_EXPLICIT_SIGN | CERT_PKEY_SIGN;
3951         else if (s->s3->tmp.md[idx] != NULL)
3952             rv |= CERT_PKEY_SIGN;
3953     } else
3954         rv |= CERT_PKEY_SIGN | CERT_PKEY_EXPLICIT_SIGN;
3955
3956     /*
3957      * When checking a CERT_PKEY structure all flags are irrelevant if the
3958      * chain is invalid.
3959      */
3960     if (!check_flags) {
3961         if (rv & CERT_PKEY_VALID)
3962             *pvalid = rv;
3963         else {
3964             /* Preserve explicit sign flag, clear rest */
3965             *pvalid &= CERT_PKEY_EXPLICIT_SIGN;
3966             return 0;
3967         }
3968     }
3969     return rv;
3970 }
3971
3972 /* Set validity of certificates in an SSL structure */
3973 void tls1_set_cert_validity(SSL *s)
3974 {
3975     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_RSA_ENC);
3976     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_RSA_SIGN);
3977     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_DSA_SIGN);
3978     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_ECC);
3979     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_GOST01);
3980     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_GOST12_256);
3981     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_GOST12_512);
3982 }
3983
3984 /* User level utiity function to check a chain is suitable */
3985 int SSL_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain)
3986 {
3987     return tls1_check_chain(s, x, pk, chain, -1);
3988 }
3989
3990 #ifndef OPENSSL_NO_DH
3991 DH *ssl_get_auto_dh(SSL *s)
3992 {
3993     int dh_secbits = 80;
3994     if (s->cert->dh_tmp_auto == 2)
3995         return DH_get_1024_160();
3996     if (s->s3->tmp.new_cipher->algorithm_auth & (SSL_aNULL | SSL_aPSK)) {
3997         if (s->s3->tmp.new_cipher->strength_bits == 256)
3998             dh_secbits = 128;
3999         else
4000             dh_secbits = 80;
4001     } else {
4002         CERT_PKEY *cpk = ssl_get_server_send_pkey(s);
4003         dh_secbits = EVP_PKEY_security_bits(cpk->privatekey);
4004     }
4005
4006     if (dh_secbits >= 128) {
4007         DH *dhp = DH_new();
4008         BIGNUM *p, *g;
4009         if (dhp == NULL)
4010             return NULL;
4011         g = BN_new();
4012         if (g != NULL)
4013             BN_set_word(g, 2);
4014         if (dh_secbits >= 192)
4015             p = BN_get_rfc3526_prime_8192(NULL);
4016         else
4017             p = BN_get_rfc3526_prime_3072(NULL);
4018         if (p == NULL || g == NULL || !DH_set0_pqg(dhp, p, NULL, g)) {
4019             DH_free(dhp);
4020             BN_free(p);
4021             BN_free(g);
4022             return NULL;
4023         }
4024         return dhp;
4025     }
4026     if (dh_secbits >= 112)
4027         return DH_get_2048_224();
4028     return DH_get_1024_160();
4029 }
4030 #endif
4031
4032 static int ssl_security_cert_key(SSL *s, SSL_CTX *ctx, X509 *x, int op)
4033 {
4034     int secbits = -1;
4035     EVP_PKEY *pkey = X509_get0_pubkey(x);
4036     if (pkey) {
4037         /*
4038          * If no parameters this will return -1 and fail using the default
4039          * security callback for any non-zero security level. This will
4040          * reject keys which omit parameters but this only affects DSA and
4041          * omission of parameters is never (?) done in practice.
4042          */
4043         secbits = EVP_PKEY_security_bits(pkey);
4044     }
4045     if (s)
4046         return ssl_security(s, op, secbits, 0, x);
4047     else
4048         return ssl_ctx_security(ctx, op, secbits, 0, x);
4049 }
4050
4051 static int ssl_security_cert_sig(SSL *s, SSL_CTX *ctx, X509 *x, int op)
4052 {
4053     /* Lookup signature algorithm digest */
4054     int secbits = -1, md_nid = NID_undef, sig_nid;
4055     /* Don't check signature if self signed */
4056     if ((X509_get_extension_flags(x) & EXFLAG_SS) != 0)
4057         return 1;
4058     sig_nid = X509_get_signature_nid(x);
4059     if (sig_nid && OBJ_find_sigid_algs(sig_nid, &md_nid, NULL)) {
4060         const EVP_MD *md;
4061         if (md_nid && (md = EVP_get_digestbynid(md_nid)))
4062             secbits = EVP_MD_size(md) * 4;
4063     }
4064     if (s)
4065         return ssl_security(s, op, secbits, md_nid, x);
4066     else
4067         return ssl_ctx_security(ctx, op, secbits, md_nid, x);
4068 }
4069
4070 int ssl_security_cert(SSL *s, SSL_CTX *ctx, X509 *x, int vfy, int is_ee)
4071 {
4072     if (vfy)
4073         vfy = SSL_SECOP_PEER;
4074     if (is_ee) {
4075         if (!ssl_security_cert_key(s, ctx, x, SSL_SECOP_EE_KEY | vfy))
4076             return SSL_R_EE_KEY_TOO_SMALL;
4077     } else {
4078         if (!ssl_security_cert_key(s, ctx, x, SSL_SECOP_CA_KEY | vfy))
4079             return SSL_R_CA_KEY_TOO_SMALL;
4080     }
4081     if (!ssl_security_cert_sig(s, ctx, x, SSL_SECOP_CA_MD | vfy))
4082         return SSL_R_CA_MD_TOO_WEAK;
4083     return 1;
4084 }
4085
4086 /*
4087  * Check security of a chain, if sk includes the end entity certificate then
4088  * x is NULL. If vfy is 1 then we are verifying a peer chain and not sending
4089  * one to the peer. Return values: 1 if ok otherwise error code to use
4090  */
4091
4092 int ssl_security_cert_chain(SSL *s, STACK_OF(X509) *sk, X509 *x, int vfy)
4093 {
4094     int rv, start_idx, i;
4095     if (x == NULL) {
4096         x = sk_X509_value(sk, 0);
4097         start_idx = 1;
4098     } else
4099         start_idx = 0;
4100
4101     rv = ssl_security_cert(s, NULL, x, vfy, 1);
4102     if (rv != 1)
4103         return rv;
4104
4105     for (i = start_idx; i < sk_X509_num(sk); i++) {
4106         x = sk_X509_value(sk, i);
4107         rv = ssl_security_cert(s, NULL, x, vfy, 0);
4108         if (rv != 1)
4109             return rv;
4110     }
4111     return 1;
4112 }