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