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             return -1;
3517         if (rv == 0)
3518             return 2;
3519         if (rv == 2)
3520             renew_ticket = 1;
3521     } else {
3522         /* Check key name matches */
3523         if (memcmp(etick, tctx->tlsext_tick_key_name, 16))
3524             return 2;
3525         if (HMAC_Init_ex(&hctx, tctx->tlsext_tick_hmac_key, 16,
3526                          tlsext_tick_md(), NULL) <= 0
3527                 || EVP_DecryptInit_ex(&ctx, EVP_aes_128_cbc(), NULL,
3528                                       tctx->tlsext_tick_aes_key,
3529                                       etick + 16) <= 0) {
3530             goto err;
3531        }
3532     }
3533     /*
3534      * Attempt to process session ticket, first conduct sanity and integrity
3535      * checks on ticket.
3536      */
3537     mlen = HMAC_size(&hctx);
3538     if (mlen < 0) {
3539         goto err;
3540     }
3541     /* Sanity check ticket length: must exceed keyname + IV + HMAC */
3542     if (eticklen <= 16 + EVP_CIPHER_CTX_iv_length(&ctx) + mlen) {
3543         HMAC_CTX_cleanup(&hctx);
3544         EVP_CIPHER_CTX_cleanup(&ctx);
3545         return 2;
3546     }
3547
3548     eticklen -= mlen;
3549     /* Check HMAC of encrypted ticket */
3550     if (HMAC_Update(&hctx, etick, eticklen) <= 0
3551             || HMAC_Final(&hctx, tick_hmac, NULL) <= 0) {
3552         goto err;
3553     }
3554     HMAC_CTX_cleanup(&hctx);
3555     if (CRYPTO_memcmp(tick_hmac, etick + eticklen, mlen)) {
3556         EVP_CIPHER_CTX_cleanup(&ctx);
3557         return 2;
3558     }
3559     /* Attempt to decrypt session data */
3560     /* Move p after IV to start of encrypted ticket, update length */
3561     p = etick + 16 + EVP_CIPHER_CTX_iv_length(&ctx);
3562     eticklen -= 16 + EVP_CIPHER_CTX_iv_length(&ctx);
3563     sdec = OPENSSL_malloc(eticklen);
3564     if (sdec == NULL
3565             || EVP_DecryptUpdate(&ctx, sdec, &slen, p, eticklen) <= 0) {
3566         EVP_CIPHER_CTX_cleanup(&ctx);
3567         OPENSSL_free(sdec);
3568         return -1;
3569     }
3570     if (EVP_DecryptFinal(&ctx, sdec + slen, &mlen) <= 0) {
3571         EVP_CIPHER_CTX_cleanup(&ctx);
3572         OPENSSL_free(sdec);
3573         return 2;
3574     }
3575     slen += mlen;
3576     EVP_CIPHER_CTX_cleanup(&ctx);
3577     p = sdec;
3578
3579     sess = d2i_SSL_SESSION(NULL, &p, slen);
3580     slen -= p - sdec;
3581     OPENSSL_free(sdec);
3582     if (sess) {
3583         /* Some additional consistency checks */
3584         if (slen != 0 || sess->session_id_length != 0) {
3585             SSL_SESSION_free(sess);
3586             return 2;
3587         }
3588         /*
3589          * The session ID, if non-empty, is used by some clients to detect
3590          * that the ticket has been accepted. So we copy it to the session
3591          * structure. If it is empty set length to zero as required by
3592          * standard.
3593          */
3594         if (sesslen)
3595             memcpy(sess->session_id, sess_id, sesslen);
3596         sess->session_id_length = sesslen;
3597         *psess = sess;
3598         if (renew_ticket)
3599             return 4;
3600         else
3601             return 3;
3602     }
3603     ERR_clear_error();
3604     /*
3605      * For session parse failure, indicate that we need to send a new ticket.
3606      */
3607     return 2;
3608 err:
3609     EVP_CIPHER_CTX_cleanup(&ctx);
3610     HMAC_CTX_cleanup(&hctx);
3611     return -1;
3612 }
3613
3614 /* Tables to translate from NIDs to TLS v1.2 ids */
3615
3616 typedef struct {
3617     int nid;
3618     int id;
3619 } tls12_lookup;
3620
3621 static tls12_lookup tls12_md[] = {
3622     {NID_md5, TLSEXT_hash_md5},
3623     {NID_sha1, TLSEXT_hash_sha1},
3624     {NID_sha224, TLSEXT_hash_sha224},
3625     {NID_sha256, TLSEXT_hash_sha256},
3626     {NID_sha384, TLSEXT_hash_sha384},
3627     {NID_sha512, TLSEXT_hash_sha512}
3628 };
3629
3630 static tls12_lookup tls12_sig[] = {
3631     {EVP_PKEY_RSA, TLSEXT_signature_rsa},
3632     {EVP_PKEY_DSA, TLSEXT_signature_dsa},
3633     {EVP_PKEY_EC, TLSEXT_signature_ecdsa}
3634 };
3635
3636 static int tls12_find_id(int nid, tls12_lookup *table, size_t tlen)
3637 {
3638     size_t i;
3639     for (i = 0; i < tlen; i++) {
3640         if (table[i].nid == nid)
3641             return table[i].id;
3642     }
3643     return -1;
3644 }
3645
3646 static int tls12_find_nid(int id, tls12_lookup *table, size_t tlen)
3647 {
3648     size_t i;
3649     for (i = 0; i < tlen; i++) {
3650         if ((table[i].id) == id)
3651             return table[i].nid;
3652     }
3653     return NID_undef;
3654 }
3655
3656 int tls12_get_sigandhash(unsigned char *p, const EVP_PKEY *pk,
3657                          const EVP_MD *md)
3658 {
3659     int sig_id, md_id;
3660     if (!md)
3661         return 0;
3662     md_id = tls12_find_id(EVP_MD_type(md), tls12_md,
3663                           sizeof(tls12_md) / sizeof(tls12_lookup));
3664     if (md_id == -1)
3665         return 0;
3666     sig_id = tls12_get_sigid(pk);
3667     if (sig_id == -1)
3668         return 0;
3669     p[0] = (unsigned char)md_id;
3670     p[1] = (unsigned char)sig_id;
3671     return 1;
3672 }
3673
3674 int tls12_get_sigid(const EVP_PKEY *pk)
3675 {
3676     return tls12_find_id(pk->type, tls12_sig,
3677                          sizeof(tls12_sig) / sizeof(tls12_lookup));
3678 }
3679
3680 const EVP_MD *tls12_get_hash(unsigned char hash_alg)
3681 {
3682     switch (hash_alg) {
3683 # ifndef OPENSSL_NO_MD5
3684     case TLSEXT_hash_md5:
3685 #  ifdef OPENSSL_FIPS
3686         if (FIPS_mode())
3687             return NULL;
3688 #  endif
3689         return EVP_md5();
3690 # endif
3691 # ifndef OPENSSL_NO_SHA
3692     case TLSEXT_hash_sha1:
3693         return EVP_sha1();
3694 # endif
3695 # ifndef OPENSSL_NO_SHA256
3696     case TLSEXT_hash_sha224:
3697         return EVP_sha224();
3698
3699     case TLSEXT_hash_sha256:
3700         return EVP_sha256();
3701 # endif
3702 # ifndef OPENSSL_NO_SHA512
3703     case TLSEXT_hash_sha384:
3704         return EVP_sha384();
3705
3706     case TLSEXT_hash_sha512:
3707         return EVP_sha512();
3708 # endif
3709     default:
3710         return NULL;
3711
3712     }
3713 }
3714
3715 static int tls12_get_pkey_idx(unsigned char sig_alg)
3716 {
3717     switch (sig_alg) {
3718 # ifndef OPENSSL_NO_RSA
3719     case TLSEXT_signature_rsa:
3720         return SSL_PKEY_RSA_SIGN;
3721 # endif
3722 # ifndef OPENSSL_NO_DSA
3723     case TLSEXT_signature_dsa:
3724         return SSL_PKEY_DSA_SIGN;
3725 # endif
3726 # ifndef OPENSSL_NO_ECDSA
3727     case TLSEXT_signature_ecdsa:
3728         return SSL_PKEY_ECC;
3729 # endif
3730     }
3731     return -1;
3732 }
3733
3734 /* Convert TLS 1.2 signature algorithm extension values into NIDs */
3735 static void tls1_lookup_sigalg(int *phash_nid, int *psign_nid,
3736                                int *psignhash_nid, const unsigned char *data)
3737 {
3738     int sign_nid = NID_undef, hash_nid = NID_undef;
3739     if (!phash_nid && !psign_nid && !psignhash_nid)
3740         return;
3741     if (phash_nid || psignhash_nid) {
3742         hash_nid = tls12_find_nid(data[0], tls12_md,
3743                                   sizeof(tls12_md) / sizeof(tls12_lookup));
3744         if (phash_nid)
3745             *phash_nid = hash_nid;
3746     }
3747     if (psign_nid || psignhash_nid) {
3748         sign_nid = tls12_find_nid(data[1], tls12_sig,
3749                                   sizeof(tls12_sig) / sizeof(tls12_lookup));
3750         if (psign_nid)
3751             *psign_nid = sign_nid;
3752     }
3753     if (psignhash_nid) {
3754         if (sign_nid == NID_undef || hash_nid == NID_undef
3755                 || OBJ_find_sigid_by_algs(psignhash_nid, hash_nid,
3756                                           sign_nid) <= 0)
3757             *psignhash_nid = NID_undef;
3758     }
3759 }
3760
3761 /* Given preference and allowed sigalgs set shared sigalgs */
3762 static int tls12_do_shared_sigalgs(TLS_SIGALGS *shsig,
3763                                    const unsigned char *pref, size_t preflen,
3764                                    const unsigned char *allow,
3765                                    size_t allowlen)
3766 {
3767     const unsigned char *ptmp, *atmp;
3768     size_t i, j, nmatch = 0;
3769     for (i = 0, ptmp = pref; i < preflen; i += 2, ptmp += 2) {
3770         /* Skip disabled hashes or signature algorithms */
3771         if (tls12_get_hash(ptmp[0]) == NULL)
3772             continue;
3773         if (tls12_get_pkey_idx(ptmp[1]) == -1)
3774             continue;
3775         for (j = 0, atmp = allow; j < allowlen; j += 2, atmp += 2) {
3776             if (ptmp[0] == atmp[0] && ptmp[1] == atmp[1]) {
3777                 nmatch++;
3778                 if (shsig) {
3779                     shsig->rhash = ptmp[0];
3780                     shsig->rsign = ptmp[1];
3781                     tls1_lookup_sigalg(&shsig->hash_nid,
3782                                        &shsig->sign_nid,
3783                                        &shsig->signandhash_nid, ptmp);
3784                     shsig++;
3785                 }
3786                 break;
3787             }
3788         }
3789     }
3790     return nmatch;
3791 }
3792
3793 /* Set shared signature algorithms for SSL structures */
3794 static int tls1_set_shared_sigalgs(SSL *s)
3795 {
3796     const unsigned char *pref, *allow, *conf;
3797     size_t preflen, allowlen, conflen;
3798     size_t nmatch;
3799     TLS_SIGALGS *salgs = NULL;
3800     CERT *c = s->cert;
3801     unsigned int is_suiteb = tls1_suiteb(s);
3802     if (c->shared_sigalgs) {
3803         OPENSSL_free(c->shared_sigalgs);
3804         c->shared_sigalgs = NULL;
3805         c->shared_sigalgslen = 0;
3806     }
3807     /* If client use client signature algorithms if not NULL */
3808     if (!s->server && c->client_sigalgs && !is_suiteb) {
3809         conf = c->client_sigalgs;
3810         conflen = c->client_sigalgslen;
3811     } else if (c->conf_sigalgs && !is_suiteb) {
3812         conf = c->conf_sigalgs;
3813         conflen = c->conf_sigalgslen;
3814     } else
3815         conflen = tls12_get_psigalgs(s, 0, &conf);
3816     if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE || is_suiteb) {
3817         pref = conf;
3818         preflen = conflen;
3819         allow = c->peer_sigalgs;
3820         allowlen = c->peer_sigalgslen;
3821     } else {
3822         allow = conf;
3823         allowlen = conflen;
3824         pref = c->peer_sigalgs;
3825         preflen = c->peer_sigalgslen;
3826     }
3827     nmatch = tls12_do_shared_sigalgs(NULL, pref, preflen, allow, allowlen);
3828     if (nmatch) {
3829         salgs = OPENSSL_malloc(nmatch * sizeof(TLS_SIGALGS));
3830         if (!salgs)
3831             return 0;
3832         nmatch = tls12_do_shared_sigalgs(salgs, pref, preflen, allow, allowlen);
3833     } else {
3834         salgs = NULL;
3835     }
3836     c->shared_sigalgs = salgs;
3837     c->shared_sigalgslen = nmatch;
3838     return 1;
3839 }
3840
3841 /* Set preferred digest for each key type */
3842
3843 int tls1_save_sigalgs(SSL *s, const unsigned char *data, int dsize)
3844 {
3845     CERT *c = s->cert;
3846     /* Extension ignored for inappropriate versions */
3847     if (!SSL_USE_SIGALGS(s))
3848         return 1;
3849     /* Should never happen */
3850     if (!c)
3851         return 0;
3852
3853     if (c->peer_sigalgs)
3854         OPENSSL_free(c->peer_sigalgs);
3855     c->peer_sigalgs = OPENSSL_malloc(dsize);
3856     if (!c->peer_sigalgs)
3857         return 0;
3858     c->peer_sigalgslen = dsize;
3859     memcpy(c->peer_sigalgs, data, dsize);
3860     return 1;
3861 }
3862
3863 int tls1_process_sigalgs(SSL *s)
3864 {
3865     int idx;
3866     size_t i;
3867     const EVP_MD *md;
3868     CERT *c = s->cert;
3869     TLS_SIGALGS *sigptr;
3870     if (!tls1_set_shared_sigalgs(s))
3871         return 0;
3872
3873 # ifdef OPENSSL_SSL_DEBUG_BROKEN_PROTOCOL
3874     if (s->cert->cert_flags & SSL_CERT_FLAG_BROKEN_PROTOCOL) {
3875         /*
3876          * Use first set signature preference to force message digest,
3877          * ignoring any peer preferences.
3878          */
3879         const unsigned char *sigs = NULL;
3880         if (s->server)
3881             sigs = c->conf_sigalgs;
3882         else
3883             sigs = c->client_sigalgs;
3884         if (sigs) {
3885             idx = tls12_get_pkey_idx(sigs[1]);
3886             md = tls12_get_hash(sigs[0]);
3887             c->pkeys[idx].digest = md;
3888             c->pkeys[idx].valid_flags = CERT_PKEY_EXPLICIT_SIGN;
3889             if (idx == SSL_PKEY_RSA_SIGN) {
3890                 c->pkeys[SSL_PKEY_RSA_ENC].valid_flags =
3891                     CERT_PKEY_EXPLICIT_SIGN;
3892                 c->pkeys[SSL_PKEY_RSA_ENC].digest = md;
3893             }
3894         }
3895     }
3896 # endif
3897
3898     for (i = 0, sigptr = c->shared_sigalgs;
3899          i < c->shared_sigalgslen; i++, sigptr++) {
3900         idx = tls12_get_pkey_idx(sigptr->rsign);
3901         if (idx > 0 && c->pkeys[idx].digest == NULL) {
3902             md = tls12_get_hash(sigptr->rhash);
3903             c->pkeys[idx].digest = md;
3904             c->pkeys[idx].valid_flags = CERT_PKEY_EXPLICIT_SIGN;
3905             if (idx == SSL_PKEY_RSA_SIGN) {
3906                 c->pkeys[SSL_PKEY_RSA_ENC].valid_flags =
3907                     CERT_PKEY_EXPLICIT_SIGN;
3908                 c->pkeys[SSL_PKEY_RSA_ENC].digest = md;
3909             }
3910         }
3911
3912     }
3913     /*
3914      * In strict mode leave unset digests as NULL to indicate we can't use
3915      * the certificate for signing.
3916      */
3917     if (!(s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)) {
3918         /*
3919          * Set any remaining keys to default values. NOTE: if alg is not
3920          * supported it stays as NULL.
3921          */
3922 # ifndef OPENSSL_NO_DSA
3923         if (!c->pkeys[SSL_PKEY_DSA_SIGN].digest)
3924             c->pkeys[SSL_PKEY_DSA_SIGN].digest = EVP_sha1();
3925 # endif
3926 # ifndef OPENSSL_NO_RSA
3927         if (!c->pkeys[SSL_PKEY_RSA_SIGN].digest) {
3928             c->pkeys[SSL_PKEY_RSA_SIGN].digest = EVP_sha1();
3929             c->pkeys[SSL_PKEY_RSA_ENC].digest = EVP_sha1();
3930         }
3931 # endif
3932 # ifndef OPENSSL_NO_ECDSA
3933         if (!c->pkeys[SSL_PKEY_ECC].digest)
3934             c->pkeys[SSL_PKEY_ECC].digest = EVP_sha1();
3935 # endif
3936     }
3937     return 1;
3938 }
3939
3940 int SSL_get_sigalgs(SSL *s, int idx,
3941                     int *psign, int *phash, int *psignhash,
3942                     unsigned char *rsig, unsigned char *rhash)
3943 {
3944     const unsigned char *psig = s->cert->peer_sigalgs;
3945     if (psig == NULL)
3946         return 0;
3947     if (idx >= 0) {
3948         idx <<= 1;
3949         if (idx >= (int)s->cert->peer_sigalgslen)
3950             return 0;
3951         psig += idx;
3952         if (rhash)
3953             *rhash = psig[0];
3954         if (rsig)
3955             *rsig = psig[1];
3956         tls1_lookup_sigalg(phash, psign, psignhash, psig);
3957     }
3958     return s->cert->peer_sigalgslen / 2;
3959 }
3960
3961 int SSL_get_shared_sigalgs(SSL *s, int idx,
3962                            int *psign, int *phash, int *psignhash,
3963                            unsigned char *rsig, unsigned char *rhash)
3964 {
3965     TLS_SIGALGS *shsigalgs = s->cert->shared_sigalgs;
3966     if (!shsigalgs || idx >= (int)s->cert->shared_sigalgslen)
3967         return 0;
3968     shsigalgs += idx;
3969     if (phash)
3970         *phash = shsigalgs->hash_nid;
3971     if (psign)
3972         *psign = shsigalgs->sign_nid;
3973     if (psignhash)
3974         *psignhash = shsigalgs->signandhash_nid;
3975     if (rsig)
3976         *rsig = shsigalgs->rsign;
3977     if (rhash)
3978         *rhash = shsigalgs->rhash;
3979     return s->cert->shared_sigalgslen;
3980 }
3981
3982 # ifndef OPENSSL_NO_HEARTBEATS
3983 int tls1_process_heartbeat(SSL *s)
3984 {
3985     unsigned char *p = &s->s3->rrec.data[0], *pl;
3986     unsigned short hbtype;
3987     unsigned int payload;
3988     unsigned int padding = 16;  /* Use minimum padding */
3989
3990     if (s->msg_callback)
3991         s->msg_callback(0, s->version, TLS1_RT_HEARTBEAT,
3992                         &s->s3->rrec.data[0], s->s3->rrec.length,
3993                         s, s->msg_callback_arg);
3994
3995     /* Read type and payload length first */
3996     if (1 + 2 + 16 > s->s3->rrec.length)
3997         return 0;               /* silently discard */
3998     hbtype = *p++;
3999     n2s(p, payload);
4000     if (1 + 2 + payload + 16 > s->s3->rrec.length)
4001         return 0;               /* silently discard per RFC 6520 sec. 4 */
4002     pl = p;
4003
4004     if (hbtype == TLS1_HB_REQUEST) {
4005         unsigned char *buffer, *bp;
4006         int r;
4007
4008         /*
4009          * Allocate memory for the response, size is 1 bytes message type,
4010          * plus 2 bytes payload length, plus payload, plus padding
4011          */
4012         buffer = OPENSSL_malloc(1 + 2 + payload + padding);
4013         if (buffer == NULL)
4014             return -1;
4015         bp = buffer;
4016
4017         /* Enter response type, length and copy payload */
4018         *bp++ = TLS1_HB_RESPONSE;
4019         s2n(payload, bp);
4020         memcpy(bp, pl, payload);
4021         bp += payload;
4022         /* Random padding */
4023         if (RAND_bytes(bp, padding) <= 0) {
4024             OPENSSL_free(buffer);
4025             return -1;
4026         }
4027
4028         r = ssl3_write_bytes(s, TLS1_RT_HEARTBEAT, buffer,
4029                              3 + payload + padding);
4030
4031         if (r >= 0 && s->msg_callback)
4032             s->msg_callback(1, s->version, TLS1_RT_HEARTBEAT,
4033                             buffer, 3 + payload + padding,
4034                             s, s->msg_callback_arg);
4035
4036         OPENSSL_free(buffer);
4037
4038         if (r < 0)
4039             return r;
4040     } else if (hbtype == TLS1_HB_RESPONSE) {
4041         unsigned int seq;
4042
4043         /*
4044          * We only send sequence numbers (2 bytes unsigned int), and 16
4045          * random bytes, so we just try to read the sequence number
4046          */
4047         n2s(pl, seq);
4048
4049         if (payload == 18 && seq == s->tlsext_hb_seq) {
4050             s->tlsext_hb_seq++;
4051             s->tlsext_hb_pending = 0;
4052         }
4053     }
4054
4055     return 0;
4056 }
4057
4058 int tls1_heartbeat(SSL *s)
4059 {
4060     unsigned char *buf, *p;
4061     int ret = -1;
4062     unsigned int payload = 18;  /* Sequence number + random bytes */
4063     unsigned int padding = 16;  /* Use minimum padding */
4064
4065     /* Only send if peer supports and accepts HB requests... */
4066     if (!(s->tlsext_heartbeat & SSL_TLSEXT_HB_ENABLED) ||
4067         s->tlsext_heartbeat & SSL_TLSEXT_HB_DONT_SEND_REQUESTS) {
4068         SSLerr(SSL_F_TLS1_HEARTBEAT, SSL_R_TLS_HEARTBEAT_PEER_DOESNT_ACCEPT);
4069         return -1;
4070     }
4071
4072     /* ...and there is none in flight yet... */
4073     if (s->tlsext_hb_pending) {
4074         SSLerr(SSL_F_TLS1_HEARTBEAT, SSL_R_TLS_HEARTBEAT_PENDING);
4075         return -1;
4076     }
4077
4078     /* ...and no handshake in progress. */
4079     if (SSL_in_init(s) || s->in_handshake) {
4080         SSLerr(SSL_F_TLS1_HEARTBEAT, SSL_R_UNEXPECTED_MESSAGE);
4081         return -1;
4082     }
4083
4084     /*
4085      * Check if padding is too long, payload and padding must not exceed 2^14
4086      * - 3 = 16381 bytes in total.
4087      */
4088     OPENSSL_assert(payload + padding <= 16381);
4089
4090     /*-
4091      * Create HeartBeat message, we just use a sequence number
4092      * as payload to distuingish different messages and add
4093      * some random stuff.
4094      *  - Message Type, 1 byte
4095      *  - Payload Length, 2 bytes (unsigned int)
4096      *  - Payload, the sequence number (2 bytes uint)
4097      *  - Payload, random bytes (16 bytes uint)
4098      *  - Padding
4099      */
4100     buf = OPENSSL_malloc(1 + 2 + payload + padding);
4101     if (buf == NULL)
4102         return -1;
4103     p = buf;
4104     /* Message Type */
4105     *p++ = TLS1_HB_REQUEST;
4106     /* Payload length (18 bytes here) */
4107     s2n(payload, p);
4108     /* Sequence number */
4109     s2n(s->tlsext_hb_seq, p);
4110     /* 16 random bytes */
4111     if (RAND_bytes(p, 16) <= 0) {
4112         SSLerr(SSL_F_TLS1_HEARTBEAT, ERR_R_INTERNAL_ERROR);
4113         goto err;
4114     }
4115     p += 16;
4116     /* Random padding */
4117     if (RAND_bytes(p, padding) <= 0) {
4118         SSLerr(SSL_F_TLS1_HEARTBEAT, ERR_R_INTERNAL_ERROR);
4119         goto err;
4120     }
4121
4122     ret = ssl3_write_bytes(s, TLS1_RT_HEARTBEAT, buf, 3 + payload + padding);
4123     if (ret >= 0) {
4124         if (s->msg_callback)
4125             s->msg_callback(1, s->version, TLS1_RT_HEARTBEAT,
4126                             buf, 3 + payload + padding,
4127                             s, s->msg_callback_arg);
4128
4129         s->tlsext_hb_pending = 1;
4130     }
4131
4132 err:
4133     OPENSSL_free(buf);
4134
4135     return ret;
4136 }
4137 # endif
4138
4139 # define MAX_SIGALGLEN   (TLSEXT_hash_num * TLSEXT_signature_num * 2)
4140
4141 typedef struct {
4142     size_t sigalgcnt;
4143     int sigalgs[MAX_SIGALGLEN];
4144 } sig_cb_st;
4145
4146 static int sig_cb(const char *elem, int len, void *arg)
4147 {
4148     sig_cb_st *sarg = arg;
4149     size_t i;
4150     char etmp[20], *p;
4151     int sig_alg, hash_alg;
4152     if (elem == NULL)
4153         return 0;
4154     if (sarg->sigalgcnt == MAX_SIGALGLEN)
4155         return 0;
4156     if (len > (int)(sizeof(etmp) - 1))
4157         return 0;
4158     memcpy(etmp, elem, len);
4159     etmp[len] = 0;
4160     p = strchr(etmp, '+');
4161     if (!p)
4162         return 0;
4163     *p = 0;
4164     p++;
4165     if (!*p)
4166         return 0;
4167
4168     if (!strcmp(etmp, "RSA"))
4169         sig_alg = EVP_PKEY_RSA;
4170     else if (!strcmp(etmp, "DSA"))
4171         sig_alg = EVP_PKEY_DSA;
4172     else if (!strcmp(etmp, "ECDSA"))
4173         sig_alg = EVP_PKEY_EC;
4174     else
4175         return 0;
4176
4177     hash_alg = OBJ_sn2nid(p);
4178     if (hash_alg == NID_undef)
4179         hash_alg = OBJ_ln2nid(p);
4180     if (hash_alg == NID_undef)
4181         return 0;
4182
4183     for (i = 0; i < sarg->sigalgcnt; i += 2) {
4184         if (sarg->sigalgs[i] == sig_alg && sarg->sigalgs[i + 1] == hash_alg)
4185             return 0;
4186     }
4187     sarg->sigalgs[sarg->sigalgcnt++] = hash_alg;
4188     sarg->sigalgs[sarg->sigalgcnt++] = sig_alg;
4189     return 1;
4190 }
4191
4192 /*
4193  * Set suppored signature algorithms based on a colon separated list of the
4194  * form sig+hash e.g. RSA+SHA512:DSA+SHA512
4195  */
4196 int tls1_set_sigalgs_list(CERT *c, const char *str, int client)
4197 {
4198     sig_cb_st sig;
4199     sig.sigalgcnt = 0;
4200     if (!CONF_parse_list(str, ':', 1, sig_cb, &sig))
4201         return 0;
4202     if (c == NULL)
4203         return 1;
4204     return tls1_set_sigalgs(c, sig.sigalgs, sig.sigalgcnt, client);
4205 }
4206
4207 int tls1_set_sigalgs(CERT *c, const int *psig_nids, size_t salglen,
4208                      int client)
4209 {
4210     unsigned char *sigalgs, *sptr;
4211     int rhash, rsign;
4212     size_t i;
4213     if (salglen & 1)
4214         return 0;
4215     sigalgs = OPENSSL_malloc(salglen);
4216     if (sigalgs == NULL)
4217         return 0;
4218     for (i = 0, sptr = sigalgs; i < salglen; i += 2) {
4219         rhash = tls12_find_id(*psig_nids++, tls12_md,
4220                               sizeof(tls12_md) / sizeof(tls12_lookup));
4221         rsign = tls12_find_id(*psig_nids++, tls12_sig,
4222                               sizeof(tls12_sig) / sizeof(tls12_lookup));
4223
4224         if (rhash == -1 || rsign == -1)
4225             goto err;
4226         *sptr++ = rhash;
4227         *sptr++ = rsign;
4228     }
4229
4230     if (client) {
4231         if (c->client_sigalgs)
4232             OPENSSL_free(c->client_sigalgs);
4233         c->client_sigalgs = sigalgs;
4234         c->client_sigalgslen = salglen;
4235     } else {
4236         if (c->conf_sigalgs)
4237             OPENSSL_free(c->conf_sigalgs);
4238         c->conf_sigalgs = sigalgs;
4239         c->conf_sigalgslen = salglen;
4240     }
4241
4242     return 1;
4243
4244  err:
4245     OPENSSL_free(sigalgs);
4246     return 0;
4247 }
4248
4249 static int tls1_check_sig_alg(CERT *c, X509 *x, int default_nid)
4250 {
4251     int sig_nid;
4252     size_t i;
4253     if (default_nid == -1)
4254         return 1;
4255     sig_nid = X509_get_signature_nid(x);
4256     if (default_nid)
4257         return sig_nid == default_nid ? 1 : 0;
4258     for (i = 0; i < c->shared_sigalgslen; i++)
4259         if (sig_nid == c->shared_sigalgs[i].signandhash_nid)
4260             return 1;
4261     return 0;
4262 }
4263
4264 /* Check to see if a certificate issuer name matches list of CA names */
4265 static int ssl_check_ca_name(STACK_OF(X509_NAME) *names, X509 *x)
4266 {
4267     X509_NAME *nm;
4268     int i;
4269     nm = X509_get_issuer_name(x);
4270     for (i = 0; i < sk_X509_NAME_num(names); i++) {
4271         if (!X509_NAME_cmp(nm, sk_X509_NAME_value(names, i)))
4272             return 1;
4273     }
4274     return 0;
4275 }
4276
4277 /*
4278  * Check certificate chain is consistent with TLS extensions and is usable by
4279  * server. This servers two purposes: it allows users to check chains before
4280  * passing them to the server and it allows the server to check chains before
4281  * attempting to use them.
4282  */
4283
4284 /* Flags which need to be set for a certificate when stict mode not set */
4285
4286 # define CERT_PKEY_VALID_FLAGS \
4287         (CERT_PKEY_EE_SIGNATURE|CERT_PKEY_EE_PARAM)
4288 /* Strict mode flags */
4289 # define CERT_PKEY_STRICT_FLAGS \
4290          (CERT_PKEY_VALID_FLAGS|CERT_PKEY_CA_SIGNATURE|CERT_PKEY_CA_PARAM \
4291          | CERT_PKEY_ISSUER_NAME|CERT_PKEY_CERT_TYPE)
4292
4293 int tls1_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain,
4294                      int idx)
4295 {
4296     int i;
4297     int rv = 0;
4298     int check_flags = 0, strict_mode;
4299     CERT_PKEY *cpk = NULL;
4300     CERT *c = s->cert;
4301     unsigned int suiteb_flags = tls1_suiteb(s);
4302     /* idx == -1 means checking server chains */
4303     if (idx != -1) {
4304         /* idx == -2 means checking client certificate chains */
4305         if (idx == -2) {
4306             cpk = c->key;
4307             idx = cpk - c->pkeys;
4308         } else
4309             cpk = c->pkeys + idx;
4310         x = cpk->x509;
4311         pk = cpk->privatekey;
4312         chain = cpk->chain;
4313         strict_mode = c->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT;
4314         /* If no cert or key, forget it */
4315         if (!x || !pk)
4316             goto end;
4317 # ifdef OPENSSL_SSL_DEBUG_BROKEN_PROTOCOL
4318         /* Allow any certificate to pass test */
4319         if (s->cert->cert_flags & SSL_CERT_FLAG_BROKEN_PROTOCOL) {
4320             rv = CERT_PKEY_STRICT_FLAGS | CERT_PKEY_EXPLICIT_SIGN |
4321                 CERT_PKEY_VALID | CERT_PKEY_SIGN;
4322             cpk->valid_flags = rv;
4323             return rv;
4324         }
4325 # endif
4326     } else {
4327         if (!x || !pk)
4328             return 0;
4329         idx = ssl_cert_type(x, pk);
4330         if (idx == -1)
4331             return 0;
4332         cpk = c->pkeys + idx;
4333         if (c->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)
4334             check_flags = CERT_PKEY_STRICT_FLAGS;
4335         else
4336             check_flags = CERT_PKEY_VALID_FLAGS;
4337         strict_mode = 1;
4338     }
4339
4340     if (suiteb_flags) {
4341         int ok;
4342         if (check_flags)
4343             check_flags |= CERT_PKEY_SUITEB;
4344         ok = X509_chain_check_suiteb(NULL, x, chain, suiteb_flags);
4345         if (ok == X509_V_OK)
4346             rv |= CERT_PKEY_SUITEB;
4347         else if (!check_flags)
4348             goto end;
4349     }
4350
4351     /*
4352      * Check all signature algorithms are consistent with signature
4353      * algorithms extension if TLS 1.2 or later and strict mode.
4354      */
4355     if (TLS1_get_version(s) >= TLS1_2_VERSION && strict_mode) {
4356         int default_nid;
4357         unsigned char rsign = 0;
4358         if (c->peer_sigalgs)
4359             default_nid = 0;
4360         /* If no sigalgs extension use defaults from RFC5246 */
4361         else {
4362             switch (idx) {
4363             case SSL_PKEY_RSA_ENC:
4364             case SSL_PKEY_RSA_SIGN:
4365             case SSL_PKEY_DH_RSA:
4366                 rsign = TLSEXT_signature_rsa;
4367                 default_nid = NID_sha1WithRSAEncryption;
4368                 break;
4369
4370             case SSL_PKEY_DSA_SIGN:
4371             case SSL_PKEY_DH_DSA:
4372                 rsign = TLSEXT_signature_dsa;
4373                 default_nid = NID_dsaWithSHA1;
4374                 break;
4375
4376             case SSL_PKEY_ECC:
4377                 rsign = TLSEXT_signature_ecdsa;
4378                 default_nid = NID_ecdsa_with_SHA1;
4379                 break;
4380
4381             default:
4382                 default_nid = -1;
4383                 break;
4384             }
4385         }
4386         /*
4387          * If peer sent no signature algorithms extension and we have set
4388          * preferred signature algorithms check we support sha1.
4389          */
4390         if (default_nid > 0 && c->conf_sigalgs) {
4391             size_t j;
4392             const unsigned char *p = c->conf_sigalgs;
4393             for (j = 0; j < c->conf_sigalgslen; j += 2, p += 2) {
4394                 if (p[0] == TLSEXT_hash_sha1 && p[1] == rsign)
4395                     break;
4396             }
4397             if (j == c->conf_sigalgslen) {
4398                 if (check_flags)
4399                     goto skip_sigs;
4400                 else
4401                     goto end;
4402             }
4403         }
4404         /* Check signature algorithm of each cert in chain */
4405         if (!tls1_check_sig_alg(c, x, default_nid)) {
4406             if (!check_flags)
4407                 goto end;
4408         } else
4409             rv |= CERT_PKEY_EE_SIGNATURE;
4410         rv |= CERT_PKEY_CA_SIGNATURE;
4411         for (i = 0; i < sk_X509_num(chain); i++) {
4412             if (!tls1_check_sig_alg(c, sk_X509_value(chain, i), default_nid)) {
4413                 if (check_flags) {
4414                     rv &= ~CERT_PKEY_CA_SIGNATURE;
4415                     break;
4416                 } else
4417                     goto end;
4418             }
4419         }
4420     }
4421     /* Else not TLS 1.2, so mark EE and CA signing algorithms OK */
4422     else if (check_flags)
4423         rv |= CERT_PKEY_EE_SIGNATURE | CERT_PKEY_CA_SIGNATURE;
4424  skip_sigs:
4425     /* Check cert parameters are consistent */
4426     if (tls1_check_cert_param(s, x, check_flags ? 1 : 2))
4427         rv |= CERT_PKEY_EE_PARAM;
4428     else if (!check_flags)
4429         goto end;
4430     if (!s->server)
4431         rv |= CERT_PKEY_CA_PARAM;
4432     /* In strict mode check rest of chain too */
4433     else if (strict_mode) {
4434         rv |= CERT_PKEY_CA_PARAM;
4435         for (i = 0; i < sk_X509_num(chain); i++) {
4436             X509 *ca = sk_X509_value(chain, i);
4437             if (!tls1_check_cert_param(s, ca, 0)) {
4438                 if (check_flags) {
4439                     rv &= ~CERT_PKEY_CA_PARAM;
4440                     break;
4441                 } else
4442                     goto end;
4443             }
4444         }
4445     }
4446     if (!s->server && strict_mode) {
4447         STACK_OF(X509_NAME) *ca_dn;
4448         int check_type = 0;
4449         switch (pk->type) {
4450         case EVP_PKEY_RSA:
4451             check_type = TLS_CT_RSA_SIGN;
4452             break;
4453         case EVP_PKEY_DSA:
4454             check_type = TLS_CT_DSS_SIGN;
4455             break;
4456         case EVP_PKEY_EC:
4457             check_type = TLS_CT_ECDSA_SIGN;
4458             break;
4459         case EVP_PKEY_DH:
4460         case EVP_PKEY_DHX:
4461             {
4462                 int cert_type = X509_certificate_type(x, pk);
4463                 if (cert_type & EVP_PKS_RSA)
4464                     check_type = TLS_CT_RSA_FIXED_DH;
4465                 if (cert_type & EVP_PKS_DSA)
4466                     check_type = TLS_CT_DSS_FIXED_DH;
4467             }
4468         }
4469         if (check_type) {
4470             const unsigned char *ctypes;
4471             int ctypelen;
4472             if (c->ctypes) {
4473                 ctypes = c->ctypes;
4474                 ctypelen = (int)c->ctype_num;
4475             } else {
4476                 ctypes = (unsigned char *)s->s3->tmp.ctype;
4477                 ctypelen = s->s3->tmp.ctype_num;
4478             }
4479             for (i = 0; i < ctypelen; i++) {
4480                 if (ctypes[i] == check_type) {
4481                     rv |= CERT_PKEY_CERT_TYPE;
4482                     break;
4483                 }
4484             }
4485             if (!(rv & CERT_PKEY_CERT_TYPE) && !check_flags)
4486                 goto end;
4487         } else
4488             rv |= CERT_PKEY_CERT_TYPE;
4489
4490         ca_dn = s->s3->tmp.ca_names;
4491
4492         if (!sk_X509_NAME_num(ca_dn))
4493             rv |= CERT_PKEY_ISSUER_NAME;
4494
4495         if (!(rv & CERT_PKEY_ISSUER_NAME)) {
4496             if (ssl_check_ca_name(ca_dn, x))
4497                 rv |= CERT_PKEY_ISSUER_NAME;
4498         }
4499         if (!(rv & CERT_PKEY_ISSUER_NAME)) {
4500             for (i = 0; i < sk_X509_num(chain); i++) {
4501                 X509 *xtmp = sk_X509_value(chain, i);
4502                 if (ssl_check_ca_name(ca_dn, xtmp)) {
4503                     rv |= CERT_PKEY_ISSUER_NAME;
4504                     break;
4505                 }
4506             }
4507         }
4508         if (!check_flags && !(rv & CERT_PKEY_ISSUER_NAME))
4509             goto end;
4510     } else
4511         rv |= CERT_PKEY_ISSUER_NAME | CERT_PKEY_CERT_TYPE;
4512
4513     if (!check_flags || (rv & check_flags) == check_flags)
4514         rv |= CERT_PKEY_VALID;
4515
4516  end:
4517
4518     if (TLS1_get_version(s) >= TLS1_2_VERSION) {
4519         if (cpk->valid_flags & CERT_PKEY_EXPLICIT_SIGN)
4520             rv |= CERT_PKEY_EXPLICIT_SIGN | CERT_PKEY_SIGN;
4521         else if (cpk->digest)
4522             rv |= CERT_PKEY_SIGN;
4523     } else
4524         rv |= CERT_PKEY_SIGN | CERT_PKEY_EXPLICIT_SIGN;
4525
4526     /*
4527      * When checking a CERT_PKEY structure all flags are irrelevant if the
4528      * chain is invalid.
4529      */
4530     if (!check_flags) {
4531         if (rv & CERT_PKEY_VALID)
4532             cpk->valid_flags = rv;
4533         else {
4534             /* Preserve explicit sign flag, clear rest */
4535             cpk->valid_flags &= CERT_PKEY_EXPLICIT_SIGN;
4536             return 0;
4537         }
4538     }
4539     return rv;
4540 }
4541
4542 /* Set validity of certificates in an SSL structure */
4543 void tls1_set_cert_validity(SSL *s)
4544 {
4545     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_RSA_ENC);
4546     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_RSA_SIGN);
4547     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_DSA_SIGN);
4548     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_DH_RSA);
4549     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_DH_DSA);
4550     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_ECC);
4551 }
4552
4553 /* User level utiity function to check a chain is suitable */
4554 int SSL_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain)
4555 {
4556     return tls1_check_chain(s, x, pk, chain, -1);
4557 }
4558
4559 #endif