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