ssl/t1_lib.c

   1 /* ssl/t1_lib.c */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   5  * This package is an SSL implementation written
   6  * by Eric Young (eay@cryptsoft.com).
   7  * The implementation was written so as to conform with Netscapes SSL.
   8  *
   9  * This library is free for commercial and non-commercial use as long as
  10  * the following conditions are aheared to.  The following conditions
  11  * apply to all code found in this distribution, be it the RC4, RSA,
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13  * included with this distribution is covered by the same copyright terms
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15  *
  16  * Copyright remains Eric Young's, and as such any Copyright notices in
  17  * the code are not to be removed.
  18  * If this package is used in a product, Eric Young should be given attribution
  19  * as the author of the parts of the library used.
  20  * This can be in the form of a textual message at program startup or
  21  * in documentation (online or textual) provided with the package.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *    "This product includes cryptographic software written by
  34  *     Eric Young (eay@cryptsoft.com)"
  35  *    The word 'cryptographic' can be left out if the rouines from the library
  36  *    being used are not cryptographic related :-).
  37  * 4. If you include any Windows specific code (or a derivative thereof) from
  38  *    the apps directory (application code) you must include an acknowledgement:
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  *
  53  * The licence and distribution terms for any publically available version or
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55  * copied and put under another distribution licence
  56  * [including the GNU Public Licence.]
  57  */
  58 /* ====================================================================
  59  * Copyright (c) 1998-2007 The OpenSSL Project.  All rights reserved.
  60  *
  61  * Redistribution and use in source and binary forms, with or without
  62  * modification, are permitted provided that the following conditions
  63  * are met:
  64  *
  65  * 1. Redistributions of source code must retain the above copyright
  66  *    notice, this list of conditions and the following disclaimer.
  67  *
  68  * 2. Redistributions in binary form must reproduce the above copyright
  69  *    notice, this list of conditions and the following disclaimer in
  70  *    the documentation and/or other materials provided with the
  71  *    distribution.
  72  *
  73  * 3. All advertising materials mentioning features or use of this
  74  *    software must display the following acknowledgment:
  75  *    "This product includes software developed by the OpenSSL Project
  76  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  77  *
  78  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  79  *    endorse or promote products derived from this software without
  80  *    prior written permission. For written permission, please contact
  81  *    openssl-core@openssl.org.
  82  *
  83  * 5. Products derived from this software may not be called "OpenSSL"
  84  *    nor may "OpenSSL" appear in their names without prior written
  85  *    permission of the OpenSSL Project.
  86  *
  87  * 6. Redistributions of any form whatsoever must retain the following
  88  *    acknowledgment:
  89  *    "This product includes software developed by the OpenSSL Project
  90  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  91  *
  92  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  93  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  94  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  95  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  96  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  97  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  98  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  99  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 100  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 101  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 102  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 103  * OF THE POSSIBILITY OF SUCH DAMAGE.
 104  * ====================================================================
 105  *
 106  * This product includes cryptographic software written by Eric Young
 107  * (eay@cryptsoft.com).  This product includes software written by Tim
 108  * Hudson (tjh@cryptsoft.com).
 109  *
 110  */
 111
 112 #include <stdio.h>
 113 #include <openssl/objects.h>
 114 #include <openssl/evp.h>
 115 #include <openssl/hmac.h>
 116 #include <openssl/ocsp.h>
 117 #include <openssl/rand.h>
 118 #include "ssl_locl.h"
 119
 120 const char tls1_version_str[] = "TLSv1" OPENSSL_VERSION_PTEXT;
 121
 122 #ifndef OPENSSL_NO_TLSEXT
 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 #endif
 127
 128 SSL3_ENC_METHOD TLSv1_enc_data = {
 129     tls1_enc,
 130     tls1_mac,
 131     tls1_setup_key_block,
 132     tls1_generate_master_secret,
 133     tls1_change_cipher_state,
 134     tls1_final_finish_mac,
 135     TLS1_FINISH_MAC_LENGTH,
 136     tls1_cert_verify_mac,
 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 };
 142
 143 long tls1_default_timeout(void)
 144 {
 145     /*
 146      * 2 hours, the 24 hours mentioned in the TLSv1 spec is way too long for
 147      * http, the cache would over fill
 148      */
 149     return (60 * 60 * 2);
 150 }
 151
 152 int tls1_new(SSL *s)
 153 {
 154     if (!ssl3_new(s))
 155         return (0);
 156     s->method->ssl_clear(s);
 157     return (1);
 158 }
 159
 160 void tls1_free(SSL *s)
 161 {
 162 #ifndef OPENSSL_NO_TLSEXT
 163     if (s->tlsext_session_ticket) {
 164         OPENSSL_free(s->tlsext_session_ticket);
 165     }
 166 #endif                          /* OPENSSL_NO_TLSEXT */
 167     ssl3_free(s);
 168 }
 169
 170 void tls1_clear(SSL *s)
 171 {
 172     ssl3_clear(s);
 173     s->version = s->method->version;
 174 }
 175
 176 #ifndef OPENSSL_NO_EC
 177
 178 static int nid_list[] = {
 179     NID_sect163k1,              /* sect163k1 (1) */
 180     NID_sect163r1,              /* sect163r1 (2) */
 181     NID_sect163r2,              /* sect163r2 (3) */
 182     NID_sect193r1,              /* sect193r1 (4) */
 183     NID_sect193r2,              /* sect193r2 (5) */
 184     NID_sect233k1,              /* sect233k1 (6) */
 185     NID_sect233r1,              /* sect233r1 (7) */
 186     NID_sect239k1,              /* sect239k1 (8) */
 187     NID_sect283k1,              /* sect283k1 (9) */
 188     NID_sect283r1,              /* sect283r1 (10) */
 189     NID_sect409k1,              /* sect409k1 (11) */
 190     NID_sect409r1,              /* sect409r1 (12) */
 191     NID_sect571k1,              /* sect571k1 (13) */
 192     NID_sect571r1,              /* sect571r1 (14) */
 193     NID_secp160k1,              /* secp160k1 (15) */
 194     NID_secp160r1,              /* secp160r1 (16) */
 195     NID_secp160r2,              /* secp160r2 (17) */
 196     NID_secp192k1,              /* secp192k1 (18) */
 197     NID_X9_62_prime192v1,       /* secp192r1 (19) */
 198     NID_secp224k1,              /* secp224k1 (20) */
 199     NID_secp224r1,              /* secp224r1 (21) */
 200     NID_secp256k1,              /* secp256k1 (22) */
 201     NID_X9_62_prime256v1,       /* secp256r1 (23) */
 202     NID_secp384r1,              /* secp384r1 (24) */
 203     NID_secp521r1               /* secp521r1 (25) */
 204 };
 205
 206 static int pref_list[] = {
 207 # ifndef OPENSSL_NO_EC2M
 208     NID_sect571r1,              /* sect571r1 (14) */
 209     NID_sect571k1,              /* sect571k1 (13) */
 210 # endif
 211     NID_secp521r1,              /* secp521r1 (25) */
 212 # ifndef OPENSSL_NO_EC2M
 213     NID_sect409k1,              /* sect409k1 (11) */
 214     NID_sect409r1,              /* sect409r1 (12) */
 215 # endif
 216     NID_secp384r1,              /* secp384r1 (24) */
 217 # ifndef OPENSSL_NO_EC2M
 218     NID_sect283k1,              /* sect283k1 (9) */
 219     NID_sect283r1,              /* sect283r1 (10) */
 220 # endif
 221     NID_secp256k1,              /* secp256k1 (22) */
 222     NID_X9_62_prime256v1,       /* secp256r1 (23) */
 223 # ifndef OPENSSL_NO_EC2M
 224     NID_sect239k1,              /* sect239k1 (8) */
 225     NID_sect233k1,              /* sect233k1 (6) */
 226     NID_sect233r1,              /* sect233r1 (7) */
 227 # endif
 228     NID_secp224k1,              /* secp224k1 (20) */
 229     NID_secp224r1,              /* secp224r1 (21) */
 230 # ifndef OPENSSL_NO_EC2M
 231     NID_sect193r1,              /* sect193r1 (4) */
 232     NID_sect193r2,              /* sect193r2 (5) */
 233 # endif
 234     NID_secp192k1,              /* secp192k1 (18) */
 235     NID_X9_62_prime192v1,       /* secp192r1 (19) */
 236 # ifndef OPENSSL_NO_EC2M
 237     NID_sect163k1,              /* sect163k1 (1) */
 238     NID_sect163r1,              /* sect163r1 (2) */
 239     NID_sect163r2,              /* sect163r2 (3) */
 240 # endif
 241     NID_secp160k1,              /* secp160k1 (15) */
 242     NID_secp160r1,              /* secp160r1 (16) */
 243     NID_secp160r2,              /* secp160r2 (17) */
 244 };
 245
 246 int tls1_ec_curve_id2nid(int curve_id)
 247 {
 248     /* ECC curves from RFC 4492 */
 249     if ((curve_id < 1) || ((unsigned int)curve_id >
 250                            sizeof(nid_list) / sizeof(nid_list[0])))
 251         return 0;
 252     return nid_list[curve_id - 1];
 253 }
 254
 255 int tls1_ec_nid2curve_id(int nid)
 256 {
 257     /* ECC curves from RFC 4492 */
 258     switch (nid) {
 259     case NID_sect163k1:        /* sect163k1 (1) */
 260         return 1;
 261     case NID_sect163r1:        /* sect163r1 (2) */
 262         return 2;
 263     case NID_sect163r2:        /* sect163r2 (3) */
 264         return 3;
 265     case NID_sect193r1:        /* sect193r1 (4) */
 266         return 4;
 267     case NID_sect193r2:        /* sect193r2 (5) */
 268         return 5;
 269     case NID_sect233k1:        /* sect233k1 (6) */
 270         return 6;
 271     case NID_sect233r1:        /* sect233r1 (7) */
 272         return 7;
 273     case NID_sect239k1:        /* sect239k1 (8) */
 274         return 8;
 275     case NID_sect283k1:        /* sect283k1 (9) */
 276         return 9;
 277     case NID_sect283r1:        /* sect283r1 (10) */
 278         return 10;
 279     case NID_sect409k1:        /* sect409k1 (11) */
 280         return 11;
 281     case NID_sect409r1:        /* sect409r1 (12) */
 282         return 12;
 283     case NID_sect571k1:        /* sect571k1 (13) */
 284         return 13;
 285     case NID_sect571r1:        /* sect571r1 (14) */
 286         return 14;
 287     case NID_secp160k1:        /* secp160k1 (15) */
 288         return 15;
 289     case NID_secp160r1:        /* secp160r1 (16) */
 290         return 16;
 291     case NID_secp160r2:        /* secp160r2 (17) */
 292         return 17;
 293     case NID_secp192k1:        /* secp192k1 (18) */
 294         return 18;
 295     case NID_X9_62_prime192v1: /* secp192r1 (19) */
 296         return 19;
 297     case NID_secp224k1:        /* secp224k1 (20) */
 298         return 20;
 299     case NID_secp224r1:        /* secp224r1 (21) */
 300         return 21;
 301     case NID_secp256k1:        /* secp256k1 (22) */
 302         return 22;
 303     case NID_X9_62_prime256v1: /* secp256r1 (23) */
 304         return 23;
 305     case NID_secp384r1:        /* secp384r1 (24) */
 306         return 24;
 307     case NID_secp521r1:        /* secp521r1 (25) */
 308         return 25;
 309     default:
 310         return 0;
 311     }
 312 }
 313 #endif                          /* OPENSSL_NO_EC */
 314
 315 #ifndef OPENSSL_NO_TLSEXT
 316
 317 /*
 318  * List of supported signature algorithms and hashes. Should make this
 319  * customisable at some point, for now include everything we support.
 320  */
 321
 322 # ifdef OPENSSL_NO_RSA
 323 #  define tlsext_sigalg_rsa(md) /* */
 324 # else
 325 #  define tlsext_sigalg_rsa(md) md, TLSEXT_signature_rsa,
 326 # endif
 327
 328 # ifdef OPENSSL_NO_DSA
 329 #  define tlsext_sigalg_dsa(md) /* */
 330 # else
 331 #  define tlsext_sigalg_dsa(md) md, TLSEXT_signature_dsa,
 332 # endif
 333
 334 # ifdef OPENSSL_NO_ECDSA
 335 #  define tlsext_sigalg_ecdsa(md)
 336                                 /* */
 337 # else
 338 #  define tlsext_sigalg_ecdsa(md) md, TLSEXT_signature_ecdsa,
 339 # endif
 340
 341 # define tlsext_sigalg(md) \
 342                 tlsext_sigalg_rsa(md) \
 343                 tlsext_sigalg_dsa(md) \
 344                 tlsext_sigalg_ecdsa(md)
 345
 346 static unsigned char tls12_sigalgs[] = {
 347 # ifndef OPENSSL_NO_SHA512
 348     tlsext_sigalg(TLSEXT_hash_sha512)
 349         tlsext_sigalg(TLSEXT_hash_sha384)
 350 # endif
 351 # ifndef OPENSSL_NO_SHA256
 352         tlsext_sigalg(TLSEXT_hash_sha256)
 353         tlsext_sigalg(TLSEXT_hash_sha224)
 354 # endif
 355 # ifndef OPENSSL_NO_SHA
 356         tlsext_sigalg(TLSEXT_hash_sha1)
 357 # endif
 358 };
 359
 360 int tls12_get_req_sig_algs(SSL *s, unsigned char *p)
 361 {
 362     size_t slen = sizeof(tls12_sigalgs);
 363     if (p)
 364         memcpy(p, tls12_sigalgs, slen);
 365     return (int)slen;
 366 }
 367
 368 unsigned char *ssl_add_clienthello_tlsext(SSL *s, unsigned char *buf,
 369                                           unsigned char *limit)
 370 {
 371     int extdatalen = 0;
 372     unsigned char *orig = buf;
 373     unsigned char *ret = buf;
 374
 375     /* don't add extensions for SSLv3 unless doing secure renegotiation */
 376     if (s->client_version == SSL3_VERSION && !s->s3->send_connection_binding)
 377         return orig;
 378
 379     ret += 2;
 380
 381     if (ret >= limit)
 382         return NULL;            /* this really never occurs, but ... */
 383
 384     if (s->tlsext_hostname != NULL) {
 385         /* Add TLS extension servername to the Client Hello message */
 386         unsigned long size_str;
 387         long lenmax;
 388
 389         /*-
 390          * check for enough space.
 391          * 4 for the servername type and entension length
 392          * 2 for servernamelist length
 393          * 1 for the hostname type
 394          * 2 for hostname length
 395          * + hostname length
 396          */
 397
 398         if ((lenmax = limit - ret - 9) < 0
 399             || (size_str =
 400                 strlen(s->tlsext_hostname)) > (unsigned long)lenmax)
 401             return NULL;
 402
 403         /* extension type and length */
 404         s2n(TLSEXT_TYPE_server_name, ret);
 405         s2n(size_str + 5, ret);
 406
 407         /* length of servername list */
 408         s2n(size_str + 3, ret);
 409
 410         /* hostname type, length and hostname */
 411         *(ret++) = (unsigned char)TLSEXT_NAMETYPE_host_name;
 412         s2n(size_str, ret);
 413         memcpy(ret, s->tlsext_hostname, size_str);
 414         ret += size_str;
 415     }
 416
 417     /* Add RI if renegotiating */
 418     if (s->renegotiate) {
 419         int el;
 420
 421         if (!ssl_add_clienthello_renegotiate_ext(s, 0, &el, 0)) {
 422             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
 423             return NULL;
 424         }
 425
 426         if ((limit - ret - 4 - el) < 0)
 427             return NULL;
 428
 429         s2n(TLSEXT_TYPE_renegotiate, ret);
 430         s2n(el, ret);
 431
 432         if (!ssl_add_clienthello_renegotiate_ext(s, ret, &el, el)) {
 433             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
 434             return NULL;
 435         }
 436
 437         ret += el;
 438     }
 439 # ifndef OPENSSL_NO_SRP
 440     /* Add SRP username if there is one */
 441     if (s->srp_ctx.login != NULL) { /* Add TLS extension SRP username to the
 442                                      * Client Hello message */
 443
 444         int login_len = strlen(s->srp_ctx.login);
 445         if (login_len > 255 || login_len == 0) {
 446             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
 447             return NULL;
 448         }
 449
 450         /*-
 451          * check for enough space.
 452          * 4 for the srp type type and entension length
 453          * 1 for the srp user identity
 454          * + srp user identity length
 455          */
 456         if ((limit - ret - 5 - login_len) < 0)
 457             return NULL;
 458
 459         /* fill in the extension */
 460         s2n(TLSEXT_TYPE_srp, ret);
 461         s2n(login_len + 1, ret);
 462         (*ret++) = (unsigned char)login_len;
 463         memcpy(ret, s->srp_ctx.login, login_len);
 464         ret += login_len;
 465     }
 466 # endif
 467
 468 # ifndef OPENSSL_NO_EC
 469     if (s->tlsext_ecpointformatlist != NULL) {
 470         /*
 471          * Add TLS extension ECPointFormats to the ClientHello message
 472          */
 473         long lenmax;
 474
 475         if ((lenmax = limit - ret - 5) < 0)
 476             return NULL;
 477         if (s->tlsext_ecpointformatlist_length > (unsigned long)lenmax)
 478             return NULL;
 479         if (s->tlsext_ecpointformatlist_length > 255) {
 480             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
 481             return NULL;
 482         }
 483
 484         s2n(TLSEXT_TYPE_ec_point_formats, ret);
 485         s2n(s->tlsext_ecpointformatlist_length + 1, ret);
 486         *(ret++) = (unsigned char)s->tlsext_ecpointformatlist_length;
 487         memcpy(ret, s->tlsext_ecpointformatlist,
 488                s->tlsext_ecpointformatlist_length);
 489         ret += s->tlsext_ecpointformatlist_length;
 490     }
 491     if (s->tlsext_ellipticcurvelist != NULL) {
 492         /*
 493          * Add TLS extension EllipticCurves to the ClientHello message
 494          */
 495         long lenmax;
 496
 497         if ((lenmax = limit - ret - 6) < 0)
 498             return NULL;
 499         if (s->tlsext_ellipticcurvelist_length > (unsigned long)lenmax)
 500             return NULL;
 501         if (s->tlsext_ellipticcurvelist_length > 65532) {
 502             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
 503             return NULL;
 504         }
 505
 506         s2n(TLSEXT_TYPE_elliptic_curves, ret);
 507         s2n(s->tlsext_ellipticcurvelist_length + 2, ret);
 508
 509         s2n(s->tlsext_ellipticcurvelist_length, ret);
 510         memcpy(ret, s->tlsext_ellipticcurvelist,
 511                s->tlsext_ellipticcurvelist_length);
 512         ret += s->tlsext_ellipticcurvelist_length;
 513     }
 514 # endif                         /* OPENSSL_NO_EC */
 515
 516     if (!(SSL_get_options(s) & SSL_OP_NO_TICKET)) {
 517         int ticklen;
 518         if (!s->new_session && s->session && s->session->tlsext_tick)
 519             ticklen = s->session->tlsext_ticklen;
 520         else if (s->session && s->tlsext_session_ticket &&
 521                  s->tlsext_session_ticket->data) {
 522             ticklen = s->tlsext_session_ticket->length;
 523             s->session->tlsext_tick = OPENSSL_malloc(ticklen);
 524             if (!s->session->tlsext_tick)
 525                 return NULL;
 526             memcpy(s->session->tlsext_tick,
 527                    s->tlsext_session_ticket->data, ticklen);
 528             s->session->tlsext_ticklen = ticklen;
 529         } else
 530             ticklen = 0;
 531         if (ticklen == 0 && s->tlsext_session_ticket &&
 532             s->tlsext_session_ticket->data == NULL)
 533             goto skip_ext;
 534         /*
 535          * Check for enough room 2 for extension type, 2 for len rest for
 536          * ticket
 537          */
 538         if ((long)(limit - ret - 4 - ticklen) < 0)
 539             return NULL;
 540         s2n(TLSEXT_TYPE_session_ticket, ret);
 541         s2n(ticklen, ret);
 542         if (ticklen) {
 543             memcpy(ret, s->session->tlsext_tick, ticklen);
 544             ret += ticklen;
 545         }
 546     }
 547  skip_ext:
 548
 549     if (TLS1_get_client_version(s) >= TLS1_2_VERSION) {
 550         if ((size_t)(limit - ret) < sizeof(tls12_sigalgs) + 6)
 551             return NULL;
 552         s2n(TLSEXT_TYPE_signature_algorithms, ret);
 553         s2n(sizeof(tls12_sigalgs) + 2, ret);
 554         s2n(sizeof(tls12_sigalgs), ret);
 555         memcpy(ret, tls12_sigalgs, sizeof(tls12_sigalgs));
 556         ret += sizeof(tls12_sigalgs);
 557     }
 558 # ifdef TLSEXT_TYPE_opaque_prf_input
 559     if (s->s3->client_opaque_prf_input != NULL && s->version != DTLS1_VERSION) {
 560         size_t col = s->s3->client_opaque_prf_input_len;
 561
 562         if ((long)(limit - ret - 6 - col < 0))
 563             return NULL;
 564         if (col > 0xFFFD)       /* can't happen */
 565             return NULL;
 566
 567         s2n(TLSEXT_TYPE_opaque_prf_input, ret);
 568         s2n(col + 2, ret);
 569         s2n(col, ret);
 570         memcpy(ret, s->s3->client_opaque_prf_input, col);
 571         ret += col;
 572     }
 573 # endif
 574
 575     if (s->tlsext_status_type == TLSEXT_STATUSTYPE_ocsp &&
 576         s->version != DTLS1_VERSION) {
 577         int i;
 578         long extlen, idlen, itmp;
 579         OCSP_RESPID *id;
 580
 581         idlen = 0;
 582         for (i = 0; i < sk_OCSP_RESPID_num(s->tlsext_ocsp_ids); i++) {
 583             id = sk_OCSP_RESPID_value(s->tlsext_ocsp_ids, i);
 584             itmp = i2d_OCSP_RESPID(id, NULL);
 585             if (itmp <= 0)
 586                 return NULL;
 587             idlen += itmp + 2;
 588         }
 589
 590         if (s->tlsext_ocsp_exts) {
 591             extlen = i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts, NULL);
 592             if (extlen < 0)
 593                 return NULL;
 594         } else
 595             extlen = 0;
 596
 597         if ((long)(limit - ret - 7 - extlen - idlen) < 0)
 598             return NULL;
 599         s2n(TLSEXT_TYPE_status_request, ret);
 600         if (extlen + idlen > 0xFFF0)
 601             return NULL;
 602         s2n(extlen + idlen + 5, ret);
 603         *(ret++) = TLSEXT_STATUSTYPE_ocsp;
 604         s2n(idlen, ret);
 605         for (i = 0; i < sk_OCSP_RESPID_num(s->tlsext_ocsp_ids); i++) {
 606             /* save position of id len */
 607             unsigned char *q = ret;
 608             id = sk_OCSP_RESPID_value(s->tlsext_ocsp_ids, i);
 609             /* skip over id len */
 610             ret += 2;
 611             itmp = i2d_OCSP_RESPID(id, &ret);
 612             /* write id len */
 613             s2n(itmp, q);
 614         }
 615         s2n(extlen, ret);
 616         if (extlen > 0)
 617             i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts, &ret);
 618     }
 619 # ifndef OPENSSL_NO_HEARTBEATS
 620     /* Add Heartbeat extension */
 621     if ((limit - ret - 4 - 1) < 0)
 622         return NULL;
 623     s2n(TLSEXT_TYPE_heartbeat, ret);
 624     s2n(1, ret);
 625     /*-
 626      * Set mode:
 627      * 1: peer may send requests
 628      * 2: peer not allowed to send requests
 629      */
 630     if (s->tlsext_heartbeat & SSL_TLSEXT_HB_DONT_RECV_REQUESTS)
 631         *(ret++) = SSL_TLSEXT_HB_DONT_SEND_REQUESTS;
 632     else
 633         *(ret++) = SSL_TLSEXT_HB_ENABLED;
 634 # endif
 635
 636 # ifndef OPENSSL_NO_NEXTPROTONEG
 637     if (s->ctx->next_proto_select_cb && !s->s3->tmp.finish_md_len) {
 638         /*
 639          * The client advertises an emtpy extension to indicate its support
 640          * for Next Protocol Negotiation
 641          */
 642         if (limit - ret - 4 < 0)
 643             return NULL;
 644         s2n(TLSEXT_TYPE_next_proto_neg, ret);
 645         s2n(0, ret);
 646     }
 647 # endif
 648
 649 # ifndef OPENSSL_NO_SRTP
 650     if (SSL_IS_DTLS(s) && SSL_get_srtp_profiles(s)) {
 651         int el;
 652
 653         ssl_add_clienthello_use_srtp_ext(s, 0, &el, 0);
 654
 655         if ((limit - ret - 4 - el) < 0)
 656             return NULL;
 657
 658         s2n(TLSEXT_TYPE_use_srtp, ret);
 659         s2n(el, ret);
 660
 661         if (ssl_add_clienthello_use_srtp_ext(s, ret, &el, el)) {
 662             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
 663             return NULL;
 664         }
 665         ret += el;
 666     }
 667 # endif
 668     /*
 669      * Add padding to workaround bugs in F5 terminators. See
 670      * https://tools.ietf.org/html/draft-agl-tls-padding-03 NB: because this
 671      * code works out the length of all existing extensions it MUST always
 672      * appear last.
 673      */
 674     if (s->options & SSL_OP_TLSEXT_PADDING) {
 675         int hlen = ret - (unsigned char *)s->init_buf->data;
 676         /*
 677          * The code in s23_clnt.c to build ClientHello messages includes the
 678          * 5-byte record header in the buffer, while the code in s3_clnt.c
 679          * does not.
 680          */
 681         if (s->state == SSL23_ST_CW_CLNT_HELLO_A)
 682             hlen -= 5;
 683         if (hlen > 0xff && hlen < 0x200) {
 684             hlen = 0x200 - hlen;
 685             if (hlen >= 4)
 686                 hlen -= 4;
 687             else
 688                 hlen = 0;
 689
 690             s2n(TLSEXT_TYPE_padding, ret);
 691             s2n(hlen, ret);
 692             memset(ret, 0, hlen);
 693             ret += hlen;
 694         }
 695     }
 696
 697     if ((extdatalen = ret - orig - 2) == 0)
 698         return orig;
 699
 700     s2n(extdatalen, orig);
 701     return ret;
 702 }
 703
 704 unsigned char *ssl_add_serverhello_tlsext(SSL *s, unsigned char *buf,
 705                                           unsigned char *limit)
 706 {
 707     int extdatalen = 0;
 708     unsigned char *orig = buf;
 709     unsigned char *ret = buf;
 710 # ifndef OPENSSL_NO_NEXTPROTONEG
 711     int next_proto_neg_seen;
 712 # endif
 713
 714     /*
 715      * don't add extensions for SSLv3, unless doing secure renegotiation
 716      */
 717     if (s->version == SSL3_VERSION && !s->s3->send_connection_binding)
 718         return orig;
 719
 720     ret += 2;
 721     if (ret >= limit)
 722         return NULL;            /* this really never occurs, but ... */
 723
 724     if (!s->hit && s->servername_done == 1
 725         && s->session->tlsext_hostname != NULL) {
 726         if ((long)(limit - ret - 4) < 0)
 727             return NULL;
 728
 729         s2n(TLSEXT_TYPE_server_name, ret);
 730         s2n(0, ret);
 731     }
 732
 733     if (s->s3->send_connection_binding) {
 734         int el;
 735
 736         if (!ssl_add_serverhello_renegotiate_ext(s, 0, &el, 0)) {
 737             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
 738             return NULL;
 739         }
 740
 741         if ((limit - ret - 4 - el) < 0)
 742             return NULL;
 743
 744         s2n(TLSEXT_TYPE_renegotiate, ret);
 745         s2n(el, ret);
 746
 747         if (!ssl_add_serverhello_renegotiate_ext(s, ret, &el, el)) {
 748             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
 749             return NULL;
 750         }
 751
 752         ret += el;
 753     }
 754 # ifndef OPENSSL_NO_EC
 755     if (s->tlsext_ecpointformatlist != NULL) {
 756         /*
 757          * Add TLS extension ECPointFormats to the ServerHello message
 758          */
 759         long lenmax;
 760
 761         if ((lenmax = limit - ret - 5) < 0)
 762             return NULL;
 763         if (s->tlsext_ecpointformatlist_length > (unsigned long)lenmax)
 764             return NULL;
 765         if (s->tlsext_ecpointformatlist_length > 255) {
 766             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
 767             return NULL;
 768         }
 769
 770         s2n(TLSEXT_TYPE_ec_point_formats, ret);
 771         s2n(s->tlsext_ecpointformatlist_length + 1, ret);
 772         *(ret++) = (unsigned char)s->tlsext_ecpointformatlist_length;
 773         memcpy(ret, s->tlsext_ecpointformatlist,
 774                s->tlsext_ecpointformatlist_length);
 775         ret += s->tlsext_ecpointformatlist_length;
 776
 777     }
 778     /*
 779      * Currently the server should not respond with a SupportedCurves
 780      * extension
 781      */
 782 # endif                         /* OPENSSL_NO_EC */
 783
 784     if (s->tlsext_ticket_expected && !(SSL_get_options(s) & SSL_OP_NO_TICKET)) {
 785         if ((long)(limit - ret - 4) < 0)
 786             return NULL;
 787         s2n(TLSEXT_TYPE_session_ticket, ret);
 788         s2n(0, ret);
 789     }
 790
 791     if (s->tlsext_status_expected) {
 792         if ((long)(limit - ret - 4) < 0)
 793             return NULL;
 794         s2n(TLSEXT_TYPE_status_request, ret);
 795         s2n(0, ret);
 796     }
 797 # ifdef TLSEXT_TYPE_opaque_prf_input
 798     if (s->s3->server_opaque_prf_input != NULL && s->version != DTLS1_VERSION) {
 799         size_t sol = s->s3->server_opaque_prf_input_len;
 800
 801         if ((long)(limit - ret - 6 - sol) < 0)
 802             return NULL;
 803         if (sol > 0xFFFD)       /* can't happen */
 804             return NULL;
 805
 806         s2n(TLSEXT_TYPE_opaque_prf_input, ret);
 807         s2n(sol + 2, ret);
 808         s2n(sol, ret);
 809         memcpy(ret, s->s3->server_opaque_prf_input, sol);
 810         ret += sol;
 811     }
 812 # endif
 813
 814 # ifndef OPENSSL_NO_SRTP
 815     if (SSL_IS_DTLS(s) && s->srtp_profile) {
 816         int el;
 817
 818         ssl_add_serverhello_use_srtp_ext(s, 0, &el, 0);
 819
 820         if ((limit - ret - 4 - el) < 0)
 821             return NULL;
 822
 823         s2n(TLSEXT_TYPE_use_srtp, ret);
 824         s2n(el, ret);
 825
 826         if (ssl_add_serverhello_use_srtp_ext(s, ret, &el, el)) {
 827             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
 828             return NULL;
 829         }
 830         ret += el;
 831     }
 832 # endif
 833
 834     if (((s->s3->tmp.new_cipher->id & 0xFFFF) == 0x80
 835          || (s->s3->tmp.new_cipher->id & 0xFFFF) == 0x81)
 836         && (SSL_get_options(s) & SSL_OP_CRYPTOPRO_TLSEXT_BUG)) {
 837         const unsigned char cryptopro_ext[36] = {
 838             0xfd, 0xe8,         /* 65000 */
 839             0x00, 0x20,         /* 32 bytes length */
 840             0x30, 0x1e, 0x30, 0x08, 0x06, 0x06, 0x2a, 0x85,
 841             0x03, 0x02, 0x02, 0x09, 0x30, 0x08, 0x06, 0x06,
 842             0x2a, 0x85, 0x03, 0x02, 0x02, 0x16, 0x30, 0x08,
 843             0x06, 0x06, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x17
 844         };
 845         if (limit - ret < 36)
 846             return NULL;
 847         memcpy(ret, cryptopro_ext, 36);
 848         ret += 36;
 849
 850     }
 851 # ifndef OPENSSL_NO_HEARTBEATS
 852     /* Add Heartbeat extension if we've received one */
 853     if (s->tlsext_heartbeat & SSL_TLSEXT_HB_ENABLED) {
 854         if ((limit - ret - 4 - 1) < 0)
 855             return NULL;
 856         s2n(TLSEXT_TYPE_heartbeat, ret);
 857         s2n(1, ret);
 858         /*-
 859          * Set mode:
 860          * 1: peer may send requests
 861          * 2: peer not allowed to send requests
 862          */
 863         if (s->tlsext_heartbeat & SSL_TLSEXT_HB_DONT_RECV_REQUESTS)
 864             *(ret++) = SSL_TLSEXT_HB_DONT_SEND_REQUESTS;
 865         else
 866             *(ret++) = SSL_TLSEXT_HB_ENABLED;
 867
 868     }
 869 # endif
 870
 871 # ifndef OPENSSL_NO_NEXTPROTONEG
 872     next_proto_neg_seen = s->s3->next_proto_neg_seen;
 873     s->s3->next_proto_neg_seen = 0;
 874     if (next_proto_neg_seen && s->ctx->next_protos_advertised_cb) {
 875         const unsigned char *npa;
 876         unsigned int npalen;
 877         int r;
 878
 879         r = s->ctx->next_protos_advertised_cb(s, &npa, &npalen,
 880                                               s->
 881                                               ctx->next_protos_advertised_cb_arg);
 882         if (r == SSL_TLSEXT_ERR_OK) {
 883             if ((long)(limit - ret - 4 - npalen) < 0)
 884                 return NULL;
 885             s2n(TLSEXT_TYPE_next_proto_neg, ret);
 886             s2n(npalen, ret);
 887             memcpy(ret, npa, npalen);
 888             ret += npalen;
 889             s->s3->next_proto_neg_seen = 1;
 890         }
 891     }
 892 # endif
 893
 894     if ((extdatalen = ret - orig - 2) == 0)
 895         return orig;
 896
 897     s2n(extdatalen, orig);
 898     return ret;
 899 }
 900
 901 # ifndef OPENSSL_NO_EC
 902 /*-
 903  * ssl_check_for_safari attempts to fingerprint Safari using OS X
 904  * SecureTransport using the TLS extension block in |d|, of length |n|.
 905  * Safari, since 10.6, sends exactly these extensions, in this order:
 906  *   SNI,
 907  *   elliptic_curves
 908  *   ec_point_formats
 909  *
 910  * We wish to fingerprint Safari because they broke ECDHE-ECDSA support in 10.8,
 911  * but they advertise support. So enabling ECDHE-ECDSA ciphers breaks them.
 912  * Sadly we cannot differentiate 10.6, 10.7 and 10.8.4 (which work), from
 913  * 10.8..10.8.3 (which don't work).
 914  */
 915 static void ssl_check_for_safari(SSL *s, const unsigned char *data,
 916                                  const unsigned char *d, int n)
 917 {
 918     unsigned short type, size;
 919     static const unsigned char kSafariExtensionsBlock[] = {
 920         0x00, 0x0a,             /* elliptic_curves extension */
 921         0x00, 0x08,             /* 8 bytes */
 922         0x00, 0x06,             /* 6 bytes of curve ids */
 923         0x00, 0x17,             /* P-256 */
 924         0x00, 0x18,             /* P-384 */
 925         0x00, 0x19,             /* P-521 */
 926
 927         0x00, 0x0b,             /* ec_point_formats */
 928         0x00, 0x02,             /* 2 bytes */
 929         0x01,                   /* 1 point format */
 930         0x00,                   /* uncompressed */
 931     };
 932
 933     /* The following is only present in TLS 1.2 */
 934     static const unsigned char kSafariTLS12ExtensionsBlock[] = {
 935         0x00, 0x0d,             /* signature_algorithms */
 936         0x00, 0x0c,             /* 12 bytes */
 937         0x00, 0x0a,             /* 10 bytes */
 938         0x05, 0x01,             /* SHA-384/RSA */
 939         0x04, 0x01,             /* SHA-256/RSA */
 940         0x02, 0x01,             /* SHA-1/RSA */
 941         0x04, 0x03,             /* SHA-256/ECDSA */
 942         0x02, 0x03,             /* SHA-1/ECDSA */
 943     };
 944
 945     if (data >= (d + n - 2))
 946         return;
 947     data += 2;
 948
 949     if (data > (d + n - 4))
 950         return;
 951     n2s(data, type);
 952     n2s(data, size);
 953
 954     if (type != TLSEXT_TYPE_server_name)
 955         return;
 956
 957     if (data + size > d + n)
 958         return;
 959     data += size;
 960
 961     if (TLS1_get_client_version(s) >= TLS1_2_VERSION) {
 962         const size_t len1 = sizeof(kSafariExtensionsBlock);
 963         const size_t len2 = sizeof(kSafariTLS12ExtensionsBlock);
 964
 965         if (data + len1 + len2 != d + n)
 966             return;
 967         if (memcmp(data, kSafariExtensionsBlock, len1) != 0)
 968             return;
 969         if (memcmp(data + len1, kSafariTLS12ExtensionsBlock, len2) != 0)
 970             return;
 971     } else {
 972         const size_t len = sizeof(kSafariExtensionsBlock);
 973
 974         if (data + len != d + n)
 975             return;
 976         if (memcmp(data, kSafariExtensionsBlock, len) != 0)
 977             return;
 978     }
 979
 980     s->s3->is_probably_safari = 1;
 981 }
 982 # endif                         /* !OPENSSL_NO_EC */
 983
 984 int ssl_parse_clienthello_tlsext(SSL *s, unsigned char **p, unsigned char *d,
 985                                  int n, int *al)
 986 {
 987     unsigned short type;
 988     unsigned short size;
 989     unsigned short len;
 990     unsigned char *data = *p;
 991     int renegotiate_seen = 0;
 992     int sigalg_seen = 0;
 993
 994     s->servername_done = 0;
 995     s->tlsext_status_type = -1;
 996 # ifndef OPENSSL_NO_NEXTPROTONEG
 997     s->s3->next_proto_neg_seen = 0;
 998 # endif
 999
1000 # ifndef OPENSSL_NO_HEARTBEATS
1001     s->tlsext_heartbeat &= ~(SSL_TLSEXT_HB_ENABLED |
1002                              SSL_TLSEXT_HB_DONT_SEND_REQUESTS);
1003 # endif
1004
1005 # ifndef OPENSSL_NO_EC
1006     if (s->options & SSL_OP_SAFARI_ECDHE_ECDSA_BUG)
1007         ssl_check_for_safari(s, data, d, n);
1008 # endif                         /* !OPENSSL_NO_EC */
1009
1010 # ifndef OPENSSL_NO_SRP
1011     if (s->srp_ctx.login != NULL) {
1012         OPENSSL_free(s->srp_ctx.login);
1013         s->srp_ctx.login = NULL;
1014     }
1015 # endif
1016
1017     s->srtp_profile = NULL;
1018
1019     if (data >= (d + n - 2))
1020         goto ri_check;
1021     n2s(data, len);
1022
1023     if (data > (d + n - len))
1024         goto ri_check;
1025
1026     while (data <= (d + n - 4)) {
1027         n2s(data, type);
1028         n2s(data, size);
1029
1030         if (data + size > (d + n))
1031             goto ri_check;
1032 # if 0
1033         fprintf(stderr, "Received extension type %d size %d\n", type, size);
1034 # endif
1035         if (s->tlsext_debug_cb)
1036             s->tlsext_debug_cb(s, 0, type, data, size, s->tlsext_debug_arg);
1037 /*-
1038  * The servername extension is treated as follows:
1039  *
1040  * - Only the hostname type is supported with a maximum length of 255.
1041  * - The servername is rejected if too long or if it contains zeros,
1042  *   in which case an fatal alert is generated.
1043  * - The servername field is maintained together with the session cache.
1044  * - When a session is resumed, the servername call back invoked in order
1045  *   to allow the application to position itself to the right context.
1046  * - The servername is acknowledged if it is new for a session or when
1047  *   it is identical to a previously used for the same session.
1048  *   Applications can control the behaviour.  They can at any time
1049  *   set a 'desirable' servername for a new SSL object. This can be the
1050  *   case for example with HTTPS when a Host: header field is received and
1051  *   a renegotiation is requested. In this case, a possible servername
1052  *   presented in the new client hello is only acknowledged if it matches
1053  *   the value of the Host: field.
1054  * - Applications must  use SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
1055  *   if they provide for changing an explicit servername context for the
1056  *   session, i.e. when the session has been established with a servername
1057  *   extension.
1058  * - On session reconnect, the servername extension may be absent.
1059  *
1060  */
1061
1062         if (type == TLSEXT_TYPE_server_name) {
1063             unsigned char *sdata;
1064             int servname_type;
1065             int dsize;
1066
1067             if (size < 2) {
1068                 *al = SSL_AD_DECODE_ERROR;
1069                 return 0;
1070             }
1071             n2s(data, dsize);
1072             size -= 2;
1073             if (dsize > size) {
1074                 *al = SSL_AD_DECODE_ERROR;
1075                 return 0;
1076             }
1077
1078             sdata = data;
1079             while (dsize > 3) {
1080                 servname_type = *(sdata++);
1081                 n2s(sdata, len);
1082                 dsize -= 3;
1083
1084                 if (len > dsize) {
1085                     *al = SSL_AD_DECODE_ERROR;
1086                     return 0;
1087                 }
1088                 if (s->servername_done == 0)
1089                     switch (servname_type) {
1090                     case TLSEXT_NAMETYPE_host_name:
1091                         if (!s->hit) {
1092                             if (s->session->tlsext_hostname) {
1093                                 *al = SSL_AD_DECODE_ERROR;
1094                                 return 0;
1095                             }
1096                             if (len > TLSEXT_MAXLEN_host_name) {
1097                                 *al = TLS1_AD_UNRECOGNIZED_NAME;
1098                                 return 0;
1099                             }
1100                             if ((s->session->tlsext_hostname =
1101                                  OPENSSL_malloc(len + 1)) == NULL) {
1102                                 *al = TLS1_AD_INTERNAL_ERROR;
1103                                 return 0;
1104                             }
1105                             memcpy(s->session->tlsext_hostname, sdata, len);
1106                             s->session->tlsext_hostname[len] = '\0';
1107                             if (strlen(s->session->tlsext_hostname) != len) {
1108                                 OPENSSL_free(s->session->tlsext_hostname);
1109                                 s->session->tlsext_hostname = NULL;
1110                                 *al = TLS1_AD_UNRECOGNIZED_NAME;
1111                                 return 0;
1112                             }
1113                             s->servername_done = 1;
1114
1115                         } else
1116                             s->servername_done = s->session->tlsext_hostname
1117                                 && strlen(s->session->tlsext_hostname) == len
1118                                 && strncmp(s->session->tlsext_hostname,
1119                                            (char *)sdata, len) == 0;
1120
1121                         break;
1122
1123                     default:
1124                         break;
1125                     }
1126
1127                 dsize -= len;
1128             }
1129             if (dsize != 0) {
1130                 *al = SSL_AD_DECODE_ERROR;
1131                 return 0;
1132             }
1133
1134         }
1135 # ifndef OPENSSL_NO_SRP
1136         else if (type == TLSEXT_TYPE_srp) {
1137             if (size <= 0 || ((len = data[0])) != (size - 1)) {
1138                 *al = SSL_AD_DECODE_ERROR;
1139                 return 0;
1140             }
1141             if (s->srp_ctx.login != NULL) {
1142                 *al = SSL_AD_DECODE_ERROR;
1143                 return 0;
1144             }
1145             if ((s->srp_ctx.login = OPENSSL_malloc(len + 1)) == NULL)
1146                 return -1;
1147             memcpy(s->srp_ctx.login, &data[1], len);
1148             s->srp_ctx.login[len] = '\0';
1149
1150             if (strlen(s->srp_ctx.login) != len) {
1151                 *al = SSL_AD_DECODE_ERROR;
1152                 return 0;
1153             }
1154         }
1155 # endif
1156
1157 # ifndef OPENSSL_NO_EC
1158         else if (type == TLSEXT_TYPE_ec_point_formats) {
1159             unsigned char *sdata = data;
1160             int ecpointformatlist_length = *(sdata++);
1161
1162             if (ecpointformatlist_length != size - 1) {
1163                 *al = TLS1_AD_DECODE_ERROR;
1164                 return 0;
1165             }
1166             if (!s->hit) {
1167                 if (s->session->tlsext_ecpointformatlist) {
1168                     OPENSSL_free(s->session->tlsext_ecpointformatlist);
1169                     s->session->tlsext_ecpointformatlist = NULL;
1170                 }
1171                 s->session->tlsext_ecpointformatlist_length = 0;
1172                 if ((s->session->tlsext_ecpointformatlist =
1173                      OPENSSL_malloc(ecpointformatlist_length)) == NULL) {
1174                     *al = TLS1_AD_INTERNAL_ERROR;
1175                     return 0;
1176                 }
1177                 s->session->tlsext_ecpointformatlist_length =
1178                     ecpointformatlist_length;
1179                 memcpy(s->session->tlsext_ecpointformatlist, sdata,
1180                        ecpointformatlist_length);
1181             }
1182 #  if 0
1183             fprintf(stderr,
1184                     "ssl_parse_clienthello_tlsext s->session->tlsext_ecpointformatlist (length=%i) ",
1185                     s->session->tlsext_ecpointformatlist_length);
1186             sdata = s->session->tlsext_ecpointformatlist;
1187             for (i = 0; i < s->session->tlsext_ecpointformatlist_length; i++)
1188                 fprintf(stderr, "%i ", *(sdata++));
1189             fprintf(stderr, "\n");
1190 #  endif
1191         } else if (type == TLSEXT_TYPE_elliptic_curves) {
1192             unsigned char *sdata = data;
1193             int ellipticcurvelist_length = (*(sdata++) << 8);
1194             ellipticcurvelist_length += (*(sdata++));
1195
1196             if (ellipticcurvelist_length != size - 2 ||
1197                 ellipticcurvelist_length < 1 ||
1198                 /* Each NamedCurve is 2 bytes. */
1199                 ellipticcurvelist_length & 1) {
1200                 *al = TLS1_AD_DECODE_ERROR;
1201                 return 0;
1202             }
1203             if (!s->hit) {
1204                 if (s->session->tlsext_ellipticcurvelist) {
1205                     *al = TLS1_AD_DECODE_ERROR;
1206                     return 0;
1207                 }
1208                 s->session->tlsext_ellipticcurvelist_length = 0;
1209                 if ((s->session->tlsext_ellipticcurvelist =
1210                      OPENSSL_malloc(ellipticcurvelist_length)) == NULL) {
1211                     *al = TLS1_AD_INTERNAL_ERROR;
1212                     return 0;
1213                 }
1214                 s->session->tlsext_ellipticcurvelist_length =
1215                     ellipticcurvelist_length;
1216                 memcpy(s->session->tlsext_ellipticcurvelist, sdata,
1217                        ellipticcurvelist_length);
1218             }
1219 #  if 0
1220             fprintf(stderr,
1221                     "ssl_parse_clienthello_tlsext s->session->tlsext_ellipticcurvelist (length=%i) ",
1222                     s->session->tlsext_ellipticcurvelist_length);
1223             sdata = s->session->tlsext_ellipticcurvelist;
1224             for (i = 0; i < s->session->tlsext_ellipticcurvelist_length; i++)
1225                 fprintf(stderr, "%i ", *(sdata++));
1226             fprintf(stderr, "\n");
1227 #  endif
1228         }
1229 # endif                         /* OPENSSL_NO_EC */
1230 # ifdef TLSEXT_TYPE_opaque_prf_input
1231         else if (type == TLSEXT_TYPE_opaque_prf_input &&
1232                  s->version != DTLS1_VERSION) {
1233             unsigned char *sdata = data;
1234
1235             if (size < 2) {
1236                 *al = SSL_AD_DECODE_ERROR;
1237                 return 0;
1238             }
1239             n2s(sdata, s->s3->client_opaque_prf_input_len);
1240             if (s->s3->client_opaque_prf_input_len != size - 2) {
1241                 *al = SSL_AD_DECODE_ERROR;
1242                 return 0;
1243             }
1244
1245             if (s->s3->client_opaque_prf_input != NULL) {
1246                 /* shouldn't really happen */
1247                 OPENSSL_free(s->s3->client_opaque_prf_input);
1248             }
1249
1250             /* dummy byte just to get non-NULL */
1251             if (s->s3->client_opaque_prf_input_len == 0)
1252                 s->s3->client_opaque_prf_input = OPENSSL_malloc(1);
1253             else
1254                 s->s3->client_opaque_prf_input =
1255                     BUF_memdup(sdata, s->s3->client_opaque_prf_input_len);
1256             if (s->s3->client_opaque_prf_input == NULL) {
1257                 *al = TLS1_AD_INTERNAL_ERROR;
1258                 return 0;
1259             }
1260         }
1261 # endif
1262         else if (type == TLSEXT_TYPE_session_ticket) {
1263             if (s->tls_session_ticket_ext_cb &&
1264                 !s->tls_session_ticket_ext_cb(s, data, size,
1265                                               s->tls_session_ticket_ext_cb_arg))
1266             {
1267                 *al = TLS1_AD_INTERNAL_ERROR;
1268                 return 0;
1269             }
1270         } else if (type == TLSEXT_TYPE_renegotiate) {
1271             if (!ssl_parse_clienthello_renegotiate_ext(s, data, size, al))
1272                 return 0;
1273             renegotiate_seen = 1;
1274         } else if (type == TLSEXT_TYPE_signature_algorithms) {
1275             int dsize;
1276             if (sigalg_seen || size < 2) {
1277                 *al = SSL_AD_DECODE_ERROR;
1278                 return 0;
1279             }
1280             sigalg_seen = 1;
1281             n2s(data, dsize);
1282             size -= 2;
1283             if (dsize != size || dsize & 1) {
1284                 *al = SSL_AD_DECODE_ERROR;
1285                 return 0;
1286             }
1287             if (!tls1_process_sigalgs(s, data, dsize)) {
1288                 *al = SSL_AD_DECODE_ERROR;
1289                 return 0;
1290             }
1291         } else if (type == TLSEXT_TYPE_status_request &&
1292                    s->version != DTLS1_VERSION) {
1293
1294             if (size < 5) {
1295                 *al = SSL_AD_DECODE_ERROR;
1296                 return 0;
1297             }
1298
1299             s->tlsext_status_type = *data++;
1300             size--;
1301             if (s->tlsext_status_type == TLSEXT_STATUSTYPE_ocsp) {
1302                 const unsigned char *sdata;
1303                 int dsize;
1304                 /* Read in responder_id_list */
1305                 n2s(data, dsize);
1306                 size -= 2;
1307                 if (dsize > size) {
1308                     *al = SSL_AD_DECODE_ERROR;
1309                     return 0;
1310                 }
1311                 while (dsize > 0) {
1312                     OCSP_RESPID *id;
1313                     int idsize;
1314                     if (dsize < 4) {
1315                         *al = SSL_AD_DECODE_ERROR;
1316                         return 0;
1317                     }
1318                     n2s(data, idsize);
1319                     dsize -= 2 + idsize;
1320                     size -= 2 + idsize;
1321                     if (dsize < 0) {
1322                         *al = SSL_AD_DECODE_ERROR;
1323                         return 0;
1324                     }
1325                     sdata = data;
1326                     data += idsize;
1327                     id = d2i_OCSP_RESPID(NULL, &sdata, idsize);
1328                     if (!id) {
1329                         *al = SSL_AD_DECODE_ERROR;
1330                         return 0;
1331                     }
1332                     if (data != sdata) {
1333                         OCSP_RESPID_free(id);
1334                         *al = SSL_AD_DECODE_ERROR;
1335                         return 0;
1336                     }
1337                     if (!s->tlsext_ocsp_ids
1338                         && !(s->tlsext_ocsp_ids =
1339                              sk_OCSP_RESPID_new_null())) {
1340                         OCSP_RESPID_free(id);
1341                         *al = SSL_AD_INTERNAL_ERROR;
1342                         return 0;
1343                     }
1344                     if (!sk_OCSP_RESPID_push(s->tlsext_ocsp_ids, id)) {
1345                         OCSP_RESPID_free(id);
1346                         *al = SSL_AD_INTERNAL_ERROR;
1347                         return 0;
1348                     }
1349                 }
1350
1351                 /* Read in request_extensions */
1352                 if (size < 2) {
1353                     *al = SSL_AD_DECODE_ERROR;
1354                     return 0;
1355                 }
1356                 n2s(data, dsize);
1357                 size -= 2;
1358                 if (dsize != size) {
1359                     *al = SSL_AD_DECODE_ERROR;
1360                     return 0;
1361                 }
1362                 sdata = data;
1363                 if (dsize > 0) {
1364                     if (s->tlsext_ocsp_exts) {
1365                         sk_X509_EXTENSION_pop_free(s->tlsext_ocsp_exts,
1366                                                    X509_EXTENSION_free);
1367                     }
1368
1369                     s->tlsext_ocsp_exts =
1370                         d2i_X509_EXTENSIONS(NULL, &sdata, dsize);
1371                     if (!s->tlsext_ocsp_exts || (data + dsize != sdata)) {
1372                         *al = SSL_AD_DECODE_ERROR;
1373                         return 0;
1374                     }
1375                 }
1376             }
1377             /*
1378              * We don't know what to do with any other type * so ignore it.
1379              */
1380             else
1381                 s->tlsext_status_type = -1;
1382         }
1383 # ifndef OPENSSL_NO_HEARTBEATS
1384         else if (type == TLSEXT_TYPE_heartbeat) {
1385             switch (data[0]) {
1386             case 0x01:         /* Client allows us to send HB requests */
1387                 s->tlsext_heartbeat |= SSL_TLSEXT_HB_ENABLED;
1388                 break;
1389             case 0x02:         /* Client doesn't accept HB requests */
1390                 s->tlsext_heartbeat |= SSL_TLSEXT_HB_ENABLED;
1391                 s->tlsext_heartbeat |= SSL_TLSEXT_HB_DONT_SEND_REQUESTS;
1392                 break;
1393             default:
1394                 *al = SSL_AD_ILLEGAL_PARAMETER;
1395                 return 0;
1396             }
1397         }
1398 # endif
1399 # ifndef OPENSSL_NO_NEXTPROTONEG
1400         else if (type == TLSEXT_TYPE_next_proto_neg &&
1401                  s->s3->tmp.finish_md_len == 0) {
1402             /*-
1403              * We shouldn't accept this extension on a
1404              * renegotiation.
1405              *
1406              * s->new_session will be set on renegotiation, but we
1407              * probably shouldn't rely that it couldn't be set on
1408              * the initial renegotation too in certain cases (when
1409              * there's some other reason to disallow resuming an
1410              * earlier session -- the current code won't be doing
1411              * anything like that, but this might change).
1412              *
1413              * A valid sign that there's been a previous handshake
1414              * in this connection is if s->s3->tmp.finish_md_len >
1415              * 0.  (We are talking about a check that will happen
1416              * in the Hello protocol round, well before a new
1417              * Finished message could have been computed.)
1418              */
1419             s->s3->next_proto_neg_seen = 1;
1420         }
1421 # endif
1422
1423         /* session ticket processed earlier */
1424 # ifndef OPENSSL_NO_SRTP
1425         else if (SSL_IS_DTLS(s) && SSL_get_srtp_profiles(s)
1426                  && type == TLSEXT_TYPE_use_srtp) {
1427             if (ssl_parse_clienthello_use_srtp_ext(s, data, size, al))
1428                 return 0;
1429         }
1430 # endif
1431
1432         data += size;
1433     }
1434
1435     *p = data;
1436
1437  ri_check:
1438
1439     /* Need RI if renegotiating */
1440
1441     if (!renegotiate_seen && s->renegotiate &&
1442         !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)) {
1443         *al = SSL_AD_HANDSHAKE_FAILURE;
1444         SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_TLSEXT,
1445                SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
1446         return 0;
1447     }
1448
1449     return 1;
1450 }
1451
1452 # ifndef OPENSSL_NO_NEXTPROTONEG
1453 /*
1454  * ssl_next_proto_validate validates a Next Protocol Negotiation block. No
1455  * elements of zero length are allowed and the set of elements must exactly
1456  * fill the length of the block.
1457  */
1458 static char ssl_next_proto_validate(unsigned char *d, unsigned len)
1459 {
1460     unsigned int off = 0;
1461
1462     while (off < len) {
1463         if (d[off] == 0)
1464             return 0;
1465         off += d[off];
1466         off++;
1467     }
1468
1469     return off == len;
1470 }
1471 # endif
1472
1473 int ssl_parse_serverhello_tlsext(SSL *s, unsigned char **p, unsigned char *d,
1474                                  int n, int *al)
1475 {
1476     unsigned short length;
1477     unsigned short type;
1478     unsigned short size;
1479     unsigned char *data = *p;
1480     int tlsext_servername = 0;
1481     int renegotiate_seen = 0;
1482
1483 # ifndef OPENSSL_NO_NEXTPROTONEG
1484     s->s3->next_proto_neg_seen = 0;
1485 # endif
1486     s->tlsext_ticket_expected = 0;
1487
1488 # ifndef OPENSSL_NO_HEARTBEATS
1489     s->tlsext_heartbeat &= ~(SSL_TLSEXT_HB_ENABLED |
1490                              SSL_TLSEXT_HB_DONT_SEND_REQUESTS);
1491 # endif
1492
1493     if (data >= (d + n - 2))
1494         goto ri_check;
1495
1496     n2s(data, length);
1497     if (data + length != d + n) {
1498         *al = SSL_AD_DECODE_ERROR;
1499         return 0;
1500     }
1501
1502     while (data <= (d + n - 4)) {
1503         n2s(data, type);
1504         n2s(data, size);
1505
1506         if (data + size > (d + n))
1507             goto ri_check;
1508
1509         if (s->tlsext_debug_cb)
1510             s->tlsext_debug_cb(s, 1, type, data, size, s->tlsext_debug_arg);
1511
1512         if (type == TLSEXT_TYPE_server_name) {
1513             if (s->tlsext_hostname == NULL || size > 0) {
1514                 *al = TLS1_AD_UNRECOGNIZED_NAME;
1515                 return 0;
1516             }
1517             tlsext_servername = 1;
1518         }
1519 # ifndef OPENSSL_NO_EC
1520         else if (type == TLSEXT_TYPE_ec_point_formats) {
1521             unsigned char *sdata = data;
1522             int ecpointformatlist_length = *(sdata++);
1523
1524             if (ecpointformatlist_length != size - 1 ||
1525                 ecpointformatlist_length < 1) {
1526                 *al = TLS1_AD_DECODE_ERROR;
1527                 return 0;
1528             }
1529             if (!s->hit) {
1530                 s->session->tlsext_ecpointformatlist_length = 0;
1531                 if (s->session->tlsext_ecpointformatlist != NULL)
1532                     OPENSSL_free(s->session->tlsext_ecpointformatlist);
1533                 if ((s->session->tlsext_ecpointformatlist =
1534                      OPENSSL_malloc(ecpointformatlist_length)) == NULL) {
1535                     *al = TLS1_AD_INTERNAL_ERROR;
1536                     return 0;
1537                 }
1538                 s->session->tlsext_ecpointformatlist_length =
1539                     ecpointformatlist_length;
1540                 memcpy(s->session->tlsext_ecpointformatlist, sdata,
1541                        ecpointformatlist_length);
1542             }
1543 #  if 0
1544             fprintf(stderr,
1545                     "ssl_parse_serverhello_tlsext s->session->tlsext_ecpointformatlist ");
1546             sdata = s->session->tlsext_ecpointformatlist;
1547             for (i = 0; i < s->session->tlsext_ecpointformatlist_length; i++)
1548                 fprintf(stderr, "%i ", *(sdata++));
1549             fprintf(stderr, "\n");
1550 #  endif
1551         }
1552 # endif                         /* OPENSSL_NO_EC */
1553
1554         else if (type == TLSEXT_TYPE_session_ticket) {
1555             if (s->tls_session_ticket_ext_cb &&
1556                 !s->tls_session_ticket_ext_cb(s, data, size,
1557                                               s->tls_session_ticket_ext_cb_arg))
1558             {
1559                 *al = TLS1_AD_INTERNAL_ERROR;
1560                 return 0;
1561             }
1562             if ((SSL_get_options(s) & SSL_OP_NO_TICKET)
1563                 || (size > 0)) {
1564                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
1565                 return 0;
1566             }
1567             s->tlsext_ticket_expected = 1;
1568         }
1569 # ifdef TLSEXT_TYPE_opaque_prf_input
1570         else if (type == TLSEXT_TYPE_opaque_prf_input &&
1571                  s->version != DTLS1_VERSION) {
1572             unsigned char *sdata = data;
1573
1574             if (size < 2) {
1575                 *al = SSL_AD_DECODE_ERROR;
1576                 return 0;
1577             }
1578             n2s(sdata, s->s3->server_opaque_prf_input_len);
1579             if (s->s3->server_opaque_prf_input_len != size - 2) {
1580                 *al = SSL_AD_DECODE_ERROR;
1581                 return 0;
1582             }
1583
1584             if (s->s3->server_opaque_prf_input != NULL) {
1585                 /* shouldn't really happen */
1586                 OPENSSL_free(s->s3->server_opaque_prf_input);
1587             }
1588             if (s->s3->server_opaque_prf_input_len == 0) {
1589                 /* dummy byte just to get non-NULL */
1590                 s->s3->server_opaque_prf_input = OPENSSL_malloc(1);
1591             } else {
1592                 s->s3->server_opaque_prf_input =
1593                     BUF_memdup(sdata, s->s3->server_opaque_prf_input_len);
1594             }
1595
1596             if (s->s3->server_opaque_prf_input == NULL) {
1597                 *al = TLS1_AD_INTERNAL_ERROR;
1598                 return 0;
1599             }
1600         }
1601 # endif
1602         else if (type == TLSEXT_TYPE_status_request &&
1603                  s->version != DTLS1_VERSION) {
1604             /*
1605              * MUST be empty and only sent if we've requested a status
1606              * request message.
1607              */
1608             if ((s->tlsext_status_type == -1) || (size > 0)) {
1609                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
1610                 return 0;
1611             }
1612             /* Set flag to expect CertificateStatus message */
1613             s->tlsext_status_expected = 1;
1614         }
1615 # ifndef OPENSSL_NO_NEXTPROTONEG
1616         else if (type == TLSEXT_TYPE_next_proto_neg &&
1617                  s->s3->tmp.finish_md_len == 0) {
1618             unsigned char *selected;
1619             unsigned char selected_len;
1620
1621             /* We must have requested it. */
1622             if (s->ctx->next_proto_select_cb == NULL) {
1623                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
1624                 return 0;
1625             }
1626             /* The data must be valid */
1627             if (!ssl_next_proto_validate(data, size)) {
1628                 *al = TLS1_AD_DECODE_ERROR;
1629                 return 0;
1630             }
1631             if (s->
1632                 ctx->next_proto_select_cb(s, &selected, &selected_len, data,
1633                                           size,
1634                                           s->ctx->next_proto_select_cb_arg) !=
1635                 SSL_TLSEXT_ERR_OK) {
1636                 *al = TLS1_AD_INTERNAL_ERROR;
1637                 return 0;
1638             }
1639             s->next_proto_negotiated = OPENSSL_malloc(selected_len);
1640             if (!s->next_proto_negotiated) {
1641                 *al = TLS1_AD_INTERNAL_ERROR;
1642                 return 0;
1643             }
1644             memcpy(s->next_proto_negotiated, selected, selected_len);
1645             s->next_proto_negotiated_len = selected_len;
1646             s->s3->next_proto_neg_seen = 1;
1647         }
1648 # endif
1649         else if (type == TLSEXT_TYPE_renegotiate) {
1650             if (!ssl_parse_serverhello_renegotiate_ext(s, data, size, al))
1651                 return 0;
1652             renegotiate_seen = 1;
1653         }
1654 # ifndef OPENSSL_NO_HEARTBEATS
1655         else if (type == TLSEXT_TYPE_heartbeat) {
1656             switch (data[0]) {
1657             case 0x01:         /* Server allows us to send HB requests */
1658                 s->tlsext_heartbeat |= SSL_TLSEXT_HB_ENABLED;
1659                 break;
1660             case 0x02:         /* Server doesn't accept HB requests */
1661                 s->tlsext_heartbeat |= SSL_TLSEXT_HB_ENABLED;
1662                 s->tlsext_heartbeat |= SSL_TLSEXT_HB_DONT_SEND_REQUESTS;
1663                 break;
1664             default:
1665                 *al = SSL_AD_ILLEGAL_PARAMETER;
1666                 return 0;
1667             }
1668         }
1669 # endif
1670 # ifndef OPENSSL_NO_SRTP
1671         else if (SSL_IS_DTLS(s) && type == TLSEXT_TYPE_use_srtp) {
1672             if (ssl_parse_serverhello_use_srtp_ext(s, data, size, al))
1673                 return 0;
1674         }
1675 # endif
1676
1677         data += size;
1678     }
1679
1680     if (data != d + n) {
1681         *al = SSL_AD_DECODE_ERROR;
1682         return 0;
1683     }
1684
1685     if (!s->hit && tlsext_servername == 1) {
1686         if (s->tlsext_hostname) {
1687             if (s->session->tlsext_hostname == NULL) {
1688                 s->session->tlsext_hostname = BUF_strdup(s->tlsext_hostname);
1689                 if (!s->session->tlsext_hostname) {
1690                     *al = SSL_AD_UNRECOGNIZED_NAME;
1691                     return 0;
1692                 }
1693             } else {
1694                 *al = SSL_AD_DECODE_ERROR;
1695                 return 0;
1696             }
1697         }
1698     }
1699
1700     *p = data;
1701
1702  ri_check:
1703
1704     /*
1705      * Determine if we need to see RI. Strictly speaking if we want to avoid
1706      * an attack we should *always* see RI even on initial server hello
1707      * because the client doesn't see any renegotiation during an attack.
1708      * However this would mean we could not connect to any server which
1709      * doesn't support RI so for the immediate future tolerate RI absence on
1710      * initial connect only.
1711      */
1712     if (!renegotiate_seen && !(s->options & SSL_OP_LEGACY_SERVER_CONNECT)
1713         && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)) {
1714         *al = SSL_AD_HANDSHAKE_FAILURE;
1715         SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_TLSEXT,
1716                SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
1717         return 0;
1718     }
1719
1720     return 1;
1721 }
1722
1723 int ssl_prepare_clienthello_tlsext(SSL *s)
1724 {
1725 # ifndef OPENSSL_NO_EC
1726     /*
1727      * If we are client and using an elliptic curve cryptography cipher
1728      * suite, send the point formats and elliptic curves we support.
1729      */
1730     int using_ecc = 0;
1731     int i;
1732     unsigned char *j;
1733     unsigned long alg_k, alg_a;
1734     STACK_OF(SSL_CIPHER) *cipher_stack = SSL_get_ciphers(s);
1735
1736     for (i = 0; i < sk_SSL_CIPHER_num(cipher_stack); i++) {
1737         SSL_CIPHER *c = sk_SSL_CIPHER_value(cipher_stack, i);
1738
1739         alg_k = c->algorithm_mkey;
1740         alg_a = c->algorithm_auth;
1741         if ((alg_k & (SSL_kEECDH | SSL_kECDHr | SSL_kECDHe)
1742              || (alg_a & SSL_aECDSA))) {
1743             using_ecc = 1;
1744             break;
1745         }
1746     }
1747     using_ecc = using_ecc && (s->version >= TLS1_VERSION);
1748     if (using_ecc) {
1749         if (s->tlsext_ecpointformatlist != NULL)
1750             OPENSSL_free(s->tlsext_ecpointformatlist);
1751         if ((s->tlsext_ecpointformatlist = OPENSSL_malloc(3)) == NULL) {
1752             SSLerr(SSL_F_SSL_PREPARE_CLIENTHELLO_TLSEXT,
1753                    ERR_R_MALLOC_FAILURE);
1754             return -1;
1755         }
1756         s->tlsext_ecpointformatlist_length = 3;
1757         s->tlsext_ecpointformatlist[0] = TLSEXT_ECPOINTFORMAT_uncompressed;
1758         s->tlsext_ecpointformatlist[1] =
1759             TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime;
1760         s->tlsext_ecpointformatlist[2] =
1761             TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2;
1762
1763         /* we support all named elliptic curves in RFC 4492 */
1764         if (s->tlsext_ellipticcurvelist != NULL)
1765             OPENSSL_free(s->tlsext_ellipticcurvelist);
1766         s->tlsext_ellipticcurvelist_length =
1767             sizeof(pref_list) / sizeof(pref_list[0]) * 2;
1768         if ((s->tlsext_ellipticcurvelist =
1769              OPENSSL_malloc(s->tlsext_ellipticcurvelist_length)) == NULL) {
1770             s->tlsext_ellipticcurvelist_length = 0;
1771             SSLerr(SSL_F_SSL_PREPARE_CLIENTHELLO_TLSEXT,
1772                    ERR_R_MALLOC_FAILURE);
1773             return -1;
1774         }
1775         for (i = 0, j = s->tlsext_ellipticcurvelist; (unsigned int)i <
1776              sizeof(pref_list) / sizeof(pref_list[0]); i++) {
1777             int id = tls1_ec_nid2curve_id(pref_list[i]);
1778             s2n(id, j);
1779         }
1780     }
1781 # endif                         /* OPENSSL_NO_EC */
1782
1783 # ifdef TLSEXT_TYPE_opaque_prf_input
1784     {
1785         int r = 1;
1786
1787         if (s->ctx->tlsext_opaque_prf_input_callback != 0) {
1788             r = s->ctx->tlsext_opaque_prf_input_callback(s, NULL, 0,
1789                                                          s->
1790                                                          ctx->tlsext_opaque_prf_input_callback_arg);
1791             if (!r)
1792                 return -1;
1793         }
1794
1795         if (s->tlsext_opaque_prf_input != NULL) {
1796             if (s->s3->client_opaque_prf_input != NULL) {
1797                 /* shouldn't really happen */
1798                 OPENSSL_free(s->s3->client_opaque_prf_input);
1799             }
1800
1801             if (s->tlsext_opaque_prf_input_len == 0) {
1802                 /* dummy byte just to get non-NULL */
1803                 s->s3->client_opaque_prf_input = OPENSSL_malloc(1);
1804             } else {
1805                 s->s3->client_opaque_prf_input =
1806                     BUF_memdup(s->tlsext_opaque_prf_input,
1807                                s->tlsext_opaque_prf_input_len);
1808             }
1809             if (s->s3->client_opaque_prf_input == NULL) {
1810                 SSLerr(SSL_F_SSL_PREPARE_CLIENTHELLO_TLSEXT,
1811                        ERR_R_MALLOC_FAILURE);
1812                 return -1;
1813             }
1814             s->s3->client_opaque_prf_input_len =
1815                 s->tlsext_opaque_prf_input_len;
1816         }
1817
1818         if (r == 2)
1819             /*
1820              * at callback's request, insist on receiving an appropriate
1821              * server opaque PRF input
1822              */
1823             s->s3->server_opaque_prf_input_len =
1824                 s->tlsext_opaque_prf_input_len;
1825     }
1826 # endif
1827
1828     return 1;
1829 }
1830
1831 int ssl_prepare_serverhello_tlsext(SSL *s)
1832 {
1833 # ifndef OPENSSL_NO_EC
1834     /*
1835      * If we are server and using an ECC cipher suite, send the point formats
1836      * we support if the client sent us an ECPointsFormat extension.  Note
1837      * that the server is not supposed to send an EllipticCurves extension.
1838      */
1839
1840     unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
1841     unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
1842     int using_ecc = (alg_k & (SSL_kEECDH | SSL_kECDHr | SSL_kECDHe))
1843         || (alg_a & SSL_aECDSA);
1844     using_ecc = using_ecc && (s->session->tlsext_ecpointformatlist != NULL);
1845
1846     if (using_ecc) {
1847         if (s->tlsext_ecpointformatlist != NULL)
1848             OPENSSL_free(s->tlsext_ecpointformatlist);
1849         if ((s->tlsext_ecpointformatlist = OPENSSL_malloc(3)) == NULL) {
1850             SSLerr(SSL_F_SSL_PREPARE_SERVERHELLO_TLSEXT,
1851                    ERR_R_MALLOC_FAILURE);
1852             return -1;
1853         }
1854         s->tlsext_ecpointformatlist_length = 3;
1855         s->tlsext_ecpointformatlist[0] = TLSEXT_ECPOINTFORMAT_uncompressed;
1856         s->tlsext_ecpointformatlist[1] =
1857             TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime;
1858         s->tlsext_ecpointformatlist[2] =
1859             TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2;
1860     }
1861 # endif                         /* OPENSSL_NO_EC */
1862
1863     return 1;
1864 }
1865
1866 int ssl_check_clienthello_tlsext_early(SSL *s)
1867 {
1868     int ret = SSL_TLSEXT_ERR_NOACK;
1869     int al = SSL_AD_UNRECOGNIZED_NAME;
1870
1871 # ifndef OPENSSL_NO_EC
1872     /*
1873      * The handling of the ECPointFormats extension is done elsewhere, namely
1874      * in ssl3_choose_cipher in s3_lib.c.
1875      */
1876     /*
1877      * The handling of the EllipticCurves extension is done elsewhere, namely
1878      * in ssl3_choose_cipher in s3_lib.c.
1879      */
1880 # endif
1881
1882     if (s->ctx != NULL && s->ctx->tlsext_servername_callback != 0)
1883         ret =
1884             s->ctx->tlsext_servername_callback(s, &al,
1885                                                s->ctx->tlsext_servername_arg);
1886     else if (s->initial_ctx != NULL
1887              && s->initial_ctx->tlsext_servername_callback != 0)
1888         ret =
1889             s->initial_ctx->tlsext_servername_callback(s, &al,
1890                                                        s->
1891                                                        initial_ctx->tlsext_servername_arg);
1892
1893 # ifdef TLSEXT_TYPE_opaque_prf_input
1894     {
1895         /*
1896          * This sort of belongs into ssl_prepare_serverhello_tlsext(), but we
1897          * might be sending an alert in response to the client hello, so this
1898          * has to happen here in ssl_check_clienthello_tlsext_early().
1899          */
1900
1901         int r = 1;
1902
1903         if (s->ctx->tlsext_opaque_prf_input_callback != 0) {
1904             r = s->ctx->tlsext_opaque_prf_input_callback(s, NULL, 0,
1905                                                          s->
1906                                                          ctx->tlsext_opaque_prf_input_callback_arg);
1907             if (!r) {
1908                 ret = SSL_TLSEXT_ERR_ALERT_FATAL;
1909                 al = SSL_AD_INTERNAL_ERROR;
1910                 goto err;
1911             }
1912         }
1913
1914         if (s->s3->server_opaque_prf_input != NULL) {
1915             /* shouldn't really happen */
1916             OPENSSL_free(s->s3->server_opaque_prf_input);
1917         }
1918         s->s3->server_opaque_prf_input = NULL;
1919
1920         if (s->tlsext_opaque_prf_input != NULL) {
1921             if (s->s3->client_opaque_prf_input != NULL &&
1922                 s->s3->client_opaque_prf_input_len ==
1923                 s->tlsext_opaque_prf_input_len) {
1924                 /*
1925                  * can only use this extension if we have a server opaque PRF
1926                  * input of the same length as the client opaque PRF input!
1927                  */
1928
1929                 if (s->tlsext_opaque_prf_input_len == 0) {
1930                     /* dummy byte just to get non-NULL */
1931                     s->s3->server_opaque_prf_input = OPENSSL_malloc(1);
1932                 } else {
1933                     s->s3->server_opaque_prf_input =
1934                         BUF_memdup(s->tlsext_opaque_prf_input,
1935                                    s->tlsext_opaque_prf_input_len);
1936                 }
1937                 if (s->s3->server_opaque_prf_input == NULL) {
1938                     ret = SSL_TLSEXT_ERR_ALERT_FATAL;
1939                     al = SSL_AD_INTERNAL_ERROR;
1940                     goto err;
1941                 }
1942                 s->s3->server_opaque_prf_input_len =
1943                     s->tlsext_opaque_prf_input_len;
1944             }
1945         }
1946
1947         if (r == 2 && s->s3->server_opaque_prf_input == NULL) {
1948             /*
1949              * The callback wants to enforce use of the extension, but we
1950              * can't do that with the client opaque PRF input; abort the
1951              * handshake.
1952              */
1953             ret = SSL_TLSEXT_ERR_ALERT_FATAL;
1954             al = SSL_AD_HANDSHAKE_FAILURE;
1955         }
1956     }
1957
1958  err:
1959 # endif
1960     switch (ret) {
1961     case SSL_TLSEXT_ERR_ALERT_FATAL:
1962         ssl3_send_alert(s, SSL3_AL_FATAL, al);
1963         return -1;
1964
1965     case SSL_TLSEXT_ERR_ALERT_WARNING:
1966         ssl3_send_alert(s, SSL3_AL_WARNING, al);
1967         return 1;
1968
1969     case SSL_TLSEXT_ERR_NOACK:
1970         s->servername_done = 0;
1971     default:
1972         return 1;
1973     }
1974 }
1975
1976 int ssl_check_clienthello_tlsext_late(SSL *s)
1977 {
1978     int ret = SSL_TLSEXT_ERR_OK;
1979     int al;
1980
1981     /*
1982      * If status request then ask callback what to do. Note: this must be
1983      * called after servername callbacks in case the certificate has
1984      * changed, and must be called after the cipher has been chosen because
1985      * this may influence which certificate is sent
1986      */
1987     if ((s->tlsext_status_type != -1) && s->ctx && s->ctx->tlsext_status_cb) {
1988         int r;
1989         CERT_PKEY *certpkey;
1990         certpkey = ssl_get_server_send_pkey(s);
1991         /* If no certificate can't return certificate status */
1992         if (certpkey == NULL) {
1993             s->tlsext_status_expected = 0;
1994             return 1;
1995         }
1996         /*
1997          * Set current certificate to one we will use so SSL_get_certificate
1998          * et al can pick it up.
1999          */
2000         s->cert->key = certpkey;
2001         r = s->ctx->tlsext_status_cb(s, s->ctx->tlsext_status_arg);
2002         switch (r) {
2003             /* We don't want to send a status request response */
2004         case SSL_TLSEXT_ERR_NOACK:
2005             s->tlsext_status_expected = 0;
2006             break;
2007             /* status request response should be sent */
2008         case SSL_TLSEXT_ERR_OK:
2009             if (s->tlsext_ocsp_resp)
2010                 s->tlsext_status_expected = 1;
2011             else
2012                 s->tlsext_status_expected = 0;
2013             break;
2014             /* something bad happened */
2015         case SSL_TLSEXT_ERR_ALERT_FATAL:
2016             ret = SSL_TLSEXT_ERR_ALERT_FATAL;
2017             al = SSL_AD_INTERNAL_ERROR;
2018             goto err;
2019         }
2020     } else
2021         s->tlsext_status_expected = 0;
2022
2023  err:
2024     switch (ret) {
2025     case SSL_TLSEXT_ERR_ALERT_FATAL:
2026         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2027         return -1;
2028
2029     case SSL_TLSEXT_ERR_ALERT_WARNING:
2030         ssl3_send_alert(s, SSL3_AL_WARNING, al);
2031         return 1;
2032
2033     default:
2034         return 1;
2035     }
2036 }
2037
2038 int ssl_check_serverhello_tlsext(SSL *s)
2039 {
2040     int ret = SSL_TLSEXT_ERR_NOACK;
2041     int al = SSL_AD_UNRECOGNIZED_NAME;
2042
2043 # ifndef OPENSSL_NO_EC
2044     /*
2045      * If we are client and using an elliptic curve cryptography cipher
2046      * suite, then if server returns an EC point formats lists extension it
2047      * must contain uncompressed.
2048      */
2049     unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
2050     unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
2051     if ((s->tlsext_ecpointformatlist != NULL)
2052         && (s->tlsext_ecpointformatlist_length > 0)
2053         && (s->session->tlsext_ecpointformatlist != NULL)
2054         && (s->session->tlsext_ecpointformatlist_length > 0)
2055         && ((alg_k & (SSL_kEECDH | SSL_kECDHr | SSL_kECDHe))
2056             || (alg_a & SSL_aECDSA))) {
2057         /* we are using an ECC cipher */
2058         size_t i;
2059         unsigned char *list;
2060         int found_uncompressed = 0;
2061         list = s->session->tlsext_ecpointformatlist;
2062         for (i = 0; i < s->session->tlsext_ecpointformatlist_length; i++) {
2063             if (*(list++) == TLSEXT_ECPOINTFORMAT_uncompressed) {
2064                 found_uncompressed = 1;
2065                 break;
2066             }
2067         }
2068         if (!found_uncompressed) {
2069             SSLerr(SSL_F_SSL_CHECK_SERVERHELLO_TLSEXT,
2070                    SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST);
2071             return -1;
2072         }
2073     }
2074     ret = SSL_TLSEXT_ERR_OK;
2075 # endif                         /* OPENSSL_NO_EC */
2076
2077     if (s->ctx != NULL && s->ctx->tlsext_servername_callback != 0)
2078         ret =
2079             s->ctx->tlsext_servername_callback(s, &al,
2080                                                s->ctx->tlsext_servername_arg);
2081     else if (s->initial_ctx != NULL
2082              && s->initial_ctx->tlsext_servername_callback != 0)
2083         ret =
2084             s->initial_ctx->tlsext_servername_callback(s, &al,
2085                                                        s->
2086                                                        initial_ctx->tlsext_servername_arg);
2087
2088 # ifdef TLSEXT_TYPE_opaque_prf_input
2089     if (s->s3->server_opaque_prf_input_len > 0) {
2090         /*
2091          * This case may indicate that we, as a client, want to insist on
2092          * using opaque PRF inputs. So first verify that we really have a
2093          * value from the server too.
2094          */
2095
2096         if (s->s3->server_opaque_prf_input == NULL) {
2097             ret = SSL_TLSEXT_ERR_ALERT_FATAL;
2098             al = SSL_AD_HANDSHAKE_FAILURE;
2099         }
2100
2101         /*
2102          * Anytime the server *has* sent an opaque PRF input, we need to
2103          * check that we have a client opaque PRF input of the same size.
2104          */
2105         if (s->s3->client_opaque_prf_input == NULL ||
2106             s->s3->client_opaque_prf_input_len !=
2107             s->s3->server_opaque_prf_input_len) {
2108             ret = SSL_TLSEXT_ERR_ALERT_FATAL;
2109             al = SSL_AD_ILLEGAL_PARAMETER;
2110         }
2111     }
2112 # endif
2113
2114     /*
2115      * If we've requested certificate status and we wont get one tell the
2116      * callback
2117      */
2118     if ((s->tlsext_status_type != -1) && !(s->tlsext_status_expected)
2119         && s->ctx && s->ctx->tlsext_status_cb) {
2120         int r;
2121         /*
2122          * Set resp to NULL, resplen to -1 so callback knows there is no
2123          * response.
2124          */
2125         if (s->tlsext_ocsp_resp) {
2126             OPENSSL_free(s->tlsext_ocsp_resp);
2127             s->tlsext_ocsp_resp = NULL;
2128         }
2129         s->tlsext_ocsp_resplen = -1;
2130         r = s->ctx->tlsext_status_cb(s, s->ctx->tlsext_status_arg);
2131         if (r == 0) {
2132             al = SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE;
2133             ret = SSL_TLSEXT_ERR_ALERT_FATAL;
2134         }
2135         if (r < 0) {
2136             al = SSL_AD_INTERNAL_ERROR;
2137             ret = SSL_TLSEXT_ERR_ALERT_FATAL;
2138         }
2139     }
2140
2141     switch (ret) {
2142     case SSL_TLSEXT_ERR_ALERT_FATAL:
2143         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2144         return -1;
2145
2146     case SSL_TLSEXT_ERR_ALERT_WARNING:
2147         ssl3_send_alert(s, SSL3_AL_WARNING, al);
2148         return 1;
2149
2150     case SSL_TLSEXT_ERR_NOACK:
2151         s->servername_done = 0;
2152     default:
2153         return 1;
2154     }
2155 }
2156
2157 /*-
2158  * Since the server cache lookup is done early on in the processing of the
2159  * ClientHello, and other operations depend on the result, we need to handle
2160  * any TLS session ticket extension at the same time.
2161  *
2162  *   session_id: points at the session ID in the ClientHello. This code will
2163  *       read past the end of this in order to parse out the session ticket
2164  *       extension, if any.
2165  *   len: the length of the session ID.
2166  *   limit: a pointer to the first byte after the ClientHello.
2167  *   ret: (output) on return, if a ticket was decrypted, then this is set to
2168  *       point to the resulting session.
2169  *
2170  * If s->tls_session_secret_cb is set then we are expecting a pre-shared key
2171  * ciphersuite, in which case we have no use for session tickets and one will
2172  * never be decrypted, nor will s->tlsext_ticket_expected be set to 1.
2173  *
2174  * Returns:
2175  *   -1: fatal error, either from parsing or decrypting the ticket.
2176  *    0: no ticket was found (or was ignored, based on settings).
2177  *    1: a zero length extension was found, indicating that the client supports
2178  *       session tickets but doesn't currently have one to offer.
2179  *    2: either s->tls_session_secret_cb was set, or a ticket was offered but
2180  *       couldn't be decrypted because of a non-fatal error.
2181  *    3: a ticket was successfully decrypted and *ret was set.
2182  *
2183  * Side effects:
2184  *   Sets s->tlsext_ticket_expected to 1 if the server will have to issue
2185  *   a new session ticket to the client because the client indicated support
2186  *   (and s->tls_session_secret_cb is NULL) but the client either doesn't have
2187  *   a session ticket or we couldn't use the one it gave us, or if
2188  *   s->ctx->tlsext_ticket_key_cb asked to renew the client's ticket.
2189  *   Otherwise, s->tlsext_ticket_expected is set to 0.
2190  */
2191 int tls1_process_ticket(SSL *s, unsigned char *session_id, int len,
2192                         const unsigned char *limit, SSL_SESSION **ret)
2193 {
2194     /* Point after session ID in client hello */
2195     const unsigned char *p = session_id + len;
2196     unsigned short i;
2197
2198     *ret = NULL;
2199     s->tlsext_ticket_expected = 0;
2200
2201     /*
2202      * If tickets disabled behave as if no ticket present to permit stateful
2203      * resumption.
2204      */
2205     if (SSL_get_options(s) & SSL_OP_NO_TICKET)
2206         return 0;
2207     if ((s->version <= SSL3_VERSION) || !limit)
2208         return 0;
2209     if (p >= limit)
2210         return -1;
2211     /* Skip past DTLS cookie */
2212     if (s->version == DTLS1_VERSION || s->version == DTLS1_BAD_VER) {
2213         i = *(p++);
2214         p += i;
2215         if (p >= limit)
2216             return -1;
2217     }
2218     /* Skip past cipher list */
2219     n2s(p, i);
2220     p += i;
2221     if (p >= limit)
2222         return -1;
2223     /* Skip past compression algorithm list */
2224     i = *(p++);
2225     p += i;
2226     if (p > limit)
2227         return -1;
2228     /* Now at start of extensions */
2229     if ((p + 2) >= limit)
2230         return 0;
2231     n2s(p, i);
2232     while ((p + 4) <= limit) {
2233         unsigned short type, size;
2234         n2s(p, type);
2235         n2s(p, size);
2236         if (p + size > limit)
2237             return 0;
2238         if (type == TLSEXT_TYPE_session_ticket) {
2239             int r;
2240             if (size == 0) {
2241                 /*
2242                  * The client will accept a ticket but doesn't currently have
2243                  * one.
2244                  */
2245                 s->tlsext_ticket_expected = 1;
2246                 return 1;
2247             }
2248             if (s->tls_session_secret_cb) {
2249                 /*
2250                  * Indicate that the ticket couldn't be decrypted rather than
2251                  * generating the session from ticket now, trigger
2252                  * abbreviated handshake based on external mechanism to
2253                  * calculate the master secret later.
2254                  */
2255                 return 2;
2256             }
2257             r = tls_decrypt_ticket(s, p, size, session_id, len, ret);
2258             switch (r) {
2259             case 2:            /* ticket couldn't be decrypted */
2260                 s->tlsext_ticket_expected = 1;
2261                 return 2;
2262             case 3:            /* ticket was decrypted */
2263                 return r;
2264             case 4:            /* ticket decrypted but need to renew */
2265                 s->tlsext_ticket_expected = 1;
2266                 return 3;
2267             default:           /* fatal error */
2268                 return -1;
2269             }
2270         }
2271         p += size;
2272     }
2273     return 0;
2274 }
2275
2276 /*-
2277  * tls_decrypt_ticket attempts to decrypt a session ticket.
2278  *
2279  *   etick: points to the body of the session ticket extension.
2280  *   eticklen: the length of the session tickets extenion.
2281  *   sess_id: points at the session ID.
2282  *   sesslen: the length of the session ID.
2283  *   psess: (output) on return, if a ticket was decrypted, then this is set to
2284  *       point to the resulting session.
2285  *
2286  * Returns:
2287  *   -1: fatal error, either from parsing or decrypting the ticket.
2288  *    2: the ticket couldn't be decrypted.
2289  *    3: a ticket was successfully decrypted and *psess was set.
2290  *    4: same as 3, but the ticket needs to be renewed.
2291  */
2292 static int tls_decrypt_ticket(SSL *s, const unsigned char *etick,
2293                               int eticklen, const unsigned char *sess_id,
2294                               int sesslen, SSL_SESSION **psess)
2295 {
2296     SSL_SESSION *sess;
2297     unsigned char *sdec;
2298     const unsigned char *p;
2299     int slen, mlen, renew_ticket = 0;
2300     unsigned char tick_hmac[EVP_MAX_MD_SIZE];
2301     HMAC_CTX hctx;
2302     EVP_CIPHER_CTX ctx;
2303     SSL_CTX *tctx = s->initial_ctx;
2304     /* Need at least keyname + iv + some encrypted data */
2305     if (eticklen < 48)
2306         return 2;
2307     /* Initialize session ticket encryption and HMAC contexts */
2308     HMAC_CTX_init(&hctx);
2309     EVP_CIPHER_CTX_init(&ctx);
2310     if (tctx->tlsext_ticket_key_cb) {
2311         unsigned char *nctick = (unsigned char *)etick;
2312         int rv = tctx->tlsext_ticket_key_cb(s, nctick, nctick + 16,
2313                                             &ctx, &hctx, 0);
2314         if (rv < 0)
2315             return -1;
2316         if (rv == 0)
2317             return 2;
2318         if (rv == 2)
2319             renew_ticket = 1;
2320     } else {
2321         /* Check key name matches */
2322         if (memcmp(etick, tctx->tlsext_tick_key_name, 16))
2323             return 2;
2324         HMAC_Init_ex(&hctx, tctx->tlsext_tick_hmac_key, 16,
2325                      tlsext_tick_md(), NULL);
2326         EVP_DecryptInit_ex(&ctx, EVP_aes_128_cbc(), NULL,
2327                            tctx->tlsext_tick_aes_key, etick + 16);
2328     }
2329     /*
2330      * Attempt to process session ticket, first conduct sanity and integrity
2331      * checks on ticket.
2332      */
2333     mlen = HMAC_size(&hctx);
2334     if (mlen < 0) {
2335         EVP_CIPHER_CTX_cleanup(&ctx);
2336         return -1;
2337     }
2338     eticklen -= mlen;
2339     /* Check HMAC of encrypted ticket */
2340     HMAC_Update(&hctx, etick, eticklen);
2341     HMAC_Final(&hctx, tick_hmac, NULL);
2342     HMAC_CTX_cleanup(&hctx);
2343     if (CRYPTO_memcmp(tick_hmac, etick + eticklen, mlen)) {
2344         EVP_CIPHER_CTX_cleanup(&ctx);
2345         return 2;
2346     }
2347     /* Attempt to decrypt session data */
2348     /* Move p after IV to start of encrypted ticket, update length */
2349     p = etick + 16 + EVP_CIPHER_CTX_iv_length(&ctx);
2350     eticklen -= 16 + EVP_CIPHER_CTX_iv_length(&ctx);
2351     sdec = OPENSSL_malloc(eticklen);
2352     if (!sdec) {
2353         EVP_CIPHER_CTX_cleanup(&ctx);
2354         return -1;
2355     }
2356     EVP_DecryptUpdate(&ctx, sdec, &slen, p, eticklen);
2357     if (EVP_DecryptFinal(&ctx, sdec + slen, &mlen) <= 0) {
2358         EVP_CIPHER_CTX_cleanup(&ctx);
2359         OPENSSL_free(sdec);
2360         return 2;
2361     }
2362     slen += mlen;
2363     EVP_CIPHER_CTX_cleanup(&ctx);
2364     p = sdec;
2365
2366     sess = d2i_SSL_SESSION(NULL, &p, slen);
2367     OPENSSL_free(sdec);
2368     if (sess) {
2369         /*
2370          * The session ID, if non-empty, is used by some clients to detect
2371          * that the ticket has been accepted. So we copy it to the session
2372          * structure. If it is empty set length to zero as required by
2373          * standard.
2374          */
2375         if (sesslen)
2376             memcpy(sess->session_id, sess_id, sesslen);
2377         sess->session_id_length = sesslen;
2378         *psess = sess;
2379         if (renew_ticket)
2380             return 4;
2381         else
2382             return 3;
2383     }
2384     ERR_clear_error();
2385     /*
2386      * For session parse failure, indicate that we need to send a new ticket.
2387      */
2388     return 2;
2389 }
2390
2391 /* Tables to translate from NIDs to TLS v1.2 ids */
2392
2393 typedef struct {
2394     int nid;
2395     int id;
2396 } tls12_lookup;
2397
2398 static tls12_lookup tls12_md[] = {
2399 # ifndef OPENSSL_NO_MD5
2400     {NID_md5, TLSEXT_hash_md5},
2401 # endif
2402 # ifndef OPENSSL_NO_SHA
2403     {NID_sha1, TLSEXT_hash_sha1},
2404 # endif
2405 # ifndef OPENSSL_NO_SHA256
2406     {NID_sha224, TLSEXT_hash_sha224},
2407     {NID_sha256, TLSEXT_hash_sha256},
2408 # endif
2409 # ifndef OPENSSL_NO_SHA512
2410     {NID_sha384, TLSEXT_hash_sha384},
2411     {NID_sha512, TLSEXT_hash_sha512}
2412 # endif
2413 };
2414
2415 static tls12_lookup tls12_sig[] = {
2416 # ifndef OPENSSL_NO_RSA
2417     {EVP_PKEY_RSA, TLSEXT_signature_rsa},
2418 # endif
2419 # ifndef OPENSSL_NO_DSA
2420     {EVP_PKEY_DSA, TLSEXT_signature_dsa},
2421 # endif
2422 # ifndef OPENSSL_NO_ECDSA
2423     {EVP_PKEY_EC, TLSEXT_signature_ecdsa}
2424 # endif
2425 };
2426
2427 static int tls12_find_id(int nid, tls12_lookup *table, size_t tlen)
2428 {
2429     size_t i;
2430     for (i = 0; i < tlen; i++) {
2431         if (table[i].nid == nid)
2432             return table[i].id;
2433     }
2434     return -1;
2435 }
2436
2437 # if 0
2438 static int tls12_find_nid(int id, tls12_lookup *table, size_t tlen)
2439 {
2440     size_t i;
2441     for (i = 0; i < tlen; i++) {
2442         if (table[i].id == id)
2443             return table[i].nid;
2444     }
2445     return -1;
2446 }
2447 # endif
2448
2449 int tls12_get_sigandhash(unsigned char *p, const EVP_PKEY *pk,
2450                          const EVP_MD *md)
2451 {
2452     int sig_id, md_id;
2453     if (!md)
2454         return 0;
2455     md_id = tls12_find_id(EVP_MD_type(md), tls12_md,
2456                           sizeof(tls12_md) / sizeof(tls12_lookup));
2457     if (md_id == -1)
2458         return 0;
2459     sig_id = tls12_get_sigid(pk);
2460     if (sig_id == -1)
2461         return 0;
2462     p[0] = (unsigned char)md_id;
2463     p[1] = (unsigned char)sig_id;
2464     return 1;
2465 }
2466
2467 int tls12_get_sigid(const EVP_PKEY *pk)
2468 {
2469     return tls12_find_id(pk->type, tls12_sig,
2470                          sizeof(tls12_sig) / sizeof(tls12_lookup));
2471 }
2472
2473 const EVP_MD *tls12_get_hash(unsigned char hash_alg)
2474 {
2475     switch (hash_alg) {
2476 # ifndef OPENSSL_NO_SHA
2477     case TLSEXT_hash_sha1:
2478         return EVP_sha1();
2479 # endif
2480 # ifndef OPENSSL_NO_SHA256
2481     case TLSEXT_hash_sha224:
2482         return EVP_sha224();
2483
2484     case TLSEXT_hash_sha256:
2485         return EVP_sha256();
2486 # endif
2487 # ifndef OPENSSL_NO_SHA512
2488     case TLSEXT_hash_sha384:
2489         return EVP_sha384();
2490
2491     case TLSEXT_hash_sha512:
2492         return EVP_sha512();
2493 # endif
2494     default:
2495         return NULL;
2496
2497     }
2498 }
2499
2500 /* Set preferred digest for each key type */
2501
2502 int tls1_process_sigalgs(SSL *s, const unsigned char *data, int dsize)
2503 {
2504     int i, idx;
2505     const EVP_MD *md;
2506     CERT *c = s->cert;
2507     /* Extension ignored for TLS versions below 1.2 */
2508     if (TLS1_get_version(s) < TLS1_2_VERSION)
2509         return 1;
2510     /* Should never happen */
2511     if (!c)
2512         return 0;
2513
2514     c->pkeys[SSL_PKEY_DSA_SIGN].digest = NULL;
2515     c->pkeys[SSL_PKEY_RSA_SIGN].digest = NULL;
2516     c->pkeys[SSL_PKEY_RSA_ENC].digest = NULL;
2517     c->pkeys[SSL_PKEY_ECC].digest = NULL;
2518
2519     for (i = 0; i < dsize; i += 2) {
2520         unsigned char hash_alg = data[i], sig_alg = data[i + 1];
2521
2522         switch (sig_alg) {
2523 # ifndef OPENSSL_NO_RSA
2524         case TLSEXT_signature_rsa:
2525             idx = SSL_PKEY_RSA_SIGN;
2526             break;
2527 # endif
2528 # ifndef OPENSSL_NO_DSA
2529         case TLSEXT_signature_dsa:
2530             idx = SSL_PKEY_DSA_SIGN;
2531             break;
2532 # endif
2533 # ifndef OPENSSL_NO_ECDSA
2534         case TLSEXT_signature_ecdsa:
2535             idx = SSL_PKEY_ECC;
2536             break;
2537 # endif
2538         default:
2539             continue;
2540         }
2541
2542         if (c->pkeys[idx].digest == NULL) {
2543             md = tls12_get_hash(hash_alg);
2544             if (md) {
2545                 c->pkeys[idx].digest = md;
2546                 if (idx == SSL_PKEY_RSA_SIGN)
2547                     c->pkeys[SSL_PKEY_RSA_ENC].digest = md;
2548             }
2549         }
2550
2551     }
2552
2553     /*
2554      * Set any remaining keys to default values. NOTE: if alg is not
2555      * supported it stays as NULL.
2556      */
2557 # ifndef OPENSSL_NO_DSA
2558     if (!c->pkeys[SSL_PKEY_DSA_SIGN].digest)
2559         c->pkeys[SSL_PKEY_DSA_SIGN].digest = EVP_sha1();
2560 # endif
2561 # ifndef OPENSSL_NO_RSA
2562     if (!c->pkeys[SSL_PKEY_RSA_SIGN].digest) {
2563         c->pkeys[SSL_PKEY_RSA_SIGN].digest = EVP_sha1();
2564         c->pkeys[SSL_PKEY_RSA_ENC].digest = EVP_sha1();
2565     }
2566 # endif
2567 # ifndef OPENSSL_NO_ECDSA
2568     if (!c->pkeys[SSL_PKEY_ECC].digest)
2569         c->pkeys[SSL_PKEY_ECC].digest = EVP_sha1();
2570 # endif
2571     return 1;
2572 }
2573
2574 #endif
2575
2576 #ifndef OPENSSL_NO_HEARTBEATS
2577 int tls1_process_heartbeat(SSL *s)
2578 {
2579     unsigned char *p = &s->s3->rrec.data[0], *pl;
2580     unsigned short hbtype;
2581     unsigned int payload;
2582     unsigned int padding = 16;  /* Use minimum padding */
2583
2584     if (s->msg_callback)
2585         s->msg_callback(0, s->version, TLS1_RT_HEARTBEAT,
2586                         &s->s3->rrec.data[0], s->s3->rrec.length,
2587                         s, s->msg_callback_arg);
2588
2589     /* Read type and payload length first */
2590     if (1 + 2 + 16 > s->s3->rrec.length)
2591         return 0;               /* silently discard */
2592     hbtype = *p++;
2593     n2s(p, payload);
2594     if (1 + 2 + payload + 16 > s->s3->rrec.length)
2595         return 0;               /* silently discard per RFC 6520 sec. 4 */
2596     pl = p;
2597
2598     if (hbtype == TLS1_HB_REQUEST) {
2599         unsigned char *buffer, *bp;
2600         int r;
2601
2602         /*
2603          * Allocate memory for the response, size is 1 bytes message type,
2604          * plus 2 bytes payload length, plus payload, plus padding
2605          */
2606         buffer = OPENSSL_malloc(1 + 2 + payload + padding);
2607         bp = buffer;
2608
2609         /* Enter response type, length and copy payload */
2610         *bp++ = TLS1_HB_RESPONSE;
2611         s2n(payload, bp);
2612         memcpy(bp, pl, payload);
2613         bp += payload;
2614         /* Random padding */
2615         RAND_pseudo_bytes(bp, padding);
2616
2617         r = ssl3_write_bytes(s, TLS1_RT_HEARTBEAT, buffer,
2618                              3 + payload + padding);
2619
2620         if (r >= 0 && s->msg_callback)
2621             s->msg_callback(1, s->version, TLS1_RT_HEARTBEAT,
2622                             buffer, 3 + payload + padding,
2623                             s, s->msg_callback_arg);
2624
2625         OPENSSL_free(buffer);
2626
2627         if (r < 0)
2628             return r;
2629     } else if (hbtype == TLS1_HB_RESPONSE) {
2630         unsigned int seq;
2631
2632         /*
2633          * We only send sequence numbers (2 bytes unsigned int), and 16
2634          * random bytes, so we just try to read the sequence number
2635          */
2636         n2s(pl, seq);
2637
2638         if (payload == 18 && seq == s->tlsext_hb_seq) {
2639             s->tlsext_hb_seq++;
2640             s->tlsext_hb_pending = 0;
2641         }
2642     }
2643
2644     return 0;
2645 }
2646
2647 int tls1_heartbeat(SSL *s)
2648 {
2649     unsigned char *buf, *p;
2650     int ret;
2651     unsigned int payload = 18;  /* Sequence number + random bytes */
2652     unsigned int padding = 16;  /* Use minimum padding */
2653
2654     /* Only send if peer supports and accepts HB requests... */
2655     if (!(s->tlsext_heartbeat & SSL_TLSEXT_HB_ENABLED) ||
2656         s->tlsext_heartbeat & SSL_TLSEXT_HB_DONT_SEND_REQUESTS) {
2657         SSLerr(SSL_F_TLS1_HEARTBEAT, SSL_R_TLS_HEARTBEAT_PEER_DOESNT_ACCEPT);
2658         return -1;
2659     }
2660
2661     /* ...and there is none in flight yet... */
2662     if (s->tlsext_hb_pending) {
2663         SSLerr(SSL_F_TLS1_HEARTBEAT, SSL_R_TLS_HEARTBEAT_PENDING);
2664         return -1;
2665     }
2666
2667     /* ...and no handshake in progress. */
2668     if (SSL_in_init(s) || s->in_handshake) {
2669         SSLerr(SSL_F_TLS1_HEARTBEAT, SSL_R_UNEXPECTED_MESSAGE);
2670         return -1;
2671     }
2672
2673     /*
2674      * Check if padding is too long, payload and padding must not exceed 2^14
2675      * - 3 = 16381 bytes in total.
2676      */
2677     OPENSSL_assert(payload + padding <= 16381);
2678
2679     /*-
2680      * Create HeartBeat message, we just use a sequence number
2681      * as payload to distuingish different messages and add
2682      * some random stuff.
2683      *  - Message Type, 1 byte
2684      *  - Payload Length, 2 bytes (unsigned int)
2685      *  - Payload, the sequence number (2 bytes uint)
2686      *  - Payload, random bytes (16 bytes uint)
2687      *  - Padding
2688      */
2689     buf = OPENSSL_malloc(1 + 2 + payload + padding);
2690     p = buf;
2691     /* Message Type */
2692     *p++ = TLS1_HB_REQUEST;
2693     /* Payload length (18 bytes here) */
2694     s2n(payload, p);
2695     /* Sequence number */
2696     s2n(s->tlsext_hb_seq, p);
2697     /* 16 random bytes */
2698     RAND_pseudo_bytes(p, 16);
2699     p += 16;
2700     /* Random padding */
2701     RAND_pseudo_bytes(p, padding);
2702
2703     ret = ssl3_write_bytes(s, TLS1_RT_HEARTBEAT, buf, 3 + payload + padding);
2704     if (ret >= 0) {
2705         if (s->msg_callback)
2706             s->msg_callback(1, s->version, TLS1_RT_HEARTBEAT,
2707                             buf, 3 + payload + padding,
2708                             s, s->msg_callback_arg);
2709
2710         s->tlsext_hb_pending = 1;
2711     }
2712
2713     OPENSSL_free(buf);
2714
2715     return ret;
2716 }
2717 #endif