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