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