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