ssl/t1_lib.c

   1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   2  * All rights reserved.
   3  *
   4  * This package is an SSL implementation written
   5  * by Eric Young (eay@cryptsoft.com).
   6  * The implementation was written so as to conform with Netscapes SSL.
   7  *
   8  * This library is free for commercial and non-commercial use as long as
   9  * the following conditions are aheared to.  The following conditions
  10  * apply to all code found in this distribution, be it the RC4, RSA,
  11  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  12  * included with this distribution is covered by the same copyright terms
  13  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  14  *
  15  * Copyright remains Eric Young's, and as such any Copyright notices in
  16  * the code are not to be removed.
  17  * If this package is used in a product, Eric Young should be given attribution
  18  * as the author of the parts of the library used.
  19  * This can be in the form of a textual message at program startup or
  20  * in documentation (online or textual) provided with the package.
  21  *
  22  * Redistribution and use in source and binary forms, with or without
  23  * modification, are permitted provided that the following conditions
  24  * are met:
  25  * 1. Redistributions of source code must retain the copyright
  26  *    notice, this list of conditions and the following disclaimer.
  27  * 2. Redistributions in binary form must reproduce the above copyright
  28  *    notice, this list of conditions and the following disclaimer in the
  29  *    documentation and/or other materials provided with the distribution.
  30  * 3. All advertising materials mentioning features or use of this software
  31  *    must display the following acknowledgement:
  32  *    "This product includes cryptographic software written by
  33  *     Eric Young (eay@cryptsoft.com)"
  34  *    The word 'cryptographic' can be left out if the rouines from the library
  35  *    being used are not cryptographic related :-).
  36  * 4. If you include any Windows specific code (or a derivative thereof) from
  37  *    the apps directory (application code) you must include an acknowledgement:
  38  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  39  *
  40  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  50  * SUCH DAMAGE.
  51  *
  52  * The licence and distribution terms for any publically available version or
  53  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  54  * copied and put under another distribution licence
  55  * [including the GNU Public Licence.]
  56  */
  57 /* ====================================================================
  58  * Copyright (c) 1998-2007 The OpenSSL Project.  All rights reserved.
  59  *
  60  * Redistribution and use in source and binary forms, with or without
  61  * modification, are permitted provided that the following conditions
  62  * are met:
  63  *
  64  * 1. Redistributions of source code must retain the above copyright
  65  *    notice, this list of conditions and the following disclaimer.
  66  *
  67  * 2. Redistributions in binary form must reproduce the above copyright
  68  *    notice, this list of conditions and the following disclaimer in
  69  *    the documentation and/or other materials provided with the
  70  *    distribution.
  71  *
  72  * 3. All advertising materials mentioning features or use of this
  73  *    software must display the following acknowledgment:
  74  *    "This product includes software developed by the OpenSSL Project
  75  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  76  *
  77  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  78  *    endorse or promote products derived from this software without
  79  *    prior written permission. For written permission, please contact
  80  *    openssl-core@openssl.org.
  81  *
  82  * 5. Products derived from this software may not be called "OpenSSL"
  83  *    nor may "OpenSSL" appear in their names without prior written
  84  *    permission of the OpenSSL Project.
  85  *
  86  * 6. Redistributions of any form whatsoever must retain the following
  87  *    acknowledgment:
  88  *    "This product includes software developed by the OpenSSL Project
  89  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  90  *
  91  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  92  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  93  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  94  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  95  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  96  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  97  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  98  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  99  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 100  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 101  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 102  * OF THE POSSIBILITY OF SUCH DAMAGE.
 103  * ====================================================================
 104  *
 105  * This product includes cryptographic software written by Eric Young
 106  * (eay@cryptsoft.com).  This product includes software written by Tim
 107  * Hudson (tjh@cryptsoft.com).
 108  *
 109  */
 110
 111 #include <stdio.h>
 112 #include <openssl/objects.h>
 113 #include <openssl/evp.h>
 114 #include <openssl/hmac.h>
 115 #include <openssl/ocsp.h>
 116 #include <openssl/rand.h>
 117 #ifndef OPENSSL_NO_DH
 118 # include <openssl/dh.h>
 119 # include <openssl/bn.h>
 120 #endif
 121 #include "ssl_locl.h"
 122
 123 static int tls_decrypt_ticket(SSL *s, const unsigned char *tick, int ticklen,
 124                               const unsigned char *sess_id, int sesslen,
 125                               SSL_SESSION **psess);
 126 static int ssl_check_clienthello_tlsext_early(SSL *s);
 127 int ssl_check_serverhello_tlsext(SSL *s);
 128
 129 SSL3_ENC_METHOD const TLSv1_enc_data = {
 130     tls1_enc,
 131     tls1_mac,
 132     tls1_setup_key_block,
 133     tls1_generate_master_secret,
 134     tls1_change_cipher_state,
 135     tls1_final_finish_mac,
 136     TLS1_FINISH_MAC_LENGTH,
 137     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
 138     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
 139     tls1_alert_code,
 140     tls1_export_keying_material,
 141     0,
 142     SSL3_HM_HEADER_LENGTH,
 143     ssl3_set_handshake_header,
 144     ssl3_handshake_write
 145 };
 146
 147 SSL3_ENC_METHOD const TLSv1_1_enc_data = {
 148     tls1_enc,
 149     tls1_mac,
 150     tls1_setup_key_block,
 151     tls1_generate_master_secret,
 152     tls1_change_cipher_state,
 153     tls1_final_finish_mac,
 154     TLS1_FINISH_MAC_LENGTH,
 155     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
 156     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
 157     tls1_alert_code,
 158     tls1_export_keying_material,
 159     SSL_ENC_FLAG_EXPLICIT_IV,
 160     SSL3_HM_HEADER_LENGTH,
 161     ssl3_set_handshake_header,
 162     ssl3_handshake_write
 163 };
 164
 165 SSL3_ENC_METHOD const TLSv1_2_enc_data = {
 166     tls1_enc,
 167     tls1_mac,
 168     tls1_setup_key_block,
 169     tls1_generate_master_secret,
 170     tls1_change_cipher_state,
 171     tls1_final_finish_mac,
 172     TLS1_FINISH_MAC_LENGTH,
 173     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
 174     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
 175     tls1_alert_code,
 176     tls1_export_keying_material,
 177     SSL_ENC_FLAG_EXPLICIT_IV | SSL_ENC_FLAG_SIGALGS | SSL_ENC_FLAG_SHA256_PRF
 178         | SSL_ENC_FLAG_TLS1_2_CIPHERS,
 179     SSL3_HM_HEADER_LENGTH,
 180     ssl3_set_handshake_header,
 181     ssl3_handshake_write
 182 };
 183
 184 long tls1_default_timeout(void)
 185 {
 186     /*
 187      * 2 hours, the 24 hours mentioned in the TLSv1 spec is way too long for
 188      * http, the cache would over fill
 189      */
 190     return (60 * 60 * 2);
 191 }
 192
 193 int tls1_new(SSL *s)
 194 {
 195     if (!ssl3_new(s))
 196         return (0);
 197     s->method->ssl_clear(s);
 198     return (1);
 199 }
 200
 201 void tls1_free(SSL *s)
 202 {
 203     OPENSSL_free(s->tlsext_session_ticket);
 204     ssl3_free(s);
 205 }
 206
 207 void tls1_clear(SSL *s)
 208 {
 209     ssl3_clear(s);
 210     if (s->method->version == TLS_ANY_VERSION)
 211         s->version = TLS_MAX_VERSION;
 212     else
 213         s->version = s->method->version;
 214 }
 215
 216 #ifndef OPENSSL_NO_EC
 217
 218 typedef struct {
 219     int nid;                    /* Curve NID */
 220     int secbits;                /* Bits of security (from SP800-57) */
 221     unsigned int flags;         /* Flags: currently just field type */
 222 } tls_curve_info;
 223
 224 # define TLS_CURVE_TYPE          0x1
 225 # define TLS_CURVE_CHAR2         0x1
 226 # define TLS_CURVE_PRIME         0x0
 227
 228 /*
 229  * Table of curve information.
 230  * NB: do not delete entries or reorder this array. It is used as a lookup
 231  * table: the index of each entry is one less than the TLS curve id.
 232  */
 233
 234 static const tls_curve_info nid_list[] = {
 235     {NID_sect163k1, 80, TLS_CURVE_CHAR2}, /* sect163k1 (1) */
 236     {NID_sect163r1, 80, TLS_CURVE_CHAR2}, /* sect163r1 (2) */
 237     {NID_sect163r2, 80, TLS_CURVE_CHAR2}, /* sect163r2 (3) */
 238     {NID_sect193r1, 80, TLS_CURVE_CHAR2}, /* sect193r1 (4) */
 239     {NID_sect193r2, 80, TLS_CURVE_CHAR2}, /* sect193r2 (5) */
 240     {NID_sect233k1, 112, TLS_CURVE_CHAR2}, /* sect233k1 (6) */
 241     {NID_sect233r1, 112, TLS_CURVE_CHAR2}, /* sect233r1 (7) */
 242     {NID_sect239k1, 112, TLS_CURVE_CHAR2}, /* sect239k1 (8) */
 243     {NID_sect283k1, 128, TLS_CURVE_CHAR2}, /* sect283k1 (9) */
 244     {NID_sect283r1, 128, TLS_CURVE_CHAR2}, /* sect283r1 (10) */
 245     {NID_sect409k1, 192, TLS_CURVE_CHAR2}, /* sect409k1 (11) */
 246     {NID_sect409r1, 192, TLS_CURVE_CHAR2}, /* sect409r1 (12) */
 247     {NID_sect571k1, 256, TLS_CURVE_CHAR2}, /* sect571k1 (13) */
 248     {NID_sect571r1, 256, TLS_CURVE_CHAR2}, /* sect571r1 (14) */
 249     {NID_secp160k1, 80, TLS_CURVE_PRIME}, /* secp160k1 (15) */
 250     {NID_secp160r1, 80, TLS_CURVE_PRIME}, /* secp160r1 (16) */
 251     {NID_secp160r2, 80, TLS_CURVE_PRIME}, /* secp160r2 (17) */
 252     {NID_secp192k1, 80, TLS_CURVE_PRIME}, /* secp192k1 (18) */
 253     {NID_X9_62_prime192v1, 80, TLS_CURVE_PRIME}, /* secp192r1 (19) */
 254     {NID_secp224k1, 112, TLS_CURVE_PRIME}, /* secp224k1 (20) */
 255     {NID_secp224r1, 112, TLS_CURVE_PRIME}, /* secp224r1 (21) */
 256     {NID_secp256k1, 128, TLS_CURVE_PRIME}, /* secp256k1 (22) */
 257     {NID_X9_62_prime256v1, 128, TLS_CURVE_PRIME}, /* secp256r1 (23) */
 258     {NID_secp384r1, 192, TLS_CURVE_PRIME}, /* secp384r1 (24) */
 259     {NID_secp521r1, 256, TLS_CURVE_PRIME}, /* secp521r1 (25) */
 260     {NID_brainpoolP256r1, 128, TLS_CURVE_PRIME}, /* brainpoolP256r1 (26) */
 261     {NID_brainpoolP384r1, 192, TLS_CURVE_PRIME}, /* brainpoolP384r1 (27) */
 262     {NID_brainpoolP512r1, 256, TLS_CURVE_PRIME}, /* brainpool512r1 (28) */
 263 };
 264
 265 static const unsigned char ecformats_default[] = {
 266     TLSEXT_ECPOINTFORMAT_uncompressed,
 267     TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime,
 268     TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2
 269 };
 270
 271 /* The default curves */
 272 static const unsigned char eccurves_default[] = {
 273     /* Prefer P-256 which has the fastest and most secure implementations. */
 274     0, 23,                      /* secp256r1 (23) */
 275     /* Other >= 256-bit prime curves. */
 276     0, 25,                      /* secp521r1 (25) */
 277     0, 28,                      /* brainpool512r1 (28) */
 278     0, 27,                      /* brainpoolP384r1 (27) */
 279     0, 24,                      /* secp384r1 (24) */
 280     0, 26,                      /* brainpoolP256r1 (26) */
 281     0, 22,                      /* secp256k1 (22) */
 282     /* >= 256-bit binary curves. */
 283     0, 14,                      /* sect571r1 (14) */
 284     0, 13,                      /* sect571k1 (13) */
 285     0, 11,                      /* sect409k1 (11) */
 286     0, 12,                      /* sect409r1 (12) */
 287     0, 9,                       /* sect283k1 (9) */
 288     0, 10,                      /* sect283r1 (10) */
 289 };
 290
 291 static const unsigned char eccurves_all[] = {
 292     /* Prefer P-256 which has the fastest and most secure implementations. */
 293     0, 23,                      /* secp256r1 (23) */
 294     /* Other >= 256-bit prime curves. */
 295     0, 25,                      /* secp521r1 (25) */
 296     0, 28,                      /* brainpool512r1 (28) */
 297     0, 27,                      /* brainpoolP384r1 (27) */
 298     0, 24,                      /* secp384r1 (24) */
 299     0, 26,                      /* brainpoolP256r1 (26) */
 300     0, 22,                      /* secp256k1 (22) */
 301     /* >= 256-bit binary curves. */
 302     0, 14,                      /* sect571r1 (14) */
 303     0, 13,                      /* sect571k1 (13) */
 304     0, 11,                      /* sect409k1 (11) */
 305     0, 12,                      /* sect409r1 (12) */
 306     0, 9,                       /* sect283k1 (9) */
 307     0, 10,                      /* sect283r1 (10) */
 308     /*
 309      * Remaining curves disabled by default but still permitted if set
 310      * via an explicit callback or parameters.
 311      */
 312     0, 20,                      /* secp224k1 (20) */
 313     0, 21,                      /* secp224r1 (21) */
 314     0, 18,                      /* secp192k1 (18) */
 315     0, 19,                      /* secp192r1 (19) */
 316     0, 15,                      /* secp160k1 (15) */
 317     0, 16,                      /* secp160r1 (16) */
 318     0, 17,                      /* secp160r2 (17) */
 319     0, 8,                       /* sect239k1 (8) */
 320     0, 6,                       /* sect233k1 (6) */
 321     0, 7,                       /* sect233r1 (7) */
 322     0, 4,                       /* sect193r1 (4) */
 323     0, 5,                       /* sect193r2 (5) */
 324     0, 1,                       /* sect163k1 (1) */
 325     0, 2,                       /* sect163r1 (2) */
 326     0, 3,                       /* sect163r2 (3) */
 327 };
 328
 329
 330 static const unsigned char suiteb_curves[] = {
 331     0, TLSEXT_curve_P_256,
 332     0, TLSEXT_curve_P_384
 333 };
 334
 335 int tls1_ec_curve_id2nid(int curve_id)
 336 {
 337     /* ECC curves from RFC 4492 and RFC 7027 */
 338     if ((curve_id < 1) || ((unsigned int)curve_id > OSSL_NELEM(nid_list)))
 339         return 0;
 340     return nid_list[curve_id - 1].nid;
 341 }
 342
 343 int tls1_ec_nid2curve_id(int nid)
 344 {
 345     size_t i;
 346     for (i = 0; i < OSSL_NELEM(nid_list); i++) {
 347         if (nid_list[i].nid == nid)
 348             return i + 1;
 349     }
 350     return 0;
 351 }
 352
 353 /*
 354  * Get curves list, if "sess" is set return client curves otherwise
 355  * preferred list.
 356  * Sets |num_curves| to the number of curves in the list, i.e.,
 357  * the length of |pcurves| is 2 * num_curves.
 358  * Returns 1 on success and 0 if the client curves list has invalid format.
 359  * The latter indicates an internal error: we should not be accepting such
 360  * lists in the first place.
 361  * TODO(emilia): we should really be storing the curves list in explicitly
 362  * parsed form instead. (However, this would affect binary compatibility
 363  * so cannot happen in the 1.0.x series.)
 364  */
 365 static int tls1_get_curvelist(SSL *s, int sess,
 366                               const unsigned char **pcurves,
 367                               size_t *num_curves)
 368 {
 369     size_t pcurveslen = 0;
 370     if (sess) {
 371         *pcurves = s->session->tlsext_ellipticcurvelist;
 372         pcurveslen = s->session->tlsext_ellipticcurvelist_length;
 373     } else {
 374         /* For Suite B mode only include P-256, P-384 */
 375         switch (tls1_suiteb(s)) {
 376         case SSL_CERT_FLAG_SUITEB_128_LOS:
 377             *pcurves = suiteb_curves;
 378             pcurveslen = sizeof(suiteb_curves);
 379             break;
 380
 381         case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY:
 382             *pcurves = suiteb_curves;
 383             pcurveslen = 2;
 384             break;
 385
 386         case SSL_CERT_FLAG_SUITEB_192_LOS:
 387             *pcurves = suiteb_curves + 2;
 388             pcurveslen = 2;
 389             break;
 390         default:
 391             *pcurves = s->tlsext_ellipticcurvelist;
 392             pcurveslen = s->tlsext_ellipticcurvelist_length;
 393         }
 394         if (!*pcurves) {
 395             *pcurves = eccurves_default;
 396             pcurveslen = sizeof(eccurves_default);
 397         }
 398     }
 399
 400     /* We do not allow odd length arrays to enter the system. */
 401     if (pcurveslen & 1) {
 402         SSLerr(SSL_F_TLS1_GET_CURVELIST, ERR_R_INTERNAL_ERROR);
 403         *num_curves = 0;
 404         return 0;
 405     } else {
 406         *num_curves = pcurveslen / 2;
 407         return 1;
 408     }
 409 }
 410
 411 /* See if curve is allowed by security callback */
 412 static int tls_curve_allowed(SSL *s, const unsigned char *curve, int op)
 413 {
 414     const tls_curve_info *cinfo;
 415     if (curve[0])
 416         return 1;
 417     if ((curve[1] < 1) || ((size_t)curve[1] > OSSL_NELEM(nid_list)))
 418         return 0;
 419     cinfo = &nid_list[curve[1] - 1];
 420 # ifdef OPENSSL_NO_EC2M
 421     if (cinfo->flags & TLS_CURVE_CHAR2)
 422         return 0;
 423 # endif
 424     return ssl_security(s, op, cinfo->secbits, cinfo->nid, (void *)curve);
 425 }
 426
 427 /* Check a curve is one of our preferences */
 428 int tls1_check_curve(SSL *s, const unsigned char *p, size_t len)
 429 {
 430     const unsigned char *curves;
 431     size_t num_curves, i;
 432     unsigned int suiteb_flags = tls1_suiteb(s);
 433     if (len != 3 || p[0] != NAMED_CURVE_TYPE)
 434         return 0;
 435     /* Check curve matches Suite B preferences */
 436     if (suiteb_flags) {
 437         unsigned long cid = s->s3->tmp.new_cipher->id;
 438         if (p[1])
 439             return 0;
 440         if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256) {
 441             if (p[2] != TLSEXT_curve_P_256)
 442                 return 0;
 443         } else if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384) {
 444             if (p[2] != TLSEXT_curve_P_384)
 445                 return 0;
 446         } else                  /* Should never happen */
 447             return 0;
 448     }
 449     if (!tls1_get_curvelist(s, 0, &curves, &num_curves))
 450         return 0;
 451     for (i = 0; i < num_curves; i++, curves += 2) {
 452         if (p[1] == curves[0] && p[2] == curves[1])
 453             return tls_curve_allowed(s, p + 1, SSL_SECOP_CURVE_CHECK);
 454     }
 455     return 0;
 456 }
 457
 458 /*-
 459  * For nmatch >= 0, return the NID of the |nmatch|th shared curve or NID_undef
 460  * if there is no match.
 461  * For nmatch == -1, return number of matches
 462  * For nmatch == -2, return the NID of the curve to use for
 463  * an EC tmp key, or NID_undef if there is no match.
 464  */
 465 int tls1_shared_curve(SSL *s, int nmatch)
 466 {
 467     const unsigned char *pref, *supp;
 468     size_t num_pref, num_supp, i, j;
 469     int k;
 470     /* Can't do anything on client side */
 471     if (s->server == 0)
 472         return -1;
 473     if (nmatch == -2) {
 474         if (tls1_suiteb(s)) {
 475             /*
 476              * For Suite B ciphersuite determines curve: we already know
 477              * these are acceptable due to previous checks.
 478              */
 479             unsigned long cid = s->s3->tmp.new_cipher->id;
 480             if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)
 481                 return NID_X9_62_prime256v1; /* P-256 */
 482             if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384)
 483                 return NID_secp384r1; /* P-384 */
 484             /* Should never happen */
 485             return NID_undef;
 486         }
 487         /* If not Suite B just return first preference shared curve */
 488         nmatch = 0;
 489     }
 490     /*
 491      * Avoid truncation. tls1_get_curvelist takes an int
 492      * but s->options is a long...
 493      */
 494     if (!tls1_get_curvelist
 495         (s, (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE) != 0, &supp,
 496          &num_supp))
 497         /* In practice, NID_undef == 0 but let's be precise. */
 498         return nmatch == -1 ? 0 : NID_undef;
 499     if (!tls1_get_curvelist
 500         (s, !(s->options & SSL_OP_CIPHER_SERVER_PREFERENCE), &pref,
 501          &num_pref))
 502         return nmatch == -1 ? 0 : NID_undef;
 503
 504     /*
 505      * If the client didn't send the elliptic_curves extension all of them
 506      * are allowed.
 507      */
 508     if (num_supp == 0 && (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE) != 0) {
 509         supp = eccurves_all;
 510         num_supp = sizeof(eccurves_all) / 2;
 511     } else if (num_pref == 0 &&
 512         (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE) == 0) {
 513         pref = eccurves_all;
 514         num_pref = sizeof(eccurves_all) / 2;
 515     }
 516
 517     k = 0;
 518     for (i = 0; i < num_pref; i++, pref += 2) {
 519         const unsigned char *tsupp = supp;
 520         for (j = 0; j < num_supp; j++, tsupp += 2) {
 521             if (pref[0] == tsupp[0] && pref[1] == tsupp[1]) {
 522                 if (!tls_curve_allowed(s, pref, SSL_SECOP_CURVE_SHARED))
 523                     continue;
 524                 if (nmatch == k) {
 525                     int id = (pref[0] << 8) | pref[1];
 526                     return tls1_ec_curve_id2nid(id);
 527                 }
 528                 k++;
 529             }
 530         }
 531     }
 532     if (nmatch == -1)
 533         return k;
 534     /* Out of range (nmatch > k). */
 535     return NID_undef;
 536 }
 537
 538 int tls1_set_curves(unsigned char **pext, size_t *pextlen,
 539                     int *curves, size_t ncurves)
 540 {
 541     unsigned char *clist, *p;
 542     size_t i;
 543     /*
 544      * Bitmap of curves included to detect duplicates: only works while curve
 545      * ids < 32
 546      */
 547     unsigned long dup_list = 0;
 548     clist = OPENSSL_malloc(ncurves * 2);
 549     if (clist == NULL)
 550         return 0;
 551     for (i = 0, p = clist; i < ncurves; i++) {
 552         unsigned long idmask;
 553         int id;
 554         id = tls1_ec_nid2curve_id(curves[i]);
 555         idmask = 1L << id;
 556         if (!id || (dup_list & idmask)) {
 557             OPENSSL_free(clist);
 558             return 0;
 559         }
 560         dup_list |= idmask;
 561         s2n(id, p);
 562     }
 563     OPENSSL_free(*pext);
 564     *pext = clist;
 565     *pextlen = ncurves * 2;
 566     return 1;
 567 }
 568
 569 # define MAX_CURVELIST   28
 570
 571 typedef struct {
 572     size_t nidcnt;
 573     int nid_arr[MAX_CURVELIST];
 574 } nid_cb_st;
 575
 576 static int nid_cb(const char *elem, int len, void *arg)
 577 {
 578     nid_cb_st *narg = arg;
 579     size_t i;
 580     int nid;
 581     char etmp[20];
 582     if (elem == NULL)
 583         return 0;
 584     if (narg->nidcnt == MAX_CURVELIST)
 585         return 0;
 586     if (len > (int)(sizeof(etmp) - 1))
 587         return 0;
 588     memcpy(etmp, elem, len);
 589     etmp[len] = 0;
 590     nid = EC_curve_nist2nid(etmp);
 591     if (nid == NID_undef)
 592         nid = OBJ_sn2nid(etmp);
 593     if (nid == NID_undef)
 594         nid = OBJ_ln2nid(etmp);
 595     if (nid == NID_undef)
 596         return 0;
 597     for (i = 0; i < narg->nidcnt; i++)
 598         if (narg->nid_arr[i] == nid)
 599             return 0;
 600     narg->nid_arr[narg->nidcnt++] = nid;
 601     return 1;
 602 }
 603
 604 /* Set curves based on a colon separate list */
 605 int tls1_set_curves_list(unsigned char **pext, size_t *pextlen,
 606                          const char *str)
 607 {
 608     nid_cb_st ncb;
 609     ncb.nidcnt = 0;
 610     if (!CONF_parse_list(str, ':', 1, nid_cb, &ncb))
 611         return 0;
 612     if (pext == NULL)
 613         return 1;
 614     return tls1_set_curves(pext, pextlen, ncb.nid_arr, ncb.nidcnt);
 615 }
 616
 617 /* For an EC key set TLS id and required compression based on parameters */
 618 static int tls1_set_ec_id(unsigned char *curve_id, unsigned char *comp_id,
 619                           EC_KEY *ec)
 620 {
 621     int id;
 622     const EC_GROUP *grp;
 623     if (!ec)
 624         return 0;
 625     /* Determine if it is a prime field */
 626     grp = EC_KEY_get0_group(ec);
 627     if (!grp)
 628         return 0;
 629     /* Determine curve ID */
 630     id = EC_GROUP_get_curve_name(grp);
 631     id = tls1_ec_nid2curve_id(id);
 632     /* If no id return error: we don't support arbitrary explicit curves */
 633     if (id == 0)
 634         return 0;
 635     curve_id[0] = 0;
 636     curve_id[1] = (unsigned char)id;
 637     if (comp_id) {
 638         if (EC_KEY_get0_public_key(ec) == NULL)
 639             return 0;
 640         if (EC_KEY_get_conv_form(ec) == POINT_CONVERSION_UNCOMPRESSED) {
 641             *comp_id = TLSEXT_ECPOINTFORMAT_uncompressed;
 642         } else {
 643             if ((nid_list[id - 1].flags & TLS_CURVE_TYPE) == TLS_CURVE_PRIME)
 644                 *comp_id = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime;
 645             else
 646                 *comp_id = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2;
 647         }
 648     }
 649     return 1;
 650 }
 651
 652 /* Check an EC key is compatible with extensions */
 653 static int tls1_check_ec_key(SSL *s,
 654                              unsigned char *curve_id, unsigned char *comp_id)
 655 {
 656     const unsigned char *pformats, *pcurves;
 657     size_t num_formats, num_curves, i;
 658     int j;
 659     /*
 660      * If point formats extension present check it, otherwise everything is
 661      * supported (see RFC4492).
 662      */
 663     if (comp_id && s->session->tlsext_ecpointformatlist) {
 664         pformats = s->session->tlsext_ecpointformatlist;
 665         num_formats = s->session->tlsext_ecpointformatlist_length;
 666         for (i = 0; i < num_formats; i++, pformats++) {
 667             if (*comp_id == *pformats)
 668                 break;
 669         }
 670         if (i == num_formats)
 671             return 0;
 672     }
 673     if (!curve_id)
 674         return 1;
 675     /* Check curve is consistent with client and server preferences */
 676     for (j = 0; j <= 1; j++) {
 677         if (!tls1_get_curvelist(s, j, &pcurves, &num_curves))
 678             return 0;
 679         if (j == 1 && num_curves == 0) {
 680             /*
 681              * If we've not received any curves then skip this check.
 682              * RFC 4492 does not require the supported elliptic curves extension
 683              * so if it is not sent we can just choose any curve.
 684              * It is invalid to send an empty list in the elliptic curves
 685              * extension, so num_curves == 0 always means no extension.
 686              */
 687             break;
 688         }
 689         for (i = 0; i < num_curves; i++, pcurves += 2) {
 690             if (pcurves[0] == curve_id[0] && pcurves[1] == curve_id[1])
 691                 break;
 692         }
 693         if (i == num_curves)
 694             return 0;
 695         /* For clients can only check sent curve list */
 696         if (!s->server)
 697             break;
 698     }
 699     return 1;
 700 }
 701
 702 static void tls1_get_formatlist(SSL *s, const unsigned char **pformats,
 703                                 size_t *num_formats)
 704 {
 705     /*
 706      * If we have a custom point format list use it otherwise use default
 707      */
 708     if (s->tlsext_ecpointformatlist) {
 709         *pformats = s->tlsext_ecpointformatlist;
 710         *num_formats = s->tlsext_ecpointformatlist_length;
 711     } else {
 712         *pformats = ecformats_default;
 713         /* For Suite B we don't support char2 fields */
 714         if (tls1_suiteb(s))
 715             *num_formats = sizeof(ecformats_default) - 1;
 716         else
 717             *num_formats = sizeof(ecformats_default);
 718     }
 719 }
 720
 721 /*
 722  * Check cert parameters compatible with extensions: currently just checks EC
 723  * certificates have compatible curves and compression.
 724  */
 725 static int tls1_check_cert_param(SSL *s, X509 *x, int set_ee_md)
 726 {
 727     unsigned char comp_id, curve_id[2];
 728     EVP_PKEY *pkey;
 729     int rv;
 730     pkey = X509_get0_pubkey(x);
 731     if (!pkey)
 732         return 0;
 733     /* If not EC nothing to do */
 734     if (EVP_PKEY_id(pkey) != EVP_PKEY_EC)
 735         return 1;
 736     rv = tls1_set_ec_id(curve_id, &comp_id, EVP_PKEY_get0_EC_KEY(pkey));
 737     if (!rv)
 738         return 0;
 739     /*
 740      * Can't check curve_id for client certs as we don't have a supported
 741      * curves extension.
 742      */
 743     rv = tls1_check_ec_key(s, s->server ? curve_id : NULL, &comp_id);
 744     if (!rv)
 745         return 0;
 746     /*
 747      * Special case for suite B. We *MUST* sign using SHA256+P-256 or
 748      * SHA384+P-384, adjust digest if necessary.
 749      */
 750     if (set_ee_md && tls1_suiteb(s)) {
 751         int check_md;
 752         size_t i;
 753         CERT *c = s->cert;
 754         if (curve_id[0])
 755             return 0;
 756         /* Check to see we have necessary signing algorithm */
 757         if (curve_id[1] == TLSEXT_curve_P_256)
 758             check_md = NID_ecdsa_with_SHA256;
 759         else if (curve_id[1] == TLSEXT_curve_P_384)
 760             check_md = NID_ecdsa_with_SHA384;
 761         else
 762             return 0;           /* Should never happen */
 763         for (i = 0; i < c->shared_sigalgslen; i++)
 764             if (check_md == c->shared_sigalgs[i].signandhash_nid)
 765                 break;
 766         if (i == c->shared_sigalgslen)
 767             return 0;
 768         if (set_ee_md == 2) {
 769             if (check_md == NID_ecdsa_with_SHA256)
 770                 s->s3->tmp.md[SSL_PKEY_ECC] = EVP_sha256();
 771             else
 772                 s->s3->tmp.md[SSL_PKEY_ECC] = EVP_sha384();
 773         }
 774     }
 775     return rv;
 776 }
 777
 778 # ifndef OPENSSL_NO_EC
 779 /*
 780  * tls1_check_ec_tmp_key - Check EC temporary key compatiblity
 781  * @s: SSL connection
 782  * @cid: Cipher ID we're considering using
 783  *
 784  * Checks that the kECDHE cipher suite we're considering using
 785  * is compatible with the client extensions.
 786  *
 787  * Returns 0 when the cipher can't be used or 1 when it can.
 788  */
 789 int tls1_check_ec_tmp_key(SSL *s, unsigned long cid)
 790 {
 791 #  ifdef OPENSSL_SSL_DEBUG_BROKEN_PROTOCOL
 792     /* Allow any curve: not just those peer supports */
 793     if (s->cert->cert_flags & SSL_CERT_FLAG_BROKEN_PROTOCOL)
 794         return 1;
 795 #  endif
 796     /*
 797      * If Suite B, AES128 MUST use P-256 and AES256 MUST use P-384, no other
 798      * curves permitted.
 799      */
 800     if (tls1_suiteb(s)) {
 801         unsigned char curve_id[2];
 802         /* Curve to check determined by ciphersuite */
 803         if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)
 804             curve_id[1] = TLSEXT_curve_P_256;
 805         else if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384)
 806             curve_id[1] = TLSEXT_curve_P_384;
 807         else
 808             return 0;
 809         curve_id[0] = 0;
 810         /* Check this curve is acceptable */
 811         if (!tls1_check_ec_key(s, curve_id, NULL))
 812             return 0;
 813         return 1;
 814     }
 815     /* Need a shared curve */
 816     if (tls1_shared_curve(s, 0))
 817         return 1;
 818     return 0;
 819 }
 820 # endif                         /* OPENSSL_NO_EC */
 821
 822 #else
 823
 824 static int tls1_check_cert_param(SSL *s, X509 *x, int set_ee_md)
 825 {
 826     return 1;
 827 }
 828
 829 #endif                          /* OPENSSL_NO_EC */
 830
 831 /*
 832  * List of supported signature algorithms and hashes. Should make this
 833  * customisable at some point, for now include everything we support.
 834  */
 835
 836 #ifdef OPENSSL_NO_RSA
 837 # define tlsext_sigalg_rsa(md) /* */
 838 #else
 839 # define tlsext_sigalg_rsa(md) md, TLSEXT_signature_rsa,
 840 #endif
 841
 842 #ifdef OPENSSL_NO_DSA
 843 # define tlsext_sigalg_dsa(md) /* */
 844 #else
 845 # define tlsext_sigalg_dsa(md) md, TLSEXT_signature_dsa,
 846 #endif
 847
 848 #ifdef OPENSSL_NO_EC
 849 # define tlsext_sigalg_ecdsa(md) /* */
 850 #else
 851 # define tlsext_sigalg_ecdsa(md) md, TLSEXT_signature_ecdsa,
 852 #endif
 853
 854 #define tlsext_sigalg(md) \
 855                 tlsext_sigalg_rsa(md) \
 856                 tlsext_sigalg_dsa(md) \
 857                 tlsext_sigalg_ecdsa(md)
 858
 859 static const unsigned char tls12_sigalgs[] = {
 860     tlsext_sigalg(TLSEXT_hash_sha512)
 861         tlsext_sigalg(TLSEXT_hash_sha384)
 862         tlsext_sigalg(TLSEXT_hash_sha256)
 863         tlsext_sigalg(TLSEXT_hash_sha224)
 864         tlsext_sigalg(TLSEXT_hash_sha1)
 865 #ifndef OPENSSL_NO_GOST
 866         TLSEXT_hash_gostr3411, TLSEXT_signature_gostr34102001,
 867         TLSEXT_hash_gostr34112012_256, TLSEXT_signature_gostr34102012_256,
 868         TLSEXT_hash_gostr34112012_512, TLSEXT_signature_gostr34102012_512
 869 #endif
 870 };
 871
 872 #ifndef OPENSSL_NO_EC
 873 static const unsigned char suiteb_sigalgs[] = {
 874     tlsext_sigalg_ecdsa(TLSEXT_hash_sha256)
 875         tlsext_sigalg_ecdsa(TLSEXT_hash_sha384)
 876 };
 877 #endif
 878 size_t tls12_get_psigalgs(SSL *s, const unsigned char **psigs)
 879 {
 880     /*
 881      * If Suite B mode use Suite B sigalgs only, ignore any other
 882      * preferences.
 883      */
 884 #ifndef OPENSSL_NO_EC
 885     switch (tls1_suiteb(s)) {
 886     case SSL_CERT_FLAG_SUITEB_128_LOS:
 887         *psigs = suiteb_sigalgs;
 888         return sizeof(suiteb_sigalgs);
 889
 890     case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY:
 891         *psigs = suiteb_sigalgs;
 892         return 2;
 893
 894     case SSL_CERT_FLAG_SUITEB_192_LOS:
 895         *psigs = suiteb_sigalgs + 2;
 896         return 2;
 897     }
 898 #endif
 899     /* If server use client authentication sigalgs if not NULL */
 900     if (s->server && s->cert->client_sigalgs) {
 901         *psigs = s->cert->client_sigalgs;
 902         return s->cert->client_sigalgslen;
 903     } else if (s->cert->conf_sigalgs) {
 904         *psigs = s->cert->conf_sigalgs;
 905         return s->cert->conf_sigalgslen;
 906     } else {
 907         *psigs = tls12_sigalgs;
 908         return sizeof(tls12_sigalgs);
 909     }
 910 }
 911
 912 /*
 913  * Check signature algorithm is consistent with sent supported signature
 914  * algorithms and if so return relevant digest.
 915  */
 916 int tls12_check_peer_sigalg(const EVP_MD **pmd, SSL *s,
 917                             const unsigned char *sig, EVP_PKEY *pkey)
 918 {
 919     const unsigned char *sent_sigs;
 920     size_t sent_sigslen, i;
 921     int sigalg = tls12_get_sigid(pkey);
 922     /* Should never happen */
 923     if (sigalg == -1)
 924         return -1;
 925     /* Check key type is consistent with signature */
 926     if (sigalg != (int)sig[1]) {
 927         SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_SIGNATURE_TYPE);
 928         return 0;
 929     }
 930 #ifndef OPENSSL_NO_EC
 931     if (EVP_PKEY_id(pkey) == EVP_PKEY_EC) {
 932         unsigned char curve_id[2], comp_id;
 933         /* Check compression and curve matches extensions */
 934         if (!tls1_set_ec_id(curve_id, &comp_id, EVP_PKEY_get0_EC_KEY(pkey)))
 935             return 0;
 936         if (!s->server && !tls1_check_ec_key(s, curve_id, &comp_id)) {
 937             SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_CURVE);
 938             return 0;
 939         }
 940         /* If Suite B only P-384+SHA384 or P-256+SHA-256 allowed */
 941         if (tls1_suiteb(s)) {
 942             if (curve_id[0])
 943                 return 0;
 944             if (curve_id[1] == TLSEXT_curve_P_256) {
 945                 if (sig[0] != TLSEXT_hash_sha256) {
 946                     SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG,
 947                            SSL_R_ILLEGAL_SUITEB_DIGEST);
 948                     return 0;
 949                 }
 950             } else if (curve_id[1] == TLSEXT_curve_P_384) {
 951                 if (sig[0] != TLSEXT_hash_sha384) {
 952                     SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG,
 953                            SSL_R_ILLEGAL_SUITEB_DIGEST);
 954                     return 0;
 955                 }
 956             } else
 957                 return 0;
 958         }
 959     } else if (tls1_suiteb(s))
 960         return 0;
 961 #endif
 962
 963     /* Check signature matches a type we sent */
 964     sent_sigslen = tls12_get_psigalgs(s, &sent_sigs);
 965     for (i = 0; i < sent_sigslen; i += 2, sent_sigs += 2) {
 966         if (sig[0] == sent_sigs[0] && sig[1] == sent_sigs[1])
 967             break;
 968     }
 969     /* Allow fallback to SHA1 if not strict mode */
 970     if (i == sent_sigslen
 971         && (sig[0] != TLSEXT_hash_sha1
 972             || s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)) {
 973         SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_SIGNATURE_TYPE);
 974         return 0;
 975     }
 976     *pmd = tls12_get_hash(sig[0]);
 977     if (*pmd == NULL) {
 978         SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_UNKNOWN_DIGEST);
 979         return 0;
 980     }
 981     /* Make sure security callback allows algorithm */
 982     if (!ssl_security(s, SSL_SECOP_SIGALG_CHECK,
 983                       EVP_MD_size(*pmd) * 4, EVP_MD_type(*pmd),
 984                       (void *)sig)) {
 985         SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_SIGNATURE_TYPE);
 986         return 0;
 987     }
 988     /*
 989      * Store the digest used so applications can retrieve it if they wish.
 990      */
 991     s->s3->tmp.peer_md = *pmd;
 992     return 1;
 993 }
 994
 995 /*
 996  * Get a mask of disabled algorithms: an algorithm is disabled if it isn't
 997  * supported or doesn't appear in supported signature algorithms. Unlike
 998  * ssl_cipher_get_disabled this applies to a specific session and not global
 999  * settings.
1000  */
1001 void ssl_set_client_disabled(SSL *s)
1002 {
1003     s->s3->tmp.mask_a = 0;
1004     s->s3->tmp.mask_k = 0;
1005     /* Don't allow TLS 1.2 only ciphers if we don't suppport them */
1006     if (!SSL_CLIENT_USE_TLS1_2_CIPHERS(s))
1007         s->s3->tmp.mask_ssl = SSL_TLSV1_2;
1008     else
1009         s->s3->tmp.mask_ssl = 0;
1010     /* Disable TLS 1.0 ciphers if using SSL v3 */
1011     if (s->client_version == SSL3_VERSION)
1012         s->s3->tmp.mask_ssl |= SSL_TLSV1;
1013     ssl_set_sig_mask(&s->s3->tmp.mask_a, s, SSL_SECOP_SIGALG_MASK);
1014 # ifndef OPENSSL_NO_PSK
1015     /* with PSK there must be client callback set */
1016     if (!s->psk_client_callback) {
1017         s->s3->tmp.mask_a |= SSL_aPSK;
1018         s->s3->tmp.mask_k |= SSL_PSK;
1019     }
1020 #endif                         /* OPENSSL_NO_PSK */
1021 #ifndef OPENSSL_NO_SRP
1022     if (!(s->srp_ctx.srp_Mask & SSL_kSRP)) {
1023         s->s3->tmp.mask_a |= SSL_aSRP;
1024         s->s3->tmp.mask_k |= SSL_kSRP;
1025     }
1026 #endif
1027 }
1028
1029 int ssl_cipher_disabled(SSL *s, const SSL_CIPHER *c, int op)
1030 {
1031     if (c->algorithm_ssl & s->s3->tmp.mask_ssl
1032         || c->algorithm_mkey & s->s3->tmp.mask_k
1033         || c->algorithm_auth & s->s3->tmp.mask_a)
1034         return 1;
1035     return !ssl_security(s, op, c->strength_bits, 0, (void *)c);
1036 }
1037
1038 static int tls_use_ticket(SSL *s)
1039 {
1040     if (s->options & SSL_OP_NO_TICKET)
1041         return 0;
1042     return ssl_security(s, SSL_SECOP_TICKET, 0, 0, NULL);
1043 }
1044
1045 unsigned char *ssl_add_clienthello_tlsext(SSL *s, unsigned char *buf,
1046                                           unsigned char *limit, int *al)
1047 {
1048     int extdatalen = 0;
1049     unsigned char *orig = buf;
1050     unsigned char *ret = buf;
1051 #ifndef OPENSSL_NO_EC
1052     /* See if we support any ECC ciphersuites */
1053     int using_ecc = 0;
1054     if (s->version >= TLS1_VERSION || SSL_IS_DTLS(s)) {
1055         int i;
1056         unsigned long alg_k, alg_a;
1057         STACK_OF(SSL_CIPHER) *cipher_stack = SSL_get_ciphers(s);
1058
1059         for (i = 0; i < sk_SSL_CIPHER_num(cipher_stack); i++) {
1060             const SSL_CIPHER *c = sk_SSL_CIPHER_value(cipher_stack, i);
1061
1062             alg_k = c->algorithm_mkey;
1063             alg_a = c->algorithm_auth;
1064             if ((alg_k & (SSL_kECDHE | SSL_kECDHEPSK))
1065                  || (alg_a & SSL_aECDSA)) {
1066                 using_ecc = 1;
1067                 break;
1068             }
1069         }
1070     }
1071 #endif
1072
1073     ret += 2;
1074
1075     if (ret >= limit)
1076         return NULL;            /* this really never occurs, but ... */
1077
1078     /* Add RI if renegotiating */
1079     if (s->renegotiate) {
1080         int el;
1081
1082         if (!ssl_add_clienthello_renegotiate_ext(s, 0, &el, 0)) {
1083             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1084             return NULL;
1085         }
1086
1087         if ((limit - ret - 4 - el) < 0)
1088             return NULL;
1089
1090         s2n(TLSEXT_TYPE_renegotiate, ret);
1091         s2n(el, ret);
1092
1093         if (!ssl_add_clienthello_renegotiate_ext(s, ret, &el, el)) {
1094             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1095             return NULL;
1096         }
1097
1098         ret += el;
1099     }
1100     /* Only add RI for SSLv3 */
1101     if (s->client_version == SSL3_VERSION)
1102         goto done;
1103
1104     if (s->tlsext_hostname != NULL) {
1105         /* Add TLS extension servername to the Client Hello message */
1106         unsigned long size_str;
1107         long lenmax;
1108
1109         /*-
1110          * check for enough space.
1111          * 4 for the servername type and entension length
1112          * 2 for servernamelist length
1113          * 1 for the hostname type
1114          * 2 for hostname length
1115          * + hostname length
1116          */
1117
1118         if ((lenmax = limit - ret - 9) < 0
1119             || (size_str =
1120                 strlen(s->tlsext_hostname)) > (unsigned long)lenmax)
1121             return NULL;
1122
1123         /* extension type and length */
1124         s2n(TLSEXT_TYPE_server_name, ret);
1125         s2n(size_str + 5, ret);
1126
1127         /* length of servername list */
1128         s2n(size_str + 3, ret);
1129
1130         /* hostname type, length and hostname */
1131         *(ret++) = (unsigned char)TLSEXT_NAMETYPE_host_name;
1132         s2n(size_str, ret);
1133         memcpy(ret, s->tlsext_hostname, size_str);
1134         ret += size_str;
1135     }
1136 #ifndef OPENSSL_NO_SRP
1137     /* Add SRP username if there is one */
1138     if (s->srp_ctx.login != NULL) { /* Add TLS extension SRP username to the
1139                                      * Client Hello message */
1140
1141         int login_len = strlen(s->srp_ctx.login);
1142         if (login_len > 255 || login_len == 0) {
1143             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1144             return NULL;
1145         }
1146
1147         /*-
1148          * check for enough space.
1149          * 4 for the srp type type and entension length
1150          * 1 for the srp user identity
1151          * + srp user identity length
1152          */
1153         if ((limit - ret - 5 - login_len) < 0)
1154             return NULL;
1155
1156         /* fill in the extension */
1157         s2n(TLSEXT_TYPE_srp, ret);
1158         s2n(login_len + 1, ret);
1159         (*ret++) = (unsigned char)login_len;
1160         memcpy(ret, s->srp_ctx.login, login_len);
1161         ret += login_len;
1162     }
1163 #endif
1164
1165 #ifndef OPENSSL_NO_EC
1166     if (using_ecc) {
1167         /*
1168          * Add TLS extension ECPointFormats to the ClientHello message
1169          */
1170         long lenmax;
1171         const unsigned char *pcurves, *pformats;
1172         size_t num_curves, num_formats, curves_list_len;
1173         size_t i;
1174         unsigned char *etmp;
1175
1176         tls1_get_formatlist(s, &pformats, &num_formats);
1177
1178         if ((lenmax = limit - ret - 5) < 0)
1179             return NULL;
1180         if (num_formats > (size_t)lenmax)
1181             return NULL;
1182         if (num_formats > 255) {
1183             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1184             return NULL;
1185         }
1186
1187         s2n(TLSEXT_TYPE_ec_point_formats, ret);
1188         /* The point format list has 1-byte length. */
1189         s2n(num_formats + 1, ret);
1190         *(ret++) = (unsigned char)num_formats;
1191         memcpy(ret, pformats, num_formats);
1192         ret += num_formats;
1193
1194         /*
1195          * Add TLS extension EllipticCurves to the ClientHello message
1196          */
1197         pcurves = s->tlsext_ellipticcurvelist;
1198         if (!tls1_get_curvelist(s, 0, &pcurves, &num_curves))
1199             return NULL;
1200
1201         if ((lenmax = limit - ret - 6) < 0)
1202             return NULL;
1203         if (num_curves > (size_t)lenmax / 2)
1204             return NULL;
1205         if (num_curves > 65532 / 2) {
1206             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1207             return NULL;
1208         }
1209
1210         s2n(TLSEXT_TYPE_elliptic_curves, ret);
1211         etmp = ret + 4;
1212         /* Copy curve ID if supported */
1213         for (i = 0; i < num_curves; i++, pcurves += 2) {
1214             if (tls_curve_allowed(s, pcurves, SSL_SECOP_CURVE_SUPPORTED)) {
1215                 *etmp++ = pcurves[0];
1216                 *etmp++ = pcurves[1];
1217             }
1218         }
1219
1220         curves_list_len = etmp - ret - 4;
1221
1222         s2n(curves_list_len + 2, ret);
1223         s2n(curves_list_len, ret);
1224         ret += curves_list_len;
1225     }
1226 #endif                         /* OPENSSL_NO_EC */
1227
1228     if (tls_use_ticket(s)) {
1229         int ticklen;
1230         if (!s->new_session && s->session && s->session->tlsext_tick)
1231             ticklen = s->session->tlsext_ticklen;
1232         else if (s->session && s->tlsext_session_ticket &&
1233                  s->tlsext_session_ticket->data) {
1234             ticklen = s->tlsext_session_ticket->length;
1235             s->session->tlsext_tick = OPENSSL_malloc(ticklen);
1236             if (s->session->tlsext_tick == NULL)
1237                 return NULL;
1238             memcpy(s->session->tlsext_tick,
1239                    s->tlsext_session_ticket->data, ticklen);
1240             s->session->tlsext_ticklen = ticklen;
1241         } else
1242             ticklen = 0;
1243         if (ticklen == 0 && s->tlsext_session_ticket &&
1244             s->tlsext_session_ticket->data == NULL)
1245             goto skip_ext;
1246         /*
1247          * Check for enough room 2 for extension type, 2 for len rest for
1248          * ticket
1249          */
1250         if ((long)(limit - ret - 4 - ticklen) < 0)
1251             return NULL;
1252         s2n(TLSEXT_TYPE_session_ticket, ret);
1253         s2n(ticklen, ret);
1254         if (ticklen) {
1255             memcpy(ret, s->session->tlsext_tick, ticklen);
1256             ret += ticklen;
1257         }
1258     }
1259  skip_ext:
1260
1261     if (SSL_USE_SIGALGS(s)) {
1262         size_t salglen;
1263         const unsigned char *salg;
1264         unsigned char *etmp;
1265         salglen = tls12_get_psigalgs(s, &salg);
1266         if ((size_t)(limit - ret) < salglen + 6)
1267             return NULL;
1268         s2n(TLSEXT_TYPE_signature_algorithms, ret);
1269         etmp = ret;
1270         /* Skip over lengths for now */
1271         ret += 4;
1272         salglen = tls12_copy_sigalgs(s, ret, salg, salglen);
1273         /* Fill in lengths */
1274         s2n(salglen + 2, etmp);
1275         s2n(salglen, etmp);
1276         ret += salglen;
1277     }
1278
1279     if (s->tlsext_status_type == TLSEXT_STATUSTYPE_ocsp) {
1280         int i;
1281         long extlen, idlen, itmp;
1282         OCSP_RESPID *id;
1283
1284         idlen = 0;
1285         for (i = 0; i < sk_OCSP_RESPID_num(s->tlsext_ocsp_ids); i++) {
1286             id = sk_OCSP_RESPID_value(s->tlsext_ocsp_ids, i);
1287             itmp = i2d_OCSP_RESPID(id, NULL);
1288             if (itmp <= 0)
1289                 return NULL;
1290             idlen += itmp + 2;
1291         }
1292
1293         if (s->tlsext_ocsp_exts) {
1294             extlen = i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts, NULL);
1295             if (extlen < 0)
1296                 return NULL;
1297         } else
1298             extlen = 0;
1299
1300         if ((long)(limit - ret - 7 - extlen - idlen) < 0)
1301             return NULL;
1302         s2n(TLSEXT_TYPE_status_request, ret);
1303         if (extlen + idlen > 0xFFF0)
1304             return NULL;
1305         s2n(extlen + idlen + 5, ret);
1306         *(ret++) = TLSEXT_STATUSTYPE_ocsp;
1307         s2n(idlen, ret);
1308         for (i = 0; i < sk_OCSP_RESPID_num(s->tlsext_ocsp_ids); i++) {
1309             /* save position of id len */
1310             unsigned char *q = ret;
1311             id = sk_OCSP_RESPID_value(s->tlsext_ocsp_ids, i);
1312             /* skip over id len */
1313             ret += 2;
1314             itmp = i2d_OCSP_RESPID(id, &ret);
1315             /* write id len */
1316             s2n(itmp, q);
1317         }
1318         s2n(extlen, ret);
1319         if (extlen > 0)
1320             i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts, &ret);
1321     }
1322 #ifndef OPENSSL_NO_HEARTBEATS
1323     if (SSL_IS_DTLS(s)) {
1324         /* Add Heartbeat extension */
1325         if ((limit - ret - 4 - 1) < 0)
1326             return NULL;
1327         s2n(TLSEXT_TYPE_heartbeat, ret);
1328         s2n(1, ret);
1329         /*-
1330          * Set mode:
1331          * 1: peer may send requests
1332          * 2: peer not allowed to send requests
1333          */
1334         if (s->tlsext_heartbeat & SSL_DTLSEXT_HB_DONT_RECV_REQUESTS)
1335             *(ret++) = SSL_DTLSEXT_HB_DONT_SEND_REQUESTS;
1336         else
1337             *(ret++) = SSL_DTLSEXT_HB_ENABLED;
1338     }
1339 #endif
1340
1341 #ifndef OPENSSL_NO_NEXTPROTONEG
1342     if (s->ctx->next_proto_select_cb && !s->s3->tmp.finish_md_len) {
1343         /*
1344          * The client advertises an emtpy extension to indicate its support
1345          * for Next Protocol Negotiation
1346          */
1347         if (limit - ret - 4 < 0)
1348             return NULL;
1349         s2n(TLSEXT_TYPE_next_proto_neg, ret);
1350         s2n(0, ret);
1351     }
1352 #endif
1353
1354     if (s->alpn_client_proto_list && !s->s3->tmp.finish_md_len) {
1355         if ((size_t)(limit - ret) < 6 + s->alpn_client_proto_list_len)
1356             return NULL;
1357         s2n(TLSEXT_TYPE_application_layer_protocol_negotiation, ret);
1358         s2n(2 + s->alpn_client_proto_list_len, ret);
1359         s2n(s->alpn_client_proto_list_len, ret);
1360         memcpy(ret, s->alpn_client_proto_list, s->alpn_client_proto_list_len);
1361         ret += s->alpn_client_proto_list_len;
1362     }
1363 #ifndef OPENSSL_NO_SRTP
1364     if (SSL_IS_DTLS(s) && SSL_get_srtp_profiles(s)) {
1365         int el;
1366
1367         /* Returns 0 on success!! */
1368         if (ssl_add_clienthello_use_srtp_ext(s, 0, &el, 0)) {
1369             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1370             return NULL;
1371         }
1372
1373         if ((limit - ret - 4 - el) < 0)
1374             return NULL;
1375
1376         s2n(TLSEXT_TYPE_use_srtp, ret);
1377         s2n(el, ret);
1378
1379         if (ssl_add_clienthello_use_srtp_ext(s, ret, &el, el)) {
1380             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1381             return NULL;
1382         }
1383         ret += el;
1384     }
1385 #endif
1386     custom_ext_init(&s->cert->cli_ext);
1387     /* Add custom TLS Extensions to ClientHello */
1388     if (!custom_ext_add(s, 0, &ret, limit, al))
1389         return NULL;
1390 #ifdef TLSEXT_TYPE_encrypt_then_mac
1391     s2n(TLSEXT_TYPE_encrypt_then_mac, ret);
1392     s2n(0, ret);
1393 #endif
1394     s2n(TLSEXT_TYPE_extended_master_secret, ret);
1395     s2n(0, ret);
1396
1397     /*
1398      * Add padding to workaround bugs in F5 terminators. See
1399      * https://tools.ietf.org/html/draft-agl-tls-padding-03 NB: because this
1400      * code works out the length of all existing extensions it MUST always
1401      * appear last.
1402      */
1403     if (s->options & SSL_OP_TLSEXT_PADDING) {
1404         int hlen = ret - (unsigned char *)s->init_buf->data;
1405
1406         if (hlen > 0xff && hlen < 0x200) {
1407             hlen = 0x200 - hlen;
1408             if (hlen >= 4)
1409                 hlen -= 4;
1410             else
1411                 hlen = 0;
1412
1413             s2n(TLSEXT_TYPE_padding, ret);
1414             s2n(hlen, ret);
1415             memset(ret, 0, hlen);
1416             ret += hlen;
1417         }
1418     }
1419
1420  done:
1421
1422     if ((extdatalen = ret - orig - 2) == 0)
1423         return orig;
1424
1425     s2n(extdatalen, orig);
1426     return ret;
1427 }
1428
1429 unsigned char *ssl_add_serverhello_tlsext(SSL *s, unsigned char *buf,
1430                                           unsigned char *limit, int *al)
1431 {
1432     int extdatalen = 0;
1433     unsigned char *orig = buf;
1434     unsigned char *ret = buf;
1435 #ifndef OPENSSL_NO_NEXTPROTONEG
1436     int next_proto_neg_seen;
1437 #endif
1438 #ifndef OPENSSL_NO_EC
1439     unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
1440     unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
1441     int using_ecc = (alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA);
1442     using_ecc = using_ecc && (s->session->tlsext_ecpointformatlist != NULL);
1443 #endif
1444
1445     ret += 2;
1446     if (ret >= limit)
1447         return NULL;            /* this really never occurs, but ... */
1448
1449     if (s->s3->send_connection_binding) {
1450         int el;
1451
1452         if (!ssl_add_serverhello_renegotiate_ext(s, 0, &el, 0)) {
1453             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1454             return NULL;
1455         }
1456
1457         if ((limit - ret - 4 - el) < 0)
1458             return NULL;
1459
1460         s2n(TLSEXT_TYPE_renegotiate, ret);
1461         s2n(el, ret);
1462
1463         if (!ssl_add_serverhello_renegotiate_ext(s, ret, &el, el)) {
1464             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1465             return NULL;
1466         }
1467
1468         ret += el;
1469     }
1470
1471     /* Only add RI for SSLv3 */
1472     if (s->version == SSL3_VERSION)
1473         goto done;
1474
1475     if (!s->hit && s->servername_done == 1
1476         && s->session->tlsext_hostname != NULL) {
1477         if ((long)(limit - ret - 4) < 0)
1478             return NULL;
1479
1480         s2n(TLSEXT_TYPE_server_name, ret);
1481         s2n(0, ret);
1482     }
1483 #ifndef OPENSSL_NO_EC
1484     if (using_ecc) {
1485         const unsigned char *plist;
1486         size_t plistlen;
1487         /*
1488          * Add TLS extension ECPointFormats to the ServerHello message
1489          */
1490         long lenmax;
1491
1492         tls1_get_formatlist(s, &plist, &plistlen);
1493
1494         if ((lenmax = limit - ret - 5) < 0)
1495             return NULL;
1496         if (plistlen > (size_t)lenmax)
1497             return NULL;
1498         if (plistlen > 255) {
1499             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1500             return NULL;
1501         }
1502
1503         s2n(TLSEXT_TYPE_ec_point_formats, ret);
1504         s2n(plistlen + 1, ret);
1505         *(ret++) = (unsigned char)plistlen;
1506         memcpy(ret, plist, plistlen);
1507         ret += plistlen;
1508
1509     }
1510     /*
1511      * Currently the server should not respond with a SupportedCurves
1512      * extension
1513      */
1514 #endif                         /* OPENSSL_NO_EC */
1515
1516     if (s->tlsext_ticket_expected && tls_use_ticket(s)) {
1517         if ((long)(limit - ret - 4) < 0)
1518             return NULL;
1519         s2n(TLSEXT_TYPE_session_ticket, ret);
1520         s2n(0, ret);
1521     }
1522
1523     if (s->tlsext_status_expected) {
1524         if ((long)(limit - ret - 4) < 0)
1525             return NULL;
1526         s2n(TLSEXT_TYPE_status_request, ret);
1527         s2n(0, ret);
1528     }
1529
1530 #ifndef OPENSSL_NO_SRTP
1531     if (SSL_IS_DTLS(s) && s->srtp_profile) {
1532         int el;
1533
1534         /* Returns 0 on success!! */
1535         if (ssl_add_serverhello_use_srtp_ext(s, 0, &el, 0)) {
1536             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1537             return NULL;
1538         }
1539         if ((limit - ret - 4 - el) < 0)
1540             return NULL;
1541
1542         s2n(TLSEXT_TYPE_use_srtp, ret);
1543         s2n(el, ret);
1544
1545         if (ssl_add_serverhello_use_srtp_ext(s, ret, &el, el)) {
1546             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1547             return NULL;
1548         }
1549         ret += el;
1550     }
1551 #endif
1552
1553     if (((s->s3->tmp.new_cipher->id & 0xFFFF) == 0x80
1554          || (s->s3->tmp.new_cipher->id & 0xFFFF) == 0x81)
1555         && (SSL_get_options(s) & SSL_OP_CRYPTOPRO_TLSEXT_BUG)) {
1556         const unsigned char cryptopro_ext[36] = {
1557             0xfd, 0xe8,         /* 65000 */
1558             0x00, 0x20,         /* 32 bytes length */
1559             0x30, 0x1e, 0x30, 0x08, 0x06, 0x06, 0x2a, 0x85,
1560             0x03, 0x02, 0x02, 0x09, 0x30, 0x08, 0x06, 0x06,
1561             0x2a, 0x85, 0x03, 0x02, 0x02, 0x16, 0x30, 0x08,
1562             0x06, 0x06, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x17
1563         };
1564         if (limit - ret < 36)
1565             return NULL;
1566         memcpy(ret, cryptopro_ext, 36);
1567         ret += 36;
1568
1569     }
1570 #ifndef OPENSSL_NO_HEARTBEATS
1571     /* Add Heartbeat extension if we've received one */
1572     if (SSL_IS_DTLS(s) && (s->tlsext_heartbeat & SSL_DTLSEXT_HB_ENABLED)) {
1573         if ((limit - ret - 4 - 1) < 0)
1574             return NULL;
1575         s2n(TLSEXT_TYPE_heartbeat, ret);
1576         s2n(1, ret);
1577         /*-
1578          * Set mode:
1579          * 1: peer may send requests
1580          * 2: peer not allowed to send requests
1581          */
1582         if (s->tlsext_heartbeat & SSL_DTLSEXT_HB_DONT_RECV_REQUESTS)
1583             *(ret++) = SSL_DTLSEXT_HB_DONT_SEND_REQUESTS;
1584         else
1585             *(ret++) = SSL_DTLSEXT_HB_ENABLED;
1586
1587     }
1588 #endif
1589
1590 #ifndef OPENSSL_NO_NEXTPROTONEG
1591     next_proto_neg_seen = s->s3->next_proto_neg_seen;
1592     s->s3->next_proto_neg_seen = 0;
1593     if (next_proto_neg_seen && s->ctx->next_protos_advertised_cb) {
1594         const unsigned char *npa;
1595         unsigned int npalen;
1596         int r;
1597
1598         r = s->ctx->next_protos_advertised_cb(s, &npa, &npalen,
1599                                               s->
1600                                               ctx->next_protos_advertised_cb_arg);
1601         if (r == SSL_TLSEXT_ERR_OK) {
1602             if ((long)(limit - ret - 4 - npalen) < 0)
1603                 return NULL;
1604             s2n(TLSEXT_TYPE_next_proto_neg, ret);
1605             s2n(npalen, ret);
1606             memcpy(ret, npa, npalen);
1607             ret += npalen;
1608             s->s3->next_proto_neg_seen = 1;
1609         }
1610     }
1611 #endif
1612     if (!custom_ext_add(s, 1, &ret, limit, al))
1613         return NULL;
1614 #ifdef TLSEXT_TYPE_encrypt_then_mac
1615     if (s->s3->flags & TLS1_FLAGS_ENCRYPT_THEN_MAC) {
1616         /*
1617          * Don't use encrypt_then_mac if AEAD or RC4 might want to disable
1618          * for other cases too.
1619          */
1620         if (s->s3->tmp.new_cipher->algorithm_mac == SSL_AEAD
1621             || s->s3->tmp.new_cipher->algorithm_enc == SSL_RC4
1622             || s->s3->tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT
1623             || s->s3->tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT12)
1624             s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
1625         else {
1626             s2n(TLSEXT_TYPE_encrypt_then_mac, ret);
1627             s2n(0, ret);
1628         }
1629     }
1630 #endif
1631     if (s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) {
1632         s2n(TLSEXT_TYPE_extended_master_secret, ret);
1633         s2n(0, ret);
1634     }
1635
1636     if (s->s3->alpn_selected) {
1637         const unsigned char *selected = s->s3->alpn_selected;
1638         unsigned len = s->s3->alpn_selected_len;
1639
1640         if ((long)(limit - ret - 4 - 2 - 1 - len) < 0)
1641             return NULL;
1642         s2n(TLSEXT_TYPE_application_layer_protocol_negotiation, ret);
1643         s2n(3 + len, ret);
1644         s2n(1 + len, ret);
1645         *ret++ = len;
1646         memcpy(ret, selected, len);
1647         ret += len;
1648     }
1649
1650  done:
1651
1652     if ((extdatalen = ret - orig - 2) == 0)
1653         return orig;
1654
1655     s2n(extdatalen, orig);
1656     return ret;
1657 }
1658
1659 /*
1660  * tls1_alpn_handle_client_hello is called to process the ALPN extension in a
1661  * ClientHello.  data: the contents of the extension, not including the type
1662  * and length.  data_len: the number of bytes in |data| al: a pointer to the
1663  * alert value to send in the event of a non-zero return.  returns: 0 on
1664  * success.
1665  */
1666 static int tls1_alpn_handle_client_hello(SSL *s, PACKET *pkt, int *al)
1667 {
1668     unsigned int data_len;
1669     unsigned int proto_len;
1670     const unsigned char *selected;
1671     const unsigned char *data;
1672     unsigned char selected_len;
1673     int r;
1674
1675     if (s->ctx->alpn_select_cb == NULL)
1676         return 0;
1677
1678     /*
1679      * data should contain a uint16 length followed by a series of 8-bit,
1680      * length-prefixed strings.
1681      */
1682     if (!PACKET_get_net_2(pkt, &data_len)
1683             || PACKET_remaining(pkt) != data_len
1684             || !PACKET_peek_bytes(pkt, &data, data_len))
1685         goto parse_error;
1686
1687     do {
1688         if (!PACKET_get_1(pkt, &proto_len)
1689                 || proto_len == 0
1690                 || !PACKET_forward(pkt, proto_len))
1691             goto parse_error;
1692     } while (PACKET_remaining(pkt));
1693
1694     r = s->ctx->alpn_select_cb(s, &selected, &selected_len, data, data_len,
1695                                s->ctx->alpn_select_cb_arg);
1696     if (r == SSL_TLSEXT_ERR_OK) {
1697         OPENSSL_free(s->s3->alpn_selected);
1698         s->s3->alpn_selected = OPENSSL_malloc(selected_len);
1699         if (s->s3->alpn_selected == NULL) {
1700             *al = SSL_AD_INTERNAL_ERROR;
1701             return -1;
1702         }
1703         memcpy(s->s3->alpn_selected, selected, selected_len);
1704         s->s3->alpn_selected_len = selected_len;
1705     }
1706     return 0;
1707
1708  parse_error:
1709     *al = SSL_AD_DECODE_ERROR;
1710     return -1;
1711 }
1712
1713 #ifndef OPENSSL_NO_EC
1714 /*-
1715  * ssl_check_for_safari attempts to fingerprint Safari using OS X
1716  * SecureTransport using the TLS extension block in |d|, of length |n|.
1717  * Safari, since 10.6, sends exactly these extensions, in this order:
1718  *   SNI,
1719  *   elliptic_curves
1720  *   ec_point_formats
1721  *
1722  * We wish to fingerprint Safari because they broke ECDHE-ECDSA support in 10.8,
1723  * but they advertise support. So enabling ECDHE-ECDSA ciphers breaks them.
1724  * Sadly we cannot differentiate 10.6, 10.7 and 10.8.4 (which work), from
1725  * 10.8..10.8.3 (which don't work).
1726  */
1727 static void ssl_check_for_safari(SSL *s, const PACKET *pkt)
1728 {
1729     unsigned int type, size;
1730     const unsigned char *eblock1, *eblock2;
1731     PACKET tmppkt;
1732
1733     static const unsigned char kSafariExtensionsBlock[] = {
1734         0x00, 0x0a,             /* elliptic_curves extension */
1735         0x00, 0x08,             /* 8 bytes */
1736         0x00, 0x06,             /* 6 bytes of curve ids */
1737         0x00, 0x17,             /* P-256 */
1738         0x00, 0x18,             /* P-384 */
1739         0x00, 0x19,             /* P-521 */
1740
1741         0x00, 0x0b,             /* ec_point_formats */
1742         0x00, 0x02,             /* 2 bytes */
1743         0x01,                   /* 1 point format */
1744         0x00,                   /* uncompressed */
1745     };
1746
1747     /* The following is only present in TLS 1.2 */
1748     static const unsigned char kSafariTLS12ExtensionsBlock[] = {
1749         0x00, 0x0d,             /* signature_algorithms */
1750         0x00, 0x0c,             /* 12 bytes */
1751         0x00, 0x0a,             /* 10 bytes */
1752         0x05, 0x01,             /* SHA-384/RSA */
1753         0x04, 0x01,             /* SHA-256/RSA */
1754         0x02, 0x01,             /* SHA-1/RSA */
1755         0x04, 0x03,             /* SHA-256/ECDSA */
1756         0x02, 0x03,             /* SHA-1/ECDSA */
1757     };
1758
1759     tmppkt = *pkt;
1760
1761     if (!PACKET_forward(&tmppkt, 2)
1762             || !PACKET_get_net_2(&tmppkt, &type)
1763             || !PACKET_get_net_2(&tmppkt, &size)
1764             || !PACKET_forward(&tmppkt, size))
1765         return;
1766
1767     if (type != TLSEXT_TYPE_server_name)
1768         return;
1769
1770     if (TLS1_get_client_version(s) >= TLS1_2_VERSION) {
1771         const size_t len1 = sizeof(kSafariExtensionsBlock);
1772         const size_t len2 = sizeof(kSafariTLS12ExtensionsBlock);
1773
1774         if (!PACKET_get_bytes(&tmppkt, &eblock1, len1)
1775                 || !PACKET_get_bytes(&tmppkt, &eblock2, len2)
1776                 || PACKET_remaining(&tmppkt))
1777             return;
1778         if (memcmp(eblock1, kSafariExtensionsBlock, len1) != 0)
1779             return;
1780         if (memcmp(eblock2, kSafariTLS12ExtensionsBlock, len2) != 0)
1781             return;
1782     } else {
1783         const size_t len = sizeof(kSafariExtensionsBlock);
1784
1785         if (!PACKET_get_bytes(&tmppkt, &eblock1, len)
1786                 || PACKET_remaining(&tmppkt))
1787             return;
1788         if (memcmp(eblock1, kSafariExtensionsBlock, len) != 0)
1789             return;
1790     }
1791
1792     s->s3->is_probably_safari = 1;
1793 }
1794 #endif                         /* !OPENSSL_NO_EC */
1795
1796 static int ssl_scan_clienthello_tlsext(SSL *s, PACKET *pkt, int *al)
1797 {
1798     unsigned int type;
1799     unsigned int size;
1800     unsigned int len;
1801     const unsigned char *data;
1802     int renegotiate_seen = 0;
1803
1804     s->servername_done = 0;
1805     s->tlsext_status_type = -1;
1806 #ifndef OPENSSL_NO_NEXTPROTONEG
1807     s->s3->next_proto_neg_seen = 0;
1808 #endif
1809
1810     OPENSSL_free(s->s3->alpn_selected);
1811     s->s3->alpn_selected = NULL;
1812 #ifndef OPENSSL_NO_HEARTBEATS
1813     s->tlsext_heartbeat &= ~(SSL_DTLSEXT_HB_ENABLED |
1814                              SSL_DTLSEXT_HB_DONT_SEND_REQUESTS);
1815 #endif
1816
1817 #ifndef OPENSSL_NO_EC
1818     if (s->options & SSL_OP_SAFARI_ECDHE_ECDSA_BUG)
1819         ssl_check_for_safari(s, pkt);
1820 # endif /* !OPENSSL_NO_EC */
1821
1822     /* Clear any signature algorithms extension received */
1823     OPENSSL_free(s->s3->tmp.peer_sigalgs);
1824     s->s3->tmp.peer_sigalgs = NULL;
1825 #ifdef TLSEXT_TYPE_encrypt_then_mac
1826     s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
1827 #endif
1828
1829 #ifndef OPENSSL_NO_SRP
1830     OPENSSL_free(s->srp_ctx.login);
1831     s->srp_ctx.login = NULL;
1832 #endif
1833
1834     s->srtp_profile = NULL;
1835
1836     if (PACKET_remaining(pkt) == 0)
1837         goto ri_check;
1838
1839     if (!PACKET_get_net_2(pkt, &len))
1840         goto err;
1841
1842     if (PACKET_remaining(pkt) != len)
1843         goto err;
1844
1845     while (PACKET_get_net_2(pkt, &type) && PACKET_get_net_2(pkt, &size)) {
1846         PACKET subpkt;
1847
1848         if (!PACKET_peek_bytes(pkt, &data, size))
1849             goto err;
1850
1851         if (s->tlsext_debug_cb)
1852             s->tlsext_debug_cb(s, 0, type, data, size, s->tlsext_debug_arg);
1853
1854         if (!PACKET_get_sub_packet(pkt, &subpkt, size))
1855             goto err;
1856
1857         if (type == TLSEXT_TYPE_renegotiate) {
1858             if (!ssl_parse_clienthello_renegotiate_ext(s, &subpkt, al))
1859                 return 0;
1860             renegotiate_seen = 1;
1861         } else if (s->version == SSL3_VERSION) {
1862         }
1863 /*-
1864  * The servername extension is treated as follows:
1865  *
1866  * - Only the hostname type is supported with a maximum length of 255.
1867  * - The servername is rejected if too long or if it contains zeros,
1868  *   in which case an fatal alert is generated.
1869  * - The servername field is maintained together with the session cache.
1870  * - When a session is resumed, the servername call back invoked in order
1871  *   to allow the application to position itself to the right context.
1872  * - The servername is acknowledged if it is new for a session or when
1873  *   it is identical to a previously used for the same session.
1874  *   Applications can control the behaviour.  They can at any time
1875  *   set a 'desirable' servername for a new SSL object. This can be the
1876  *   case for example with HTTPS when a Host: header field is received and
1877  *   a renegotiation is requested. In this case, a possible servername
1878  *   presented in the new client hello is only acknowledged if it matches
1879  *   the value of the Host: field.
1880  * - Applications must  use SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
1881  *   if they provide for changing an explicit servername context for the
1882  *   session, i.e. when the session has been established with a servername
1883  *   extension.
1884  * - On session reconnect, the servername extension may be absent.
1885  *
1886  */
1887
1888         else if (type == TLSEXT_TYPE_server_name) {
1889             const unsigned char *sdata;
1890             unsigned int servname_type;
1891             unsigned int dsize;
1892             PACKET ssubpkt;
1893
1894             if (!PACKET_get_net_2(&subpkt, &dsize)
1895                     || !PACKET_get_sub_packet(&subpkt, &ssubpkt, dsize))
1896                 goto err;
1897
1898             while (PACKET_remaining(&ssubpkt) > 3) {
1899                 if (!PACKET_get_1(&ssubpkt, &servname_type)
1900                         || !PACKET_get_net_2(&ssubpkt, &len)
1901                         || PACKET_remaining(&ssubpkt) < len)
1902                     goto err;
1903
1904                 if (s->servername_done == 0)
1905                     switch (servname_type) {
1906                     case TLSEXT_NAMETYPE_host_name:
1907                         if (!s->hit) {
1908                             if (s->session->tlsext_hostname)
1909                                 goto err;
1910
1911                             if (len > TLSEXT_MAXLEN_host_name) {
1912                                 *al = TLS1_AD_UNRECOGNIZED_NAME;
1913                                 return 0;
1914                             }
1915                             if ((s->session->tlsext_hostname =
1916                                  OPENSSL_malloc(len + 1)) == NULL) {
1917                                 *al = TLS1_AD_INTERNAL_ERROR;
1918                                 return 0;
1919                             }
1920                             if (!PACKET_copy_bytes(&ssubpkt,
1921                                     (unsigned char *)s->session
1922                                         ->tlsext_hostname,
1923                                     len)) {
1924                                 *al = SSL_AD_DECODE_ERROR;
1925                                 return 0;
1926                             }
1927                             s->session->tlsext_hostname[len] = '\0';
1928                             if (strlen(s->session->tlsext_hostname) != len) {
1929                                 OPENSSL_free(s->session->tlsext_hostname);
1930                                 s->session->tlsext_hostname = NULL;
1931                                 *al = TLS1_AD_UNRECOGNIZED_NAME;
1932                                 return 0;
1933                             }
1934                             s->servername_done = 1;
1935
1936                         } else {
1937                             if (!PACKET_get_bytes(&ssubpkt, &sdata, len)) {
1938                                 *al = SSL_AD_DECODE_ERROR;
1939                                 return 0;
1940                             }
1941                             s->servername_done = s->session->tlsext_hostname
1942                                 && strlen(s->session->tlsext_hostname) == len
1943                                 && strncmp(s->session->tlsext_hostname,
1944                                            (char *)sdata, len) == 0;
1945                         }
1946
1947                         break;
1948
1949                     default:
1950                         break;
1951                     }
1952             }
1953             /* We shouldn't have any bytes left */
1954             if (PACKET_remaining(&ssubpkt) != 0)
1955                 goto err;
1956
1957         }
1958 #ifndef OPENSSL_NO_SRP
1959         else if (type == TLSEXT_TYPE_srp) {
1960             if (!PACKET_get_1(&subpkt, &len)
1961                     || s->srp_ctx.login != NULL)
1962                 goto err;
1963
1964             if ((s->srp_ctx.login = OPENSSL_malloc(len + 1)) == NULL)
1965                 return -1;
1966             if (!PACKET_copy_bytes(&subpkt, (unsigned char *)s->srp_ctx.login,
1967                                    len))
1968                 goto err;
1969             s->srp_ctx.login[len] = '\0';
1970
1971             if (strlen(s->srp_ctx.login) != len
1972                     || PACKET_remaining(&subpkt))
1973                 goto err;
1974         }
1975 #endif
1976
1977 #ifndef OPENSSL_NO_EC
1978         else if (type == TLSEXT_TYPE_ec_point_formats) {
1979             unsigned int ecpointformatlist_length;
1980
1981             if (!PACKET_get_1(&subpkt, &ecpointformatlist_length)
1982                     || ecpointformatlist_length == 0)
1983                 goto err;
1984
1985             if (!s->hit) {
1986                 OPENSSL_free(s->session->tlsext_ecpointformatlist);
1987                 s->session->tlsext_ecpointformatlist = NULL;
1988                 s->session->tlsext_ecpointformatlist_length = 0;
1989                 if ((s->session->tlsext_ecpointformatlist =
1990                      OPENSSL_malloc(ecpointformatlist_length)) == NULL) {
1991                     *al = TLS1_AD_INTERNAL_ERROR;
1992                     return 0;
1993                 }
1994                 s->session->tlsext_ecpointformatlist_length =
1995                     ecpointformatlist_length;
1996                 if (!PACKET_copy_bytes(&subpkt,
1997                         s->session->tlsext_ecpointformatlist,
1998                         ecpointformatlist_length))
1999                     goto err;
2000             } else if (!PACKET_forward(&subpkt, ecpointformatlist_length)) {
2001                 goto err;
2002             }
2003             /* We should have consumed all the bytes by now */
2004             if (PACKET_remaining(&subpkt)) {
2005                 *al = TLS1_AD_DECODE_ERROR;
2006                 return 0;
2007             }
2008         } else if (type == TLSEXT_TYPE_elliptic_curves) {
2009             unsigned int ellipticcurvelist_length;
2010
2011             /* Each NamedCurve is 2 bytes and we must have at least 1 */
2012             if (!PACKET_get_net_2(&subpkt, &ellipticcurvelist_length)
2013                     || ellipticcurvelist_length == 0
2014                     || (ellipticcurvelist_length & 1) != 0)
2015                 goto err;
2016
2017             if (!s->hit) {
2018                 if (s->session->tlsext_ellipticcurvelist)
2019                     goto err;
2020
2021                 s->session->tlsext_ellipticcurvelist_length = 0;
2022                 if ((s->session->tlsext_ellipticcurvelist =
2023                      OPENSSL_malloc(ellipticcurvelist_length)) == NULL) {
2024                     *al = TLS1_AD_INTERNAL_ERROR;
2025                     return 0;
2026                 }
2027                 s->session->tlsext_ellipticcurvelist_length =
2028                     ellipticcurvelist_length;
2029                 if (!PACKET_copy_bytes(&subpkt,
2030                         s->session->tlsext_ellipticcurvelist,
2031                         ellipticcurvelist_length))
2032                     goto err;
2033             } else if (!PACKET_forward(&subpkt, ellipticcurvelist_length)) {
2034                 goto err;
2035             }
2036             /* We should have consumed all the bytes by now */
2037             if (PACKET_remaining(&subpkt)) {
2038                 goto err;
2039             }
2040         }
2041 #endif                         /* OPENSSL_NO_EC */
2042         else if (type == TLSEXT_TYPE_session_ticket) {
2043             if (!PACKET_forward(&subpkt, size)
2044                 || (s->tls_session_ticket_ext_cb &&
2045                     !s->tls_session_ticket_ext_cb(s, data, size,
2046                                         s->tls_session_ticket_ext_cb_arg))) {
2047                 *al = TLS1_AD_INTERNAL_ERROR;
2048                 return 0;
2049             }
2050         } else if (type == TLSEXT_TYPE_signature_algorithms) {
2051             unsigned int dsize;
2052
2053             if (s->s3->tmp.peer_sigalgs
2054                     || !PACKET_get_net_2(&subpkt, &dsize)
2055                     || (dsize & 1) != 0
2056                     || (dsize == 0)
2057                     || !PACKET_get_bytes(&subpkt, &data, dsize)
2058                     || PACKET_remaining(&subpkt) != 0
2059                     || !tls1_save_sigalgs(s, data, dsize)) {
2060                 goto err;
2061             }
2062         } else if (type == TLSEXT_TYPE_status_request) {
2063             PACKET ssubpkt;
2064
2065             if (!PACKET_get_1(&subpkt,
2066                               (unsigned int *)&s->tlsext_status_type))
2067                 goto err;
2068
2069             if (s->tlsext_status_type == TLSEXT_STATUSTYPE_ocsp) {
2070                 const unsigned char *sdata;
2071                 unsigned int dsize;
2072                 /* Read in responder_id_list */
2073                 if (!PACKET_get_net_2(&subpkt, &dsize)
2074                         || !PACKET_get_sub_packet(&subpkt, &ssubpkt, dsize))
2075                     goto err;
2076
2077                 while (PACKET_remaining(&ssubpkt)) {
2078                     OCSP_RESPID *id;
2079                     unsigned int idsize;
2080
2081                     if (PACKET_remaining(&ssubpkt) < 4
2082                             || !PACKET_get_net_2(&ssubpkt, &idsize)
2083                             || !PACKET_get_bytes(&ssubpkt, &data, idsize)) {
2084                         goto err;
2085                     }
2086                     sdata = data;
2087                     data += idsize;
2088                     id = d2i_OCSP_RESPID(NULL, &sdata, idsize);
2089                     if (!id)
2090                         goto err;
2091                     if (data != sdata) {
2092                         OCSP_RESPID_free(id);
2093                         goto err;
2094                     }
2095                     if (!s->tlsext_ocsp_ids
2096                         && !(s->tlsext_ocsp_ids =
2097                              sk_OCSP_RESPID_new_null())) {
2098                         OCSP_RESPID_free(id);
2099                         *al = SSL_AD_INTERNAL_ERROR;
2100                         return 0;
2101                     }
2102                     if (!sk_OCSP_RESPID_push(s->tlsext_ocsp_ids, id)) {
2103                         OCSP_RESPID_free(id);
2104                         *al = SSL_AD_INTERNAL_ERROR;
2105                         return 0;
2106                     }
2107                 }
2108
2109                 /* Read in request_extensions */
2110                 if (!PACKET_get_net_2(&subpkt, &dsize)
2111                         || !PACKET_get_bytes(&subpkt, &data, dsize)
2112                         || PACKET_remaining(&subpkt)) {
2113                     goto err;
2114                 }
2115                 sdata = data;
2116                 if (dsize > 0) {
2117                     sk_X509_EXTENSION_pop_free(s->tlsext_ocsp_exts,
2118                                                X509_EXTENSION_free);
2119                     s->tlsext_ocsp_exts =
2120                         d2i_X509_EXTENSIONS(NULL, &sdata, dsize);
2121                     if (!s->tlsext_ocsp_exts || (data + dsize != sdata))
2122                         goto err;
2123                 }
2124             }
2125             /*
2126              * We don't know what to do with any other type * so ignore it.
2127              */
2128             else
2129                 s->tlsext_status_type = -1;
2130         }
2131 #ifndef OPENSSL_NO_HEARTBEATS
2132         else if (SSL_IS_DTLS(s) && type == TLSEXT_TYPE_heartbeat) {
2133             unsigned int hbtype;
2134
2135             if (!PACKET_get_1(&subpkt, &hbtype)
2136                     || PACKET_remaining(&subpkt)) {
2137                 *al = SSL_AD_DECODE_ERROR;
2138                 return 0;
2139             }
2140             switch (hbtype) {
2141             case 0x01:         /* Client allows us to send HB requests */
2142                 s->tlsext_heartbeat |= SSL_DTLSEXT_HB_ENABLED;
2143                 break;
2144             case 0x02:         /* Client doesn't accept HB requests */
2145                 s->tlsext_heartbeat |= SSL_DTLSEXT_HB_ENABLED;
2146                 s->tlsext_heartbeat |= SSL_DTLSEXT_HB_DONT_SEND_REQUESTS;
2147                 break;
2148             default:
2149                 *al = SSL_AD_ILLEGAL_PARAMETER;
2150                 return 0;
2151             }
2152         }
2153 #endif
2154 #ifndef OPENSSL_NO_NEXTPROTONEG
2155         else if (type == TLSEXT_TYPE_next_proto_neg &&
2156                  s->s3->tmp.finish_md_len == 0 &&
2157                  s->s3->alpn_selected == NULL) {
2158             /*-
2159              * We shouldn't accept this extension on a
2160              * renegotiation.
2161              *
2162              * s->new_session will be set on renegotiation, but we
2163              * probably shouldn't rely that it couldn't be set on
2164              * the initial renegotation too in certain cases (when
2165              * there's some other reason to disallow resuming an
2166              * earlier session -- the current code won't be doing
2167              * anything like that, but this might change).
2168              *
2169              * A valid sign that there's been a previous handshake
2170              * in this connection is if s->s3->tmp.finish_md_len >
2171              * 0.  (We are talking about a check that will happen
2172              * in the Hello protocol round, well before a new
2173              * Finished message could have been computed.)
2174              */
2175             s->s3->next_proto_neg_seen = 1;
2176         }
2177 #endif
2178
2179         else if (type == TLSEXT_TYPE_application_layer_protocol_negotiation &&
2180                  s->ctx->alpn_select_cb && s->s3->tmp.finish_md_len == 0) {
2181             if (tls1_alpn_handle_client_hello(s, &subpkt, al) != 0)
2182                 return 0;
2183 #ifndef OPENSSL_NO_NEXTPROTONEG
2184             /* ALPN takes precedence over NPN. */
2185             s->s3->next_proto_neg_seen = 0;
2186 #endif
2187         }
2188
2189         /* session ticket processed earlier */
2190 #ifndef OPENSSL_NO_SRTP
2191         else if (SSL_IS_DTLS(s) && SSL_get_srtp_profiles(s)
2192                  && type == TLSEXT_TYPE_use_srtp) {
2193             if (ssl_parse_clienthello_use_srtp_ext(s, &subpkt, al))
2194                 return 0;
2195         }
2196 #endif
2197 #ifdef TLSEXT_TYPE_encrypt_then_mac
2198         else if (type == TLSEXT_TYPE_encrypt_then_mac)
2199             s->s3->flags |= TLS1_FLAGS_ENCRYPT_THEN_MAC;
2200 #endif
2201         /*
2202          * Note: extended master secret extension handled in
2203          * tls_check_serverhello_tlsext_early()
2204          */
2205
2206         /*
2207          * If this ClientHello extension was unhandled and this is a
2208          * nonresumed connection, check whether the extension is a custom
2209          * TLS Extension (has a custom_srv_ext_record), and if so call the
2210          * callback and record the extension number so that an appropriate
2211          * ServerHello may be later returned.
2212          */
2213         else if (!s->hit) {
2214             if (custom_ext_parse(s, 1, type, data, size, al) <= 0)
2215                 return 0;
2216         }
2217     }
2218
2219     /* Spurious data on the end */
2220     if (PACKET_remaining(pkt) != 0)
2221         goto err;
2222
2223  ri_check:
2224
2225     /* Need RI if renegotiating */
2226
2227     if (!renegotiate_seen && s->renegotiate &&
2228         !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)) {
2229         *al = SSL_AD_HANDSHAKE_FAILURE;
2230         SSLerr(SSL_F_SSL_SCAN_CLIENTHELLO_TLSEXT,
2231                SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
2232         return 0;
2233     }
2234
2235     return 1;
2236 err:
2237     *al = SSL_AD_DECODE_ERROR;
2238     return 0;
2239 }
2240
2241 int ssl_parse_clienthello_tlsext(SSL *s, PACKET *pkt)
2242 {
2243     int al = -1;
2244     custom_ext_init(&s->cert->srv_ext);
2245     if (ssl_scan_clienthello_tlsext(s, pkt, &al) <= 0) {
2246         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2247         return 0;
2248     }
2249
2250     if (ssl_check_clienthello_tlsext_early(s) <= 0) {
2251         SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_TLSEXT, SSL_R_CLIENTHELLO_TLSEXT);
2252         return 0;
2253     }
2254     return 1;
2255 }
2256
2257 #ifndef OPENSSL_NO_NEXTPROTONEG
2258 /*
2259  * ssl_next_proto_validate validates a Next Protocol Negotiation block. No
2260  * elements of zero length are allowed and the set of elements must exactly
2261  * fill the length of the block.
2262  */
2263 static char ssl_next_proto_validate(PACKET *pkt)
2264 {
2265     unsigned int len;
2266
2267     while (PACKET_remaining(pkt)) {
2268         if (!PACKET_get_1(pkt, &len)
2269                 || !PACKET_forward(pkt, len))
2270             return 0;
2271     }
2272
2273     return 1;
2274 }
2275 #endif
2276
2277 static int ssl_scan_serverhello_tlsext(SSL *s, PACKET *pkt, int *al)
2278 {
2279     unsigned int length, type, size;
2280     int tlsext_servername = 0;
2281     int renegotiate_seen = 0;
2282
2283 #ifndef OPENSSL_NO_NEXTPROTONEG
2284     s->s3->next_proto_neg_seen = 0;
2285 #endif
2286     s->tlsext_ticket_expected = 0;
2287
2288     OPENSSL_free(s->s3->alpn_selected);
2289     s->s3->alpn_selected = NULL;
2290 #ifndef OPENSSL_NO_HEARTBEATS
2291     s->tlsext_heartbeat &= ~(SSL_DTLSEXT_HB_ENABLED |
2292                              SSL_DTLSEXT_HB_DONT_SEND_REQUESTS);
2293 #endif
2294
2295 #ifdef TLSEXT_TYPE_encrypt_then_mac
2296     s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
2297 #endif
2298
2299     s->s3->flags &= ~TLS1_FLAGS_RECEIVED_EXTMS;
2300
2301     if (!PACKET_get_net_2(pkt, &length))
2302         goto ri_check;
2303
2304     if (PACKET_remaining(pkt) != length) {
2305         *al = SSL_AD_DECODE_ERROR;
2306         return 0;
2307     }
2308
2309     while (PACKET_get_net_2(pkt, &type) && PACKET_get_net_2(pkt, &size)) {
2310         const unsigned char *data;
2311         PACKET spkt;
2312
2313         if (!PACKET_get_sub_packet(pkt, &spkt, size)
2314                 ||  !PACKET_peek_bytes(&spkt, &data, size))
2315             goto ri_check;
2316
2317         if (s->tlsext_debug_cb)
2318             s->tlsext_debug_cb(s, 1, type, data, size, s->tlsext_debug_arg);
2319
2320         if (type == TLSEXT_TYPE_renegotiate) {
2321             if (!ssl_parse_serverhello_renegotiate_ext(s, &spkt, al))
2322                 return 0;
2323             renegotiate_seen = 1;
2324         } else if (s->version == SSL3_VERSION) {
2325         } else if (type == TLSEXT_TYPE_server_name) {
2326             if (s->tlsext_hostname == NULL || size > 0) {
2327                 *al = TLS1_AD_UNRECOGNIZED_NAME;
2328                 return 0;
2329             }
2330             tlsext_servername = 1;
2331         }
2332 #ifndef OPENSSL_NO_EC
2333         else if (type == TLSEXT_TYPE_ec_point_formats) {
2334             unsigned int ecpointformatlist_length;
2335             if (!PACKET_get_1(&spkt, &ecpointformatlist_length)
2336                     || ecpointformatlist_length != size - 1) {
2337                 *al = TLS1_AD_DECODE_ERROR;
2338                 return 0;
2339             }
2340             if (!s->hit) {
2341                 s->session->tlsext_ecpointformatlist_length = 0;
2342                 OPENSSL_free(s->session->tlsext_ecpointformatlist);
2343                 if ((s->session->tlsext_ecpointformatlist =
2344                      OPENSSL_malloc(ecpointformatlist_length)) == NULL) {
2345                     *al = TLS1_AD_INTERNAL_ERROR;
2346                     return 0;
2347                 }
2348                 s->session->tlsext_ecpointformatlist_length =
2349                     ecpointformatlist_length;
2350                 if (!PACKET_copy_bytes(&spkt,
2351                                        s->session->tlsext_ecpointformatlist,
2352                                        ecpointformatlist_length)) {
2353                     *al = TLS1_AD_DECODE_ERROR;
2354                     return 0;
2355                 }
2356
2357             }
2358         }
2359 #endif                         /* OPENSSL_NO_EC */
2360
2361         else if (type == TLSEXT_TYPE_session_ticket) {
2362             if (s->tls_session_ticket_ext_cb &&
2363                 !s->tls_session_ticket_ext_cb(s, data, size,
2364                                               s->tls_session_ticket_ext_cb_arg))
2365             {
2366                 *al = TLS1_AD_INTERNAL_ERROR;
2367                 return 0;
2368             }
2369             if (!tls_use_ticket(s) || (size > 0)) {
2370                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
2371                 return 0;
2372             }
2373             s->tlsext_ticket_expected = 1;
2374         }
2375         else if (type == TLSEXT_TYPE_status_request) {
2376             /*
2377              * MUST be empty and only sent if we've requested a status
2378              * request message.
2379              */
2380             if ((s->tlsext_status_type == -1) || (size > 0)) {
2381                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
2382                 return 0;
2383             }
2384             /* Set flag to expect CertificateStatus message */
2385             s->tlsext_status_expected = 1;
2386         }
2387 #ifndef OPENSSL_NO_NEXTPROTONEG
2388         else if (type == TLSEXT_TYPE_next_proto_neg &&
2389                  s->s3->tmp.finish_md_len == 0) {
2390             unsigned char *selected;
2391             unsigned char selected_len;
2392             /* We must have requested it. */
2393             if (s->ctx->next_proto_select_cb == NULL) {
2394                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
2395                 return 0;
2396             }
2397             /* The data must be valid */
2398             if (!ssl_next_proto_validate(&spkt)) {
2399                 *al = TLS1_AD_DECODE_ERROR;
2400                 return 0;
2401             }
2402             if (s->
2403                 ctx->next_proto_select_cb(s, &selected, &selected_len, data,
2404                                           size,
2405                                           s->ctx->next_proto_select_cb_arg) !=
2406                 SSL_TLSEXT_ERR_OK) {
2407                 *al = TLS1_AD_INTERNAL_ERROR;
2408                 return 0;
2409             }
2410             s->next_proto_negotiated = OPENSSL_malloc(selected_len);
2411             if (s->next_proto_negotiated == NULL) {
2412                 *al = TLS1_AD_INTERNAL_ERROR;
2413                 return 0;
2414             }
2415             memcpy(s->next_proto_negotiated, selected, selected_len);
2416             s->next_proto_negotiated_len = selected_len;
2417             s->s3->next_proto_neg_seen = 1;
2418         }
2419 #endif
2420
2421         else if (type == TLSEXT_TYPE_application_layer_protocol_negotiation) {
2422             unsigned len;
2423             /* We must have requested it. */
2424             if (s->alpn_client_proto_list == NULL) {
2425                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
2426                 return 0;
2427             }
2428             /*-
2429              * The extension data consists of:
2430              *   uint16 list_length
2431              *   uint8 proto_length;
2432              *   uint8 proto[proto_length];
2433              */
2434             if (!PACKET_get_net_2(&spkt, &len)
2435                     || PACKET_remaining(&spkt) != len
2436                     || !PACKET_get_1(&spkt, &len)
2437                     || PACKET_remaining(&spkt) != len) {
2438                 *al = TLS1_AD_DECODE_ERROR;
2439                 return 0;
2440             }
2441             OPENSSL_free(s->s3->alpn_selected);
2442             s->s3->alpn_selected = OPENSSL_malloc(len);
2443             if (s->s3->alpn_selected == NULL) {
2444                 *al = TLS1_AD_INTERNAL_ERROR;
2445                 return 0;
2446             }
2447             if (!PACKET_copy_bytes(&spkt, s->s3->alpn_selected, len)) {
2448                 *al = TLS1_AD_DECODE_ERROR;
2449                 return 0;
2450             }
2451             s->s3->alpn_selected_len = len;
2452         }
2453 #ifndef OPENSSL_NO_HEARTBEATS
2454         else if (SSL_IS_DTLS(s) && type == TLSEXT_TYPE_heartbeat) {
2455             unsigned int hbtype;
2456             if (!PACKET_get_1(&spkt, &hbtype)) {
2457                 *al = SSL_AD_DECODE_ERROR;
2458                 return 0;
2459             }
2460             switch (hbtype) {
2461             case 0x01:         /* Server allows us to send HB requests */
2462                 s->tlsext_heartbeat |= SSL_DTLSEXT_HB_ENABLED;
2463                 break;
2464             case 0x02:         /* Server doesn't accept HB requests */
2465                 s->tlsext_heartbeat |= SSL_DTLSEXT_HB_ENABLED;
2466                 s->tlsext_heartbeat |= SSL_DTLSEXT_HB_DONT_SEND_REQUESTS;
2467                 break;
2468             default:
2469                 *al = SSL_AD_ILLEGAL_PARAMETER;
2470                 return 0;
2471             }
2472         }
2473 #endif
2474 #ifndef OPENSSL_NO_SRTP
2475         else if (SSL_IS_DTLS(s) && type == TLSEXT_TYPE_use_srtp) {
2476             if (ssl_parse_serverhello_use_srtp_ext(s, &spkt, al))
2477                 return 0;
2478         }
2479 #endif
2480 #ifdef TLSEXT_TYPE_encrypt_then_mac
2481         else if (type == TLSEXT_TYPE_encrypt_then_mac) {
2482             /* Ignore if inappropriate ciphersuite */
2483             if (s->s3->tmp.new_cipher->algorithm_mac != SSL_AEAD
2484                 && s->s3->tmp.new_cipher->algorithm_enc != SSL_RC4)
2485                 s->s3->flags |= TLS1_FLAGS_ENCRYPT_THEN_MAC;
2486         }
2487 #endif
2488         else if (type == TLSEXT_TYPE_extended_master_secret) {
2489             s->s3->flags |= TLS1_FLAGS_RECEIVED_EXTMS;
2490             if (!s->hit)
2491                 s->session->flags |= SSL_SESS_FLAG_EXTMS;
2492         }
2493         /*
2494          * If this extension type was not otherwise handled, but matches a
2495          * custom_cli_ext_record, then send it to the c callback
2496          */
2497         else if (custom_ext_parse(s, 0, type, data, size, al) <= 0)
2498             return 0;
2499     }
2500
2501     if (PACKET_remaining(pkt) != 0) {
2502         *al = SSL_AD_DECODE_ERROR;
2503         return 0;
2504     }
2505
2506     if (!s->hit && tlsext_servername == 1) {
2507         if (s->tlsext_hostname) {
2508             if (s->session->tlsext_hostname == NULL) {
2509                 s->session->tlsext_hostname = OPENSSL_strdup(s->tlsext_hostname);
2510                 if (!s->session->tlsext_hostname) {
2511                     *al = SSL_AD_UNRECOGNIZED_NAME;
2512                     return 0;
2513                 }
2514             } else {
2515                 *al = SSL_AD_DECODE_ERROR;
2516                 return 0;
2517             }
2518         }
2519     }
2520
2521  ri_check:
2522
2523     /*
2524      * Determine if we need to see RI. Strictly speaking if we want to avoid
2525      * an attack we should *always* see RI even on initial server hello
2526      * because the client doesn't see any renegotiation during an attack.
2527      * However this would mean we could not connect to any server which
2528      * doesn't support RI so for the immediate future tolerate RI absence on
2529      * initial connect only.
2530      */
2531     if (!renegotiate_seen && !(s->options & SSL_OP_LEGACY_SERVER_CONNECT)
2532         && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)) {
2533         *al = SSL_AD_HANDSHAKE_FAILURE;
2534         SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT,
2535                SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
2536         return 0;
2537     }
2538
2539     if (s->hit) {
2540         /*
2541          * Check extended master secret extension is consistent with
2542          * original session.
2543          */
2544         if (!(s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) !=
2545             !(s->session->flags & SSL_SESS_FLAG_EXTMS)) {
2546             *al = SSL_AD_HANDSHAKE_FAILURE;
2547             SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT, SSL_R_INCONSISTENT_EXTMS);
2548             return 0;
2549             }
2550     }
2551
2552     return 1;
2553 }
2554
2555 int ssl_prepare_clienthello_tlsext(SSL *s)
2556 {
2557
2558     return 1;
2559 }
2560
2561 int ssl_prepare_serverhello_tlsext(SSL *s)
2562 {
2563     return 1;
2564 }
2565
2566 static int ssl_check_clienthello_tlsext_early(SSL *s)
2567 {
2568     int ret = SSL_TLSEXT_ERR_NOACK;
2569     int al = SSL_AD_UNRECOGNIZED_NAME;
2570
2571 #ifndef OPENSSL_NO_EC
2572     /*
2573      * The handling of the ECPointFormats extension is done elsewhere, namely
2574      * in ssl3_choose_cipher in s3_lib.c.
2575      */
2576     /*
2577      * The handling of the EllipticCurves extension is done elsewhere, namely
2578      * in ssl3_choose_cipher in s3_lib.c.
2579      */
2580 #endif
2581
2582     if (s->ctx != NULL && s->ctx->tlsext_servername_callback != 0)
2583         ret =
2584             s->ctx->tlsext_servername_callback(s, &al,
2585                                                s->ctx->tlsext_servername_arg);
2586     else if (s->initial_ctx != NULL
2587              && s->initial_ctx->tlsext_servername_callback != 0)
2588         ret =
2589             s->initial_ctx->tlsext_servername_callback(s, &al,
2590                                                        s->
2591                                                        initial_ctx->tlsext_servername_arg);
2592
2593     switch (ret) {
2594     case SSL_TLSEXT_ERR_ALERT_FATAL:
2595         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2596         return -1;
2597
2598     case SSL_TLSEXT_ERR_ALERT_WARNING:
2599         ssl3_send_alert(s, SSL3_AL_WARNING, al);
2600         return 1;
2601
2602     case SSL_TLSEXT_ERR_NOACK:
2603         s->servername_done = 0;
2604     default:
2605         return 1;
2606     }
2607 }
2608 /* Initialise digests to default values */
2609 void ssl_set_default_md(SSL *s)
2610 {
2611     const EVP_MD **pmd = s->s3->tmp.md;
2612 #ifndef OPENSSL_NO_DSA
2613     pmd[SSL_PKEY_DSA_SIGN] = ssl_md(SSL_MD_SHA1_IDX);
2614 #endif
2615 #ifndef OPENSSL_NO_RSA
2616     if (SSL_USE_SIGALGS(s))
2617         pmd[SSL_PKEY_RSA_SIGN] = ssl_md(SSL_MD_SHA1_IDX);
2618     else
2619         pmd[SSL_PKEY_RSA_SIGN] = ssl_md(SSL_MD_MD5_SHA1_IDX);
2620     pmd[SSL_PKEY_RSA_ENC] = pmd[SSL_PKEY_RSA_SIGN];
2621 #endif
2622 #ifndef OPENSSL_NO_EC
2623     pmd[SSL_PKEY_ECC] = ssl_md(SSL_MD_SHA1_IDX);
2624 #endif
2625 #ifndef OPENSSL_NO_GOST
2626     pmd[SSL_PKEY_GOST01] = ssl_md(SSL_MD_GOST94_IDX);
2627     pmd[SSL_PKEY_GOST12_256] = ssl_md(SSL_MD_GOST12_256_IDX);
2628     pmd[SSL_PKEY_GOST12_512] = ssl_md(SSL_MD_GOST12_512_IDX);
2629 #endif
2630 }
2631
2632 int tls1_set_server_sigalgs(SSL *s)
2633 {
2634     int al;
2635     size_t i;
2636     /* Clear any shared sigtnature algorithms */
2637     OPENSSL_free(s->cert->shared_sigalgs);
2638     s->cert->shared_sigalgs = NULL;
2639     s->cert->shared_sigalgslen = 0;
2640     /* Clear certificate digests and validity flags */
2641     for (i = 0; i < SSL_PKEY_NUM; i++) {
2642         s->s3->tmp.md[i] = NULL;
2643         s->s3->tmp.valid_flags[i] = 0;
2644     }
2645
2646     /* If sigalgs received process it. */
2647     if (s->s3->tmp.peer_sigalgs) {
2648         if (!tls1_process_sigalgs(s)) {
2649             SSLerr(SSL_F_TLS1_SET_SERVER_SIGALGS, ERR_R_MALLOC_FAILURE);
2650             al = SSL_AD_INTERNAL_ERROR;
2651             goto err;
2652         }
2653         /* Fatal error is no shared signature algorithms */
2654         if (!s->cert->shared_sigalgs) {
2655             SSLerr(SSL_F_TLS1_SET_SERVER_SIGALGS,
2656                    SSL_R_NO_SHARED_SIGATURE_ALGORITHMS);
2657             al = SSL_AD_ILLEGAL_PARAMETER;
2658             goto err;
2659         }
2660     } else {
2661         ssl_set_default_md(s);
2662     }
2663     return 1;
2664  err:
2665     ssl3_send_alert(s, SSL3_AL_FATAL, al);
2666     return 0;
2667 }
2668
2669 int ssl_check_clienthello_tlsext_late(SSL *s)
2670 {
2671     int ret = SSL_TLSEXT_ERR_OK;
2672     int al = SSL_AD_INTERNAL_ERROR;
2673
2674     /*
2675      * If status request then ask callback what to do. Note: this must be
2676      * called after servername callbacks in case the certificate has changed,
2677      * and must be called after the cipher has been chosen because this may
2678      * influence which certificate is sent
2679      */
2680     if ((s->tlsext_status_type != -1) && s->ctx && s->ctx->tlsext_status_cb) {
2681         int r;
2682         CERT_PKEY *certpkey;
2683         certpkey = ssl_get_server_send_pkey(s);
2684         /* If no certificate can't return certificate status */
2685         if (certpkey == NULL) {
2686             s->tlsext_status_expected = 0;
2687             return 1;
2688         }
2689         /*
2690          * Set current certificate to one we will use so SSL_get_certificate
2691          * et al can pick it up.
2692          */
2693         s->cert->key = certpkey;
2694         r = s->ctx->tlsext_status_cb(s, s->ctx->tlsext_status_arg);
2695         switch (r) {
2696             /* We don't want to send a status request response */
2697         case SSL_TLSEXT_ERR_NOACK:
2698             s->tlsext_status_expected = 0;
2699             break;
2700             /* status request response should be sent */
2701         case SSL_TLSEXT_ERR_OK:
2702             if (s->tlsext_ocsp_resp)
2703                 s->tlsext_status_expected = 1;
2704             else
2705                 s->tlsext_status_expected = 0;
2706             break;
2707             /* something bad happened */
2708         case SSL_TLSEXT_ERR_ALERT_FATAL:
2709             ret = SSL_TLSEXT_ERR_ALERT_FATAL;
2710             al = SSL_AD_INTERNAL_ERROR;
2711             goto err;
2712         }
2713     } else
2714         s->tlsext_status_expected = 0;
2715
2716  err:
2717     switch (ret) {
2718     case SSL_TLSEXT_ERR_ALERT_FATAL:
2719         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2720         return -1;
2721
2722     case SSL_TLSEXT_ERR_ALERT_WARNING:
2723         ssl3_send_alert(s, SSL3_AL_WARNING, al);
2724         return 1;
2725
2726     default:
2727         return 1;
2728     }
2729 }
2730
2731 int ssl_check_serverhello_tlsext(SSL *s)
2732 {
2733     int ret = SSL_TLSEXT_ERR_NOACK;
2734     int al = SSL_AD_UNRECOGNIZED_NAME;
2735
2736 #ifndef OPENSSL_NO_EC
2737     /*
2738      * If we are client and using an elliptic curve cryptography cipher
2739      * suite, then if server returns an EC point formats lists extension it
2740      * must contain uncompressed.
2741      */
2742     unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
2743     unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
2744     if ((s->tlsext_ecpointformatlist != NULL)
2745         && (s->tlsext_ecpointformatlist_length > 0)
2746         && (s->session->tlsext_ecpointformatlist != NULL)
2747         && (s->session->tlsext_ecpointformatlist_length > 0)
2748         && ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))) {
2749         /* we are using an ECC cipher */
2750         size_t i;
2751         unsigned char *list;
2752         int found_uncompressed = 0;
2753         list = s->session->tlsext_ecpointformatlist;
2754         for (i = 0; i < s->session->tlsext_ecpointformatlist_length; i++) {
2755             if (*(list++) == TLSEXT_ECPOINTFORMAT_uncompressed) {
2756                 found_uncompressed = 1;
2757                 break;
2758             }
2759         }
2760         if (!found_uncompressed) {
2761             SSLerr(SSL_F_SSL_CHECK_SERVERHELLO_TLSEXT,
2762                    SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST);
2763             return -1;
2764         }
2765     }
2766     ret = SSL_TLSEXT_ERR_OK;
2767 #endif                         /* OPENSSL_NO_EC */
2768
2769     if (s->ctx != NULL && s->ctx->tlsext_servername_callback != 0)
2770         ret =
2771             s->ctx->tlsext_servername_callback(s, &al,
2772                                                s->ctx->tlsext_servername_arg);
2773     else if (s->initial_ctx != NULL
2774              && s->initial_ctx->tlsext_servername_callback != 0)
2775         ret =
2776             s->initial_ctx->tlsext_servername_callback(s, &al,
2777                                                        s->
2778                                                        initial_ctx->tlsext_servername_arg);
2779
2780     /*
2781      * Ensure we get sensible values passed to tlsext_status_cb in the event
2782      * that we don't receive a status message
2783      */
2784     OPENSSL_free(s->tlsext_ocsp_resp);
2785     s->tlsext_ocsp_resp = NULL;
2786     s->tlsext_ocsp_resplen = -1;
2787
2788     switch (ret) {
2789     case SSL_TLSEXT_ERR_ALERT_FATAL:
2790         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2791         return -1;
2792
2793     case SSL_TLSEXT_ERR_ALERT_WARNING:
2794         ssl3_send_alert(s, SSL3_AL_WARNING, al);
2795         return 1;
2796
2797     case SSL_TLSEXT_ERR_NOACK:
2798         s->servername_done = 0;
2799     default:
2800         return 1;
2801     }
2802 }
2803
2804 int ssl_parse_serverhello_tlsext(SSL *s, PACKET *pkt)
2805 {
2806     int al = -1;
2807     if (s->version < SSL3_VERSION)
2808         return 1;
2809     if (ssl_scan_serverhello_tlsext(s, pkt, &al) <= 0) {
2810         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2811         return 0;
2812     }
2813
2814     if (ssl_check_serverhello_tlsext(s) <= 0) {
2815         SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_TLSEXT, SSL_R_SERVERHELLO_TLSEXT);
2816         return 0;
2817     }
2818     return 1;
2819 }
2820
2821 /*-
2822  * Since the server cache lookup is done early on in the processing of the
2823  * ClientHello and other operations depend on the result some extensions
2824  * need to be handled at the same time.
2825  *
2826  * Two extensions are currently handled, session ticket and extended master
2827  * secret.
2828  *
2829  *   session_id: ClientHello session ID.
2830  *   ext: ClientHello extensions (including length prefix)
2831  *   ret: (output) on return, if a ticket was decrypted, then this is set to
2832  *       point to the resulting session.
2833  *
2834  * If s->tls_session_secret_cb is set then we are expecting a pre-shared key
2835  * ciphersuite, in which case we have no use for session tickets and one will
2836  * never be decrypted, nor will s->tlsext_ticket_expected be set to 1.
2837  *
2838  * Returns:
2839  *   -1: fatal error, either from parsing or decrypting the ticket.
2840  *    0: no ticket was found (or was ignored, based on settings).
2841  *    1: a zero length extension was found, indicating that the client supports
2842  *       session tickets but doesn't currently have one to offer.
2843  *    2: either s->tls_session_secret_cb was set, or a ticket was offered but
2844  *       couldn't be decrypted because of a non-fatal error.
2845  *    3: a ticket was successfully decrypted and *ret was set.
2846  *
2847  * Side effects:
2848  *   Sets s->tlsext_ticket_expected to 1 if the server will have to issue
2849  *   a new session ticket to the client because the client indicated support
2850  *   (and s->tls_session_secret_cb is NULL) but the client either doesn't have
2851  *   a session ticket or we couldn't use the one it gave us, or if
2852  *   s->ctx->tlsext_ticket_key_cb asked to renew the client's ticket.
2853  *   Otherwise, s->tlsext_ticket_expected is set to 0.
2854  *
2855  *   For extended master secret flag is set if the extension is present.
2856  *
2857  */
2858 int tls_check_serverhello_tlsext_early(SSL *s, const PACKET *ext,
2859                                        const PACKET *session_id,
2860                                        SSL_SESSION **ret)
2861 {
2862     unsigned int i;
2863     PACKET local_ext = *ext;
2864     int retv = -1;
2865
2866     int have_ticket = 0;
2867     int use_ticket = tls_use_ticket(s);
2868
2869     *ret = NULL;
2870     s->tlsext_ticket_expected = 0;
2871     s->s3->flags &= ~TLS1_FLAGS_RECEIVED_EXTMS;
2872
2873     /*
2874      * If tickets disabled behave as if no ticket present to permit stateful
2875      * resumption.
2876      */
2877     if ((s->version <= SSL3_VERSION))
2878         return 0;
2879
2880     if (!PACKET_get_net_2(&local_ext, &i)) {
2881         retv = 0;
2882         goto end;
2883     }
2884     while (PACKET_remaining(&local_ext) >= 4) {
2885         unsigned int type, size;
2886
2887         if (!PACKET_get_net_2(&local_ext, &type)
2888                 || !PACKET_get_net_2(&local_ext, &size)) {
2889             /* Shouldn't ever happen */
2890             retv = -1;
2891             goto end;
2892         }
2893         if (PACKET_remaining(&local_ext) < size) {
2894             retv = 0;
2895             goto end;
2896         }
2897         if (type == TLSEXT_TYPE_session_ticket && use_ticket) {
2898             int r;
2899             const unsigned char *etick;
2900
2901             /* Duplicate extension */
2902             if (have_ticket != 0) {
2903                 retv = -1;
2904                 goto end;
2905             }
2906             have_ticket = 1;
2907
2908             if (size == 0) {
2909                 /*
2910                  * The client will accept a ticket but doesn't currently have
2911                  * one.
2912                  */
2913                 s->tlsext_ticket_expected = 1;
2914                 retv = 1;
2915                 continue;
2916             }
2917             if (s->tls_session_secret_cb) {
2918                 /*
2919                  * Indicate that the ticket couldn't be decrypted rather than
2920                  * generating the session from ticket now, trigger
2921                  * abbreviated handshake based on external mechanism to
2922                  * calculate the master secret later.
2923                  */
2924                 retv = 2;
2925                 continue;
2926             }
2927             if (!PACKET_get_bytes(&local_ext, &etick, size)) {
2928                 /* Shouldn't ever happen */
2929                 retv = -1;
2930                 goto end;
2931             }
2932             r = tls_decrypt_ticket(s, etick, size, PACKET_data(session_id),
2933                                    PACKET_remaining(session_id), ret);
2934             switch (r) {
2935             case 2:            /* ticket couldn't be decrypted */
2936                 s->tlsext_ticket_expected = 1;
2937                 retv = 2;
2938                 break;
2939             case 3:            /* ticket was decrypted */
2940                 retv = r;
2941                 break;
2942             case 4:            /* ticket decrypted but need to renew */
2943                 s->tlsext_ticket_expected = 1;
2944                 retv = 3;
2945                 break;
2946             default:           /* fatal error */
2947                 retv = -1;
2948                 break;
2949             }
2950             continue;
2951         } else {
2952             if (type == TLSEXT_TYPE_extended_master_secret)
2953                 s->s3->flags |= TLS1_FLAGS_RECEIVED_EXTMS;
2954             if (!PACKET_forward(&local_ext, size)) {
2955                 retv = -1;
2956                 goto end;
2957             }
2958         }
2959     }
2960     if (have_ticket == 0)
2961         retv = 0;
2962 end:
2963     return retv;
2964 }
2965
2966 /*-
2967  * tls_decrypt_ticket attempts to decrypt a session ticket.
2968  *
2969  *   etick: points to the body of the session ticket extension.
2970  *   eticklen: the length of the session tickets extenion.
2971  *   sess_id: points at the session ID.
2972  *   sesslen: the length of the session ID.
2973  *   psess: (output) on return, if a ticket was decrypted, then this is set to
2974  *       point to the resulting session.
2975  *
2976  * Returns:
2977  *   -2: fatal error, malloc failure.
2978  *   -1: fatal error, either from parsing or decrypting the ticket.
2979  *    2: the ticket couldn't be decrypted.
2980  *    3: a ticket was successfully decrypted and *psess was set.
2981  *    4: same as 3, but the ticket needs to be renewed.
2982  */
2983 static int tls_decrypt_ticket(SSL *s, const unsigned char *etick,
2984                               int eticklen, const unsigned char *sess_id,
2985                               int sesslen, SSL_SESSION **psess)
2986 {
2987     SSL_SESSION *sess;
2988     unsigned char *sdec;
2989     const unsigned char *p;
2990     int slen, mlen, renew_ticket = 0, ret = -1;
2991     unsigned char tick_hmac[EVP_MAX_MD_SIZE];
2992     HMAC_CTX *hctx = NULL;
2993     EVP_CIPHER_CTX *ctx;
2994     SSL_CTX *tctx = s->initial_ctx;
2995     /* Need at least keyname + iv + some encrypted data */
2996     if (eticklen < 48)
2997         return 2;
2998     /* Initialize session ticket encryption and HMAC contexts */
2999     hctx = HMAC_CTX_new();
3000     if (hctx == NULL)
3001         return -2;
3002     ctx = EVP_CIPHER_CTX_new();
3003     if (ctx == NULL) {
3004         ret = -2;
3005         goto err;
3006     }
3007     if (tctx->tlsext_ticket_key_cb) {
3008         unsigned char *nctick = (unsigned char *)etick;
3009         int rv = tctx->tlsext_ticket_key_cb(s, nctick, nctick + 16,
3010                                             ctx, hctx, 0);
3011         if (rv < 0)
3012             goto err;
3013         if (rv == 0) {
3014             ret = 2;
3015             goto err;
3016         }
3017         if (rv == 2)
3018             renew_ticket = 1;
3019     } else {
3020         /* Check key name matches */
3021         if (memcmp(etick, tctx->tlsext_tick_key_name, 16)) {
3022             ret = 2;
3023             goto err;
3024         }
3025         if (HMAC_Init_ex(hctx, tctx->tlsext_tick_hmac_key, 16,
3026                          EVP_sha256(), NULL) <= 0
3027                 || EVP_DecryptInit_ex(ctx, EVP_aes_128_cbc(), NULL,
3028                                       tctx->tlsext_tick_aes_key,
3029                                       etick + 16) <= 0) {
3030             goto err;
3031        }
3032     }
3033     /*
3034      * Attempt to process session ticket, first conduct sanity and integrity
3035      * checks on ticket.
3036      */
3037     mlen = HMAC_size(hctx);
3038     if (mlen < 0) {
3039         goto err;
3040     }
3041     eticklen -= mlen;
3042     /* Check HMAC of encrypted ticket */
3043     if (HMAC_Update(hctx, etick, eticklen) <= 0
3044             || HMAC_Final(hctx, tick_hmac, NULL) <= 0) {
3045         goto err;
3046     }
3047     HMAC_CTX_free(hctx);
3048     if (CRYPTO_memcmp(tick_hmac, etick + eticklen, mlen)) {
3049         EVP_CIPHER_CTX_free(ctx);
3050         return 2;
3051     }
3052     /* Attempt to decrypt session data */
3053     /* Move p after IV to start of encrypted ticket, update length */
3054     p = etick + 16 + EVP_CIPHER_CTX_iv_length(ctx);
3055     eticklen -= 16 + EVP_CIPHER_CTX_iv_length(ctx);
3056     sdec = OPENSSL_malloc(eticklen);
3057     if (sdec == NULL
3058             || EVP_DecryptUpdate(ctx, sdec, &slen, p, eticklen) <= 0) {
3059         EVP_CIPHER_CTX_free(ctx);
3060         return -1;
3061     }
3062     if (EVP_DecryptFinal(ctx, sdec + slen, &mlen) <= 0) {
3063         EVP_CIPHER_CTX_free(ctx);
3064         OPENSSL_free(sdec);
3065         return 2;
3066     }
3067     slen += mlen;
3068     EVP_CIPHER_CTX_free(ctx);
3069     ctx = NULL;
3070     p = sdec;
3071
3072     sess = d2i_SSL_SESSION(NULL, &p, slen);
3073     OPENSSL_free(sdec);
3074     if (sess) {
3075         /*
3076          * The session ID, if non-empty, is used by some clients to detect
3077          * that the ticket has been accepted. So we copy it to the session
3078          * structure. If it is empty set length to zero as required by
3079          * standard.
3080          */
3081         if (sesslen)
3082             memcpy(sess->session_id, sess_id, sesslen);
3083         sess->session_id_length = sesslen;
3084         *psess = sess;
3085         if (renew_ticket)
3086             return 4;
3087         else
3088             return 3;
3089     }
3090     ERR_clear_error();
3091     /*
3092      * For session parse failure, indicate that we need to send a new ticket.
3093      */
3094     return 2;
3095 err:
3096     EVP_CIPHER_CTX_free(ctx);
3097     HMAC_CTX_free(hctx);
3098     return ret;
3099 }
3100
3101 /* Tables to translate from NIDs to TLS v1.2 ids */
3102
3103 typedef struct {
3104     int nid;
3105     int id;
3106 } tls12_lookup;
3107
3108 static const tls12_lookup tls12_md[] = {
3109     {NID_md5, TLSEXT_hash_md5},
3110     {NID_sha1, TLSEXT_hash_sha1},
3111     {NID_sha224, TLSEXT_hash_sha224},
3112     {NID_sha256, TLSEXT_hash_sha256},
3113     {NID_sha384, TLSEXT_hash_sha384},
3114     {NID_sha512, TLSEXT_hash_sha512},
3115     {NID_id_GostR3411_94, TLSEXT_hash_gostr3411},
3116     {NID_id_GostR3411_2012_256, TLSEXT_hash_gostr34112012_256},
3117     {NID_id_GostR3411_2012_512, TLSEXT_hash_gostr34112012_512},
3118 };
3119
3120 static const tls12_lookup tls12_sig[] = {
3121     {EVP_PKEY_RSA, TLSEXT_signature_rsa},
3122     {EVP_PKEY_DSA, TLSEXT_signature_dsa},
3123     {EVP_PKEY_EC, TLSEXT_signature_ecdsa},
3124     {NID_id_GostR3410_2001, TLSEXT_signature_gostr34102001},
3125     {NID_id_GostR3410_2012_256, TLSEXT_signature_gostr34102012_256},
3126     {NID_id_GostR3410_2012_512, TLSEXT_signature_gostr34102012_512}
3127 };
3128
3129 static int tls12_find_id(int nid, const tls12_lookup *table, size_t tlen)
3130 {
3131     size_t i;
3132     for (i = 0; i < tlen; i++) {
3133         if (table[i].nid == nid)
3134             return table[i].id;
3135     }
3136     return -1;
3137 }
3138
3139 static int tls12_find_nid(int id, const tls12_lookup *table, size_t tlen)
3140 {
3141     size_t i;
3142     for (i = 0; i < tlen; i++) {
3143         if ((table[i].id) == id)
3144             return table[i].nid;
3145     }
3146     return NID_undef;
3147 }
3148
3149 int tls12_get_sigandhash(unsigned char *p, const EVP_PKEY *pk,
3150                          const EVP_MD *md)
3151 {
3152     int sig_id, md_id;
3153     if (!md)
3154         return 0;
3155     md_id = tls12_find_id(EVP_MD_type(md), tls12_md, OSSL_NELEM(tls12_md));
3156     if (md_id == -1)
3157         return 0;
3158     sig_id = tls12_get_sigid(pk);
3159     if (sig_id == -1)
3160         return 0;
3161     p[0] = (unsigned char)md_id;
3162     p[1] = (unsigned char)sig_id;
3163     return 1;
3164 }
3165
3166 int tls12_get_sigid(const EVP_PKEY *pk)
3167 {
3168     return tls12_find_id(EVP_PKEY_id(pk), tls12_sig, OSSL_NELEM(tls12_sig));
3169 }
3170
3171 typedef struct {
3172     int nid;
3173     int secbits;
3174     int md_idx;
3175     unsigned char tlsext_hash;
3176 } tls12_hash_info;
3177
3178 static const tls12_hash_info tls12_md_info[] = {
3179     {NID_md5, 64, SSL_MD_MD5_IDX, TLSEXT_hash_md5},
3180     {NID_sha1, 80, SSL_MD_SHA1_IDX, TLSEXT_hash_sha1},
3181     {NID_sha224, 112, SSL_MD_SHA224_IDX, TLSEXT_hash_sha224},
3182     {NID_sha256, 128, SSL_MD_SHA256_IDX, TLSEXT_hash_sha256},
3183     {NID_sha384, 192, SSL_MD_SHA384_IDX, TLSEXT_hash_sha384},
3184     {NID_sha512, 256, SSL_MD_SHA512_IDX, TLSEXT_hash_sha512},
3185     {NID_id_GostR3411_94,       128, SSL_MD_GOST94_IDX, TLSEXT_hash_gostr3411},
3186     {NID_id_GostR3411_2012_256, 128, SSL_MD_GOST12_256_IDX, TLSEXT_hash_gostr34112012_256},
3187     {NID_id_GostR3411_2012_512, 256, SSL_MD_GOST12_512_IDX, TLSEXT_hash_gostr34112012_512},
3188 };
3189
3190 static const tls12_hash_info *tls12_get_hash_info(unsigned char hash_alg)
3191 {
3192     unsigned int i;
3193     if (hash_alg == 0)
3194         return NULL;
3195
3196     for (i=0; i < OSSL_NELEM(tls12_md_info); i++)
3197     {
3198         if (tls12_md_info[i].tlsext_hash == hash_alg)
3199             return tls12_md_info + i;
3200     }
3201
3202     return NULL;
3203 }
3204
3205 const EVP_MD *tls12_get_hash(unsigned char hash_alg)
3206 {
3207     const tls12_hash_info *inf;
3208     if (hash_alg == TLSEXT_hash_md5 && FIPS_mode())
3209         return NULL;
3210     inf = tls12_get_hash_info(hash_alg);
3211     if (!inf)
3212         return NULL;
3213     return ssl_md(inf->md_idx);
3214 }
3215
3216 static int tls12_get_pkey_idx(unsigned char sig_alg)
3217 {
3218     switch (sig_alg) {
3219 #ifndef OPENSSL_NO_RSA
3220     case TLSEXT_signature_rsa:
3221         return SSL_PKEY_RSA_SIGN;
3222 #endif
3223 #ifndef OPENSSL_NO_DSA
3224     case TLSEXT_signature_dsa:
3225         return SSL_PKEY_DSA_SIGN;
3226 #endif
3227 #ifndef OPENSSL_NO_EC
3228     case TLSEXT_signature_ecdsa:
3229         return SSL_PKEY_ECC;
3230 #endif
3231 # ifndef OPENSSL_NO_GOST
3232     case TLSEXT_signature_gostr34102001:
3233         return SSL_PKEY_GOST01;
3234
3235     case TLSEXT_signature_gostr34102012_256:
3236         return SSL_PKEY_GOST12_256;
3237
3238     case TLSEXT_signature_gostr34102012_512:
3239         return SSL_PKEY_GOST12_512;
3240 # endif
3241     }
3242     return -1;
3243 }
3244
3245 /* Convert TLS 1.2 signature algorithm extension values into NIDs */
3246 static void tls1_lookup_sigalg(int *phash_nid, int *psign_nid,
3247                                int *psignhash_nid, const unsigned char *data)
3248 {
3249     int sign_nid = NID_undef, hash_nid = NID_undef;
3250     if (!phash_nid && !psign_nid && !psignhash_nid)
3251         return;
3252     if (phash_nid || psignhash_nid) {
3253         hash_nid = tls12_find_nid(data[0], tls12_md, OSSL_NELEM(tls12_md));
3254         if (phash_nid)
3255             *phash_nid = hash_nid;
3256     }
3257     if (psign_nid || psignhash_nid) {
3258         sign_nid = tls12_find_nid(data[1], tls12_sig, OSSL_NELEM(tls12_sig));
3259         if (psign_nid)
3260             *psign_nid = sign_nid;
3261     }
3262     if (psignhash_nid) {
3263         if (sign_nid == NID_undef || hash_nid == NID_undef
3264                 || OBJ_find_sigid_by_algs(psignhash_nid, hash_nid,
3265                                           sign_nid) <= 0)
3266             *psignhash_nid = NID_undef;
3267     }
3268 }
3269
3270 /* Check to see if a signature algorithm is allowed */
3271 static int tls12_sigalg_allowed(SSL *s, int op, const unsigned char *ptmp)
3272 {
3273     /* See if we have an entry in the hash table and it is enabled */
3274     const tls12_hash_info *hinf = tls12_get_hash_info(ptmp[0]);
3275     if (hinf == NULL || ssl_md(hinf->md_idx) == NULL)
3276         return 0;
3277     /* See if public key algorithm allowed */
3278     if (tls12_get_pkey_idx(ptmp[1]) == -1)
3279         return 0;
3280     /* Finally see if security callback allows it */
3281     return ssl_security(s, op, hinf->secbits, hinf->nid, (void *)ptmp);
3282 }
3283
3284 /*
3285  * Get a mask of disabled public key algorithms based on supported signature
3286  * algorithms. For example if no signature algorithm supports RSA then RSA is
3287  * disabled.
3288  */
3289
3290 void ssl_set_sig_mask(uint32_t *pmask_a, SSL *s, int op)
3291 {
3292     const unsigned char *sigalgs;
3293     size_t i, sigalgslen;
3294     int have_rsa = 0, have_dsa = 0, have_ecdsa = 0;
3295     /*
3296      * Now go through all signature algorithms seeing if we support any for
3297      * RSA, DSA, ECDSA. Do this for all versions not just TLS 1.2. To keep
3298      * down calls to security callback only check if we have to.
3299      */
3300     sigalgslen = tls12_get_psigalgs(s, &sigalgs);
3301     for (i = 0; i < sigalgslen; i += 2, sigalgs += 2) {
3302         switch (sigalgs[1]) {
3303 #ifndef OPENSSL_NO_RSA
3304         case TLSEXT_signature_rsa:
3305             if (!have_rsa && tls12_sigalg_allowed(s, op, sigalgs))
3306                 have_rsa = 1;
3307             break;
3308 #endif
3309 #ifndef OPENSSL_NO_DSA
3310         case TLSEXT_signature_dsa:
3311             if (!have_dsa && tls12_sigalg_allowed(s, op, sigalgs))
3312                 have_dsa = 1;
3313             break;
3314 #endif
3315 #ifndef OPENSSL_NO_EC
3316         case TLSEXT_signature_ecdsa:
3317             if (!have_ecdsa && tls12_sigalg_allowed(s, op, sigalgs))
3318                 have_ecdsa = 1;
3319             break;
3320 #endif
3321         }
3322     }
3323     if (!have_rsa)
3324         *pmask_a |= SSL_aRSA;
3325     if (!have_dsa)
3326         *pmask_a |= SSL_aDSS;
3327     if (!have_ecdsa)
3328         *pmask_a |= SSL_aECDSA;
3329 }
3330
3331 size_t tls12_copy_sigalgs(SSL *s, unsigned char *out,
3332                           const unsigned char *psig, size_t psiglen)
3333 {
3334     unsigned char *tmpout = out;
3335     size_t i;
3336     for (i = 0; i < psiglen; i += 2, psig += 2) {
3337         if (tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SUPPORTED, psig)) {
3338             *tmpout++ = psig[0];
3339             *tmpout++ = psig[1];
3340         }
3341     }
3342     return tmpout - out;
3343 }
3344
3345 /* Given preference and allowed sigalgs set shared sigalgs */
3346 static int tls12_shared_sigalgs(SSL *s, TLS_SIGALGS *shsig,
3347                                 const unsigned char *pref, size_t preflen,
3348                                 const unsigned char *allow, size_t allowlen)
3349 {
3350     const unsigned char *ptmp, *atmp;
3351     size_t i, j, nmatch = 0;
3352     for (i = 0, ptmp = pref; i < preflen; i += 2, ptmp += 2) {
3353         /* Skip disabled hashes or signature algorithms */
3354         if (!tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SHARED, ptmp))
3355             continue;
3356         for (j = 0, atmp = allow; j < allowlen; j += 2, atmp += 2) {
3357             if (ptmp[0] == atmp[0] && ptmp[1] == atmp[1]) {
3358                 nmatch++;
3359                 if (shsig) {
3360                     shsig->rhash = ptmp[0];
3361                     shsig->rsign = ptmp[1];
3362                     tls1_lookup_sigalg(&shsig->hash_nid,
3363                                        &shsig->sign_nid,
3364                                        &shsig->signandhash_nid, ptmp);
3365                     shsig++;
3366                 }
3367                 break;
3368             }
3369         }
3370     }
3371     return nmatch;
3372 }
3373
3374 /* Set shared signature algorithms for SSL structures */
3375 static int tls1_set_shared_sigalgs(SSL *s)
3376 {
3377     const unsigned char *pref, *allow, *conf;
3378     size_t preflen, allowlen, conflen;
3379     size_t nmatch;
3380     TLS_SIGALGS *salgs = NULL;
3381     CERT *c = s->cert;
3382     unsigned int is_suiteb = tls1_suiteb(s);
3383
3384     OPENSSL_free(c->shared_sigalgs);
3385     c->shared_sigalgs = NULL;
3386     c->shared_sigalgslen = 0;
3387     /* If client use client signature algorithms if not NULL */
3388     if (!s->server && c->client_sigalgs && !is_suiteb) {
3389         conf = c->client_sigalgs;
3390         conflen = c->client_sigalgslen;
3391     } else if (c->conf_sigalgs && !is_suiteb) {
3392         conf = c->conf_sigalgs;
3393         conflen = c->conf_sigalgslen;
3394     } else
3395         conflen = tls12_get_psigalgs(s, &conf);
3396     if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE || is_suiteb) {
3397         pref = conf;
3398         preflen = conflen;
3399         allow = s->s3->tmp.peer_sigalgs;
3400         allowlen = s->s3->tmp.peer_sigalgslen;
3401     } else {
3402         allow = conf;
3403         allowlen = conflen;
3404         pref = s->s3->tmp.peer_sigalgs;
3405         preflen = s->s3->tmp.peer_sigalgslen;
3406     }
3407     nmatch = tls12_shared_sigalgs(s, NULL, pref, preflen, allow, allowlen);
3408     if (nmatch) {
3409         salgs = OPENSSL_malloc(nmatch * sizeof(TLS_SIGALGS));
3410         if (salgs == NULL)
3411             return 0;
3412         nmatch = tls12_shared_sigalgs(s, salgs, pref, preflen, allow, allowlen);
3413     } else {
3414         salgs = NULL;
3415     }
3416     c->shared_sigalgs = salgs;
3417     c->shared_sigalgslen = nmatch;
3418     return 1;
3419 }
3420
3421 /* Set preferred digest for each key type */
3422
3423 int tls1_save_sigalgs(SSL *s, const unsigned char *data, int dsize)
3424 {
3425     CERT *c = s->cert;
3426     /* Extension ignored for inappropriate versions */
3427     if (!SSL_USE_SIGALGS(s))
3428         return 1;
3429     /* Should never happen */
3430     if (!c)
3431         return 0;
3432
3433     OPENSSL_free(s->s3->tmp.peer_sigalgs);
3434     s->s3->tmp.peer_sigalgs = OPENSSL_malloc(dsize);
3435     if (s->s3->tmp.peer_sigalgs == NULL)
3436         return 0;
3437     s->s3->tmp.peer_sigalgslen = dsize;
3438     memcpy(s->s3->tmp.peer_sigalgs, data, dsize);
3439     return 1;
3440 }
3441
3442 int tls1_process_sigalgs(SSL *s)
3443 {
3444     int idx;
3445     size_t i;
3446     const EVP_MD *md;
3447     const EVP_MD **pmd = s->s3->tmp.md;
3448     uint32_t *pvalid = s->s3->tmp.valid_flags;
3449     CERT *c = s->cert;
3450     TLS_SIGALGS *sigptr;
3451     if (!tls1_set_shared_sigalgs(s))
3452         return 0;
3453
3454 #ifdef OPENSSL_SSL_DEBUG_BROKEN_PROTOCOL
3455     if (s->cert->cert_flags & SSL_CERT_FLAG_BROKEN_PROTOCOL) {
3456         /*
3457          * Use first set signature preference to force message digest,
3458          * ignoring any peer preferences.
3459          */
3460         const unsigned char *sigs = NULL;
3461         if (s->server)
3462             sigs = c->conf_sigalgs;
3463         else
3464             sigs = c->client_sigalgs;
3465         if (sigs) {
3466             idx = tls12_get_pkey_idx(sigs[1]);
3467             md = tls12_get_hash(sigs[0]);
3468             pmd[idx] = md;
3469             pvalid[idx] = CERT_PKEY_EXPLICIT_SIGN;
3470             if (idx == SSL_PKEY_RSA_SIGN) {
3471                 pvalid[SSL_PKEY_RSA_ENC] = CERT_PKEY_EXPLICIT_SIGN;
3472                 pmd[SSL_PKEY_RSA_ENC] = md;
3473             }
3474         }
3475     }
3476 #endif
3477
3478     for (i = 0, sigptr = c->shared_sigalgs;
3479          i < c->shared_sigalgslen; i++, sigptr++) {
3480         idx = tls12_get_pkey_idx(sigptr->rsign);
3481         if (idx > 0 && pmd[idx] == NULL) {
3482             md = tls12_get_hash(sigptr->rhash);
3483             pmd[idx] = md;
3484             pvalid[idx] = CERT_PKEY_EXPLICIT_SIGN;
3485             if (idx == SSL_PKEY_RSA_SIGN) {
3486                 pvalid[SSL_PKEY_RSA_ENC] = CERT_PKEY_EXPLICIT_SIGN;
3487                 pmd[SSL_PKEY_RSA_ENC] = md;
3488             }
3489         }
3490
3491     }
3492     /*
3493      * In strict mode leave unset digests as NULL to indicate we can't use
3494      * the certificate for signing.
3495      */
3496     if (!(s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)) {
3497         /*
3498          * Set any remaining keys to default values. NOTE: if alg is not
3499          * supported it stays as NULL.
3500          */
3501 #ifndef OPENSSL_NO_DSA
3502         if (pmd[SSL_PKEY_DSA_SIGN] == NULL)
3503             pmd[SSL_PKEY_DSA_SIGN] = EVP_sha1();
3504 #endif
3505 #ifndef OPENSSL_NO_RSA
3506         if (pmd[SSL_PKEY_RSA_SIGN] == NULL) {
3507             pmd[SSL_PKEY_RSA_SIGN] = EVP_sha1();
3508             pmd[SSL_PKEY_RSA_ENC] = EVP_sha1();
3509         }
3510 #endif
3511 #ifndef OPENSSL_NO_EC
3512         if (pmd[SSL_PKEY_ECC] == NULL)
3513             pmd[SSL_PKEY_ECC] = EVP_sha1();
3514 #endif
3515 # ifndef OPENSSL_NO_GOST
3516         if (pmd[SSL_PKEY_GOST01] == NULL)
3517             pmd[SSL_PKEY_GOST01] = EVP_get_digestbynid(NID_id_GostR3411_94);
3518         if (pmd[SSL_PKEY_GOST12_256] == NULL)
3519             pmd[SSL_PKEY_GOST12_256] = EVP_get_digestbynid(NID_id_GostR3411_2012_256);
3520         if (pmd[SSL_PKEY_GOST12_512] == NULL)
3521             pmd[SSL_PKEY_GOST12_512] = EVP_get_digestbynid(NID_id_GostR3411_2012_512);
3522 # endif
3523     }
3524     return 1;
3525 }
3526
3527 int SSL_get_sigalgs(SSL *s, int idx,
3528                     int *psign, int *phash, int *psignhash,
3529                     unsigned char *rsig, unsigned char *rhash)
3530 {
3531     const unsigned char *psig = s->s3->tmp.peer_sigalgs;
3532     if (psig == NULL)
3533         return 0;
3534     if (idx >= 0) {
3535         idx <<= 1;
3536         if (idx >= (int)s->s3->tmp.peer_sigalgslen)
3537             return 0;
3538         psig += idx;
3539         if (rhash)
3540             *rhash = psig[0];
3541         if (rsig)
3542             *rsig = psig[1];
3543         tls1_lookup_sigalg(phash, psign, psignhash, psig);
3544     }
3545     return s->s3->tmp.peer_sigalgslen / 2;
3546 }
3547
3548 int SSL_get_shared_sigalgs(SSL *s, int idx,
3549                            int *psign, int *phash, int *psignhash,
3550                            unsigned char *rsig, unsigned char *rhash)
3551 {
3552     TLS_SIGALGS *shsigalgs = s->cert->shared_sigalgs;
3553     if (!shsigalgs || idx >= (int)s->cert->shared_sigalgslen)
3554         return 0;
3555     shsigalgs += idx;
3556     if (phash)
3557         *phash = shsigalgs->hash_nid;
3558     if (psign)
3559         *psign = shsigalgs->sign_nid;
3560     if (psignhash)
3561         *psignhash = shsigalgs->signandhash_nid;
3562     if (rsig)
3563         *rsig = shsigalgs->rsign;
3564     if (rhash)
3565         *rhash = shsigalgs->rhash;
3566     return s->cert->shared_sigalgslen;
3567 }
3568
3569 #define MAX_SIGALGLEN   (TLSEXT_hash_num * TLSEXT_signature_num * 2)
3570
3571 typedef struct {
3572     size_t sigalgcnt;
3573     int sigalgs[MAX_SIGALGLEN];
3574 } sig_cb_st;
3575
3576 static void get_sigorhash(int *psig, int *phash, const char *str)
3577 {
3578     if (strcmp(str, "RSA") == 0) {
3579         *psig = EVP_PKEY_RSA;
3580     } else if (strcmp(str, "DSA") == 0) {
3581         *psig = EVP_PKEY_DSA;
3582     } else if (strcmp(str, "ECDSA") == 0) {
3583         *psig = EVP_PKEY_EC;
3584     } else {
3585         *phash = OBJ_sn2nid(str);
3586         if (*phash == NID_undef)
3587             *phash = OBJ_ln2nid(str);
3588     }
3589 }
3590
3591 static int sig_cb(const char *elem, int len, void *arg)
3592 {
3593     sig_cb_st *sarg = arg;
3594     size_t i;
3595     char etmp[20], *p;
3596     int sig_alg = NID_undef, hash_alg = NID_undef;
3597     if (elem == NULL)
3598         return 0;
3599     if (sarg->sigalgcnt == MAX_SIGALGLEN)
3600         return 0;
3601     if (len > (int)(sizeof(etmp) - 1))
3602         return 0;
3603     memcpy(etmp, elem, len);
3604     etmp[len] = 0;
3605     p = strchr(etmp, '+');
3606     if (!p)
3607         return 0;
3608     *p = 0;
3609     p++;
3610     if (!*p)
3611         return 0;
3612
3613     get_sigorhash(&sig_alg, &hash_alg, etmp);
3614     get_sigorhash(&sig_alg, &hash_alg, p);
3615
3616     if (sig_alg == NID_undef || hash_alg == NID_undef)
3617         return 0;
3618
3619     for (i = 0; i < sarg->sigalgcnt; i += 2) {
3620         if (sarg->sigalgs[i] == sig_alg && sarg->sigalgs[i + 1] == hash_alg)
3621             return 0;
3622     }
3623     sarg->sigalgs[sarg->sigalgcnt++] = hash_alg;
3624     sarg->sigalgs[sarg->sigalgcnt++] = sig_alg;
3625     return 1;
3626 }
3627
3628 /*
3629  * Set suppored signature algorithms based on a colon separated list of the
3630  * form sig+hash e.g. RSA+SHA512:DSA+SHA512
3631  */
3632 int tls1_set_sigalgs_list(CERT *c, const char *str, int client)
3633 {
3634     sig_cb_st sig;
3635     sig.sigalgcnt = 0;
3636     if (!CONF_parse_list(str, ':', 1, sig_cb, &sig))
3637         return 0;
3638     if (c == NULL)
3639         return 1;
3640     return tls1_set_sigalgs(c, sig.sigalgs, sig.sigalgcnt, client);
3641 }
3642
3643 int tls1_set_sigalgs(CERT *c, const int *psig_nids, size_t salglen,
3644                      int client)
3645 {
3646     unsigned char *sigalgs, *sptr;
3647     int rhash, rsign;
3648     size_t i;
3649     if (salglen & 1)
3650         return 0;
3651     sigalgs = OPENSSL_malloc(salglen);
3652     if (sigalgs == NULL)
3653         return 0;
3654     for (i = 0, sptr = sigalgs; i < salglen; i += 2) {
3655         rhash = tls12_find_id(*psig_nids++, tls12_md, OSSL_NELEM(tls12_md));
3656         rsign = tls12_find_id(*psig_nids++, tls12_sig, OSSL_NELEM(tls12_sig));
3657
3658         if (rhash == -1 || rsign == -1)
3659             goto err;
3660         *sptr++ = rhash;
3661         *sptr++ = rsign;
3662     }
3663
3664     if (client) {
3665         OPENSSL_free(c->client_sigalgs);
3666         c->client_sigalgs = sigalgs;
3667         c->client_sigalgslen = salglen;
3668     } else {
3669         OPENSSL_free(c->conf_sigalgs);
3670         c->conf_sigalgs = sigalgs;
3671         c->conf_sigalgslen = salglen;
3672     }
3673
3674     return 1;
3675
3676  err:
3677     OPENSSL_free(sigalgs);
3678     return 0;
3679 }
3680
3681 static int tls1_check_sig_alg(CERT *c, X509 *x, int default_nid)
3682 {
3683     int sig_nid;
3684     size_t i;
3685     if (default_nid == -1)
3686         return 1;
3687     sig_nid = X509_get_signature_nid(x);
3688     if (default_nid)
3689         return sig_nid == default_nid ? 1 : 0;
3690     for (i = 0; i < c->shared_sigalgslen; i++)
3691         if (sig_nid == c->shared_sigalgs[i].signandhash_nid)
3692             return 1;