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