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