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