ssl/t1_lib.c

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