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