ssl/t1_lib.c

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