ssl/t1_lib.c

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