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