ssl/t1_lib.c

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