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