ssl/t1_lib.c

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