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