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