ssl/t1_lib.c

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