ssl/t1_lib.c

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