ssl/t1_lib.c

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