ssl/t1_lib.c

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