ssl/s3_srvr.c

   1 /* ssl/s3_srvr.c -*- mode:C; c-file-style: "eay" -*- */
   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  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
 113  *
 114  * Portions of the attached software ("Contribution") are developed by
 115  * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
 116  *
 117  * The Contribution is licensed pursuant to the OpenSSL open source
 118  * license provided above.
 119  *
 120  * ECC cipher suite support in OpenSSL originally written by
 121  * Vipul Gupta and Sumit Gupta of Sun Microsystems Laboratories.
 122  *
 123  */
 124 /* ====================================================================
 125  * Copyright 2005 Nokia. All rights reserved.
 126  *
 127  * The portions of the attached software ("Contribution") is developed by
 128  * Nokia Corporation and is licensed pursuant to the OpenSSL open source
 129  * license.
 130  *
 131  * The Contribution, originally written by Mika Kousa and Pasi Eronen of
 132  * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
 133  * support (see RFC 4279) to OpenSSL.
 134  *
 135  * No patent licenses or other rights except those expressly stated in
 136  * the OpenSSL open source license shall be deemed granted or received
 137  * expressly, by implication, estoppel, or otherwise.
 138  *
 139  * No assurances are provided by Nokia that the Contribution does not
 140  * infringe the patent or other intellectual property rights of any third
 141  * party or that the license provides you with all the necessary rights
 142  * to make use of the Contribution.
 143  *
 144  * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
 145  * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
 146  * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
 147  * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
 148  * OTHERWISE.
 149  */
 150
 151
 152 #include <stdio.h>
 153 #include "ssl_locl.h"
 154 #include "internal/constant_time_locl.h"
 155 #include <openssl/buffer.h>
 156 #include <openssl/rand.h>
 157 #include <openssl/objects.h>
 158 #include <openssl/evp.h>
 159 #include <openssl/hmac.h>
 160 #include <openssl/x509.h>
 161 #ifndef OPENSSL_NO_DH
 162 # include <openssl/dh.h>
 163 #endif
 164 #include <openssl/bn.h>
 165 #include <openssl/md5.h>
 166
 167 static STACK_OF(SSL_CIPHER) *ssl_bytes_to_cipher_list(SSL *s,
 168                                                       PACKET *cipher_suites,
 169                                                       STACK_OF(SSL_CIPHER) **skp,
 170                                                       int sslv2format, int *al);
 171
 172 #ifndef OPENSSL_NO_SRP
 173 static int ssl_check_srp_ext_ClientHello(SSL *s, int *al)
 174 {
 175     int ret = SSL_ERROR_NONE;
 176
 177     *al = SSL_AD_UNRECOGNIZED_NAME;
 178
 179     if ((s->s3->tmp.new_cipher->algorithm_mkey & SSL_kSRP) &&
 180         (s->srp_ctx.TLS_ext_srp_username_callback != NULL)) {
 181         if (s->srp_ctx.login == NULL) {
 182             /*
 183              * RFC 5054 says SHOULD reject, we do so if There is no srp
 184              * login name
 185              */
 186             ret = SSL3_AL_FATAL;
 187             *al = SSL_AD_UNKNOWN_PSK_IDENTITY;
 188         } else {
 189             ret = SSL_srp_server_param_with_username(s, al);
 190         }
 191     }
 192     return ret;
 193 }
 194 #endif
 195
 196 int ssl3_accept(SSL *s)
 197 {
 198     BUF_MEM *buf;
 199     unsigned long alg_k, Time = (unsigned long)time(NULL);
 200     void (*cb) (const SSL *ssl, int type, int val) = NULL;
 201     int ret = -1;
 202     int new_state, state, skip = 0;
 203
 204     RAND_add(&Time, sizeof(Time), 0);
 205     ERR_clear_error();
 206     clear_sys_error();
 207
 208     if (s->info_callback != NULL)
 209         cb = s->info_callback;
 210     else if (s->ctx->info_callback != NULL)
 211         cb = s->ctx->info_callback;
 212
 213     /* init things to blank */
 214     s->in_handshake++;
 215     if (!SSL_in_init(s) || SSL_in_before(s)) {
 216         if (!SSL_clear(s))
 217             return -1;
 218     }
 219
 220 #ifndef OPENSSL_NO_HEARTBEATS
 221     /*
 222      * If we're awaiting a HeartbeatResponse, pretend we already got and
 223      * don't await it anymore, because Heartbeats don't make sense during
 224      * handshakes anyway.
 225      */
 226     if (s->tlsext_hb_pending) {
 227         s->tlsext_hb_pending = 0;
 228         s->tlsext_hb_seq++;
 229     }
 230 #endif
 231
 232     for (;;) {
 233         state = s->state;
 234
 235         switch (s->state) {
 236         case SSL_ST_RENEGOTIATE:
 237             s->renegotiate = 1;
 238             /* s->state=SSL_ST_ACCEPT; */
 239
 240         case SSL_ST_BEFORE:
 241         case SSL_ST_ACCEPT:
 242         case SSL_ST_BEFORE | SSL_ST_ACCEPT:
 243         case SSL_ST_OK | SSL_ST_ACCEPT:
 244
 245             s->server = 1;
 246             if (cb != NULL)
 247                 cb(s, SSL_CB_HANDSHAKE_START, 1);
 248
 249             if ((s->version >> 8 != 3) && s->version != TLS_ANY_VERSION) {
 250                 SSLerr(SSL_F_SSL3_ACCEPT, ERR_R_INTERNAL_ERROR);
 251                 s->state = SSL_ST_ERR;
 252                 return -1;
 253             }
 254
 255             if (!ssl_security(s, SSL_SECOP_VERSION, 0, s->version, NULL)) {
 256                 SSLerr(SSL_F_SSL3_ACCEPT, SSL_R_VERSION_TOO_LOW);
 257                 return -1;
 258             }
 259
 260             s->type = SSL_ST_ACCEPT;
 261
 262             if (s->init_buf == NULL) {
 263                 if ((buf = BUF_MEM_new()) == NULL) {
 264                     ret = -1;
 265                     s->state = SSL_ST_ERR;
 266                     goto end;
 267                 }
 268                 if (!BUF_MEM_grow(buf, SSL3_RT_MAX_PLAIN_LENGTH)) {
 269                     BUF_MEM_free(buf);
 270                     ret = -1;
 271                     s->state = SSL_ST_ERR;
 272                     goto end;
 273                 }
 274                 s->init_buf = buf;
 275             }
 276
 277             if (!ssl3_setup_buffers(s)) {
 278                 ret = -1;
 279                 s->state = SSL_ST_ERR;
 280                 goto end;
 281             }
 282
 283             s->init_num = 0;
 284             s->s3->flags &= ~TLS1_FLAGS_SKIP_CERT_VERIFY;
 285             /*
 286              * Should have been reset by ssl3_get_finished, too.
 287              */
 288             s->s3->change_cipher_spec = 0;
 289
 290             if (s->state != SSL_ST_RENEGOTIATE) {
 291                 /*
 292                  * Ok, we now need to push on a buffering BIO so that the
 293                  * output is sent in a way that TCP likes :-)
 294                  */
 295                 if (!ssl_init_wbio_buffer(s, 1)) {
 296                     ret = -1;
 297                     s->state = SSL_ST_ERR;
 298                     goto end;
 299                 }
 300
 301                 ssl3_init_finished_mac(s);
 302                 s->state = SSL3_ST_SR_CLNT_HELLO_A;
 303                 s->ctx->stats.sess_accept++;
 304             } else if (!s->s3->send_connection_binding &&
 305                        !(s->options &
 306                          SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)) {
 307                 /*
 308                  * Server attempting to renegotiate with client that doesn't
 309                  * support secure renegotiation.
 310                  */
 311                 SSLerr(SSL_F_SSL3_ACCEPT,
 312                        SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
 313                 ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_HANDSHAKE_FAILURE);
 314                 ret = -1;
 315                 s->state = SSL_ST_ERR;
 316                 goto end;
 317             } else {
 318                 /*
 319                  * s->state == SSL_ST_RENEGOTIATE, we will just send a
 320                  * HelloRequest
 321                  */
 322                 s->ctx->stats.sess_accept_renegotiate++;
 323                 s->state = SSL3_ST_SW_HELLO_REQ_A;
 324             }
 325             break;
 326
 327         case SSL3_ST_SW_HELLO_REQ_A:
 328         case SSL3_ST_SW_HELLO_REQ_B:
 329
 330             s->shutdown = 0;
 331             ret = ssl3_send_hello_request(s);
 332             if (ret <= 0)
 333                 goto end;
 334             s->s3->tmp.next_state = SSL3_ST_SW_HELLO_REQ_C;
 335             s->state = SSL3_ST_SW_FLUSH;
 336             s->init_num = 0;
 337
 338             ssl3_init_finished_mac(s);
 339             break;
 340
 341         case SSL3_ST_SW_HELLO_REQ_C:
 342             s->state = SSL_ST_OK;
 343             break;
 344
 345         case SSL3_ST_SR_CLNT_HELLO_A:
 346         case SSL3_ST_SR_CLNT_HELLO_B:
 347         case SSL3_ST_SR_CLNT_HELLO_C:
 348
 349             ret = ssl3_get_client_hello(s);
 350             if (ret <= 0)
 351                 goto end;
 352
 353             s->state = SSL3_ST_SW_SRVR_HELLO_A;
 354             s->init_num = 0;
 355             break;
 356
 357 #ifndef OPENSSL_NO_SRP
 358         case SSL3_ST_SR_CLNT_HELLO_D:
 359             {
 360                 enum WORK_STATE wst_ret;
 361
 362                 wst_ret = tls_post_process_client_hello(s, WORK_MORE_B);
 363                 if (wst_ret == WORK_MORE_B)
 364                     goto end;
 365                 if (wst_ret == WORK_ERROR) {
 366                     ret = -1;
 367                     goto end;
 368                 }
 369             }
 370
 371             s->state = SSL3_ST_SW_SRVR_HELLO_A;
 372             s->init_num = 0;
 373             break;
 374 #endif
 375
 376         case SSL3_ST_SW_SRVR_HELLO_A:
 377         case SSL3_ST_SW_SRVR_HELLO_B:
 378             ret = ssl3_send_server_hello(s);
 379             if (ret <= 0)
 380                 goto end;
 381
 382             if (s->hit) {
 383                 if (s->tlsext_ticket_expected)
 384                     s->state = SSL3_ST_SW_SESSION_TICKET_A;
 385                 else
 386                     s->state = SSL3_ST_SW_CHANGE_A;
 387             } else {
 388                 s->state = SSL3_ST_SW_CERT_A;
 389             }
 390             s->init_num = 0;
 391             break;
 392
 393         case SSL3_ST_SW_CERT_A:
 394         case SSL3_ST_SW_CERT_B:
 395             /* Check if it is anon DH or anon ECDH, */
 396             /* normal PSK or SRP */
 397             if (!(s->s3->tmp.new_cipher->algorithm_auth &
 398                  (SSL_aNULL | SSL_aSRP | SSL_aPSK))) {
 399                 ret = ssl3_send_server_certificate(s);
 400                 if (ret <= 0)
 401                     goto end;
 402
 403                 if (s->tlsext_status_expected)
 404                     s->state = SSL3_ST_SW_CERT_STATUS_A;
 405                 else
 406                     s->state = SSL3_ST_SW_KEY_EXCH_A;
 407             } else {
 408                 skip = 1;
 409                 s->state = SSL3_ST_SW_KEY_EXCH_A;
 410             }
 411             s->init_num = 0;
 412             break;
 413
 414         case SSL3_ST_SW_KEY_EXCH_A:
 415         case SSL3_ST_SW_KEY_EXCH_B:
 416             alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
 417
 418             /*
 419              * clear this, it may get reset by
 420              * send_server_key_exchange
 421              */
 422             s->s3->tmp.use_rsa_tmp = 0;
 423
 424             /*
 425              * only send if a DH key exchange, fortezza or RSA but we have a
 426              * sign only certificate PSK: may send PSK identity hints For
 427              * ECC ciphersuites, we send a serverKeyExchange message only if
 428              * the cipher suite is either ECDH-anon or ECDHE. In other cases,
 429              * the server certificate contains the server's public key for
 430              * key exchange.
 431              */
 432             if (0
 433                 /*
 434                  * PSK: send ServerKeyExchange if PSK identity hint if
 435                  * provided
 436                  */
 437 #ifndef OPENSSL_NO_PSK
 438                 /* Only send SKE if we have identity hint for plain PSK */
 439                 || ((alg_k & (SSL_kPSK | SSL_kRSAPSK)) && s->cert->psk_identity_hint)
 440                 /* For other PSK always send SKE */
 441                 || (alg_k & (SSL_PSK & (SSL_kDHEPSK | SSL_kECDHEPSK)))
 442 #endif
 443 #ifndef OPENSSL_NO_SRP
 444                 /* SRP: send ServerKeyExchange */
 445                 || (alg_k & SSL_kSRP)
 446 #endif
 447                 || (alg_k & SSL_kDHE)
 448                 || (alg_k & SSL_kECDHE)
 449                 || ((alg_k & SSL_kRSA)
 450                     && (s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey == NULL
 451                         || (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher)
 452                             && EVP_PKEY_size(s->cert->pkeys
 453                                              [SSL_PKEY_RSA_ENC].privatekey) *
 454                             8 > SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher)
 455                         )
 456                     )
 457                 )
 458                 ) {
 459                 ret = ssl3_send_server_key_exchange(s);
 460                 if (ret <= 0)
 461                     goto end;
 462             } else
 463                 skip = 1;
 464
 465             s->state = SSL3_ST_SW_CERT_REQ_A;
 466             s->init_num = 0;
 467             break;
 468
 469         case SSL3_ST_SW_CERT_REQ_A:
 470         case SSL3_ST_SW_CERT_REQ_B:
 471             if (                /* don't request cert unless asked for it: */
 472                    !(s->verify_mode & SSL_VERIFY_PEER) ||
 473                    /*
 474                     * if SSL_VERIFY_CLIENT_ONCE is set, don't request cert
 475                     * during re-negotiation:
 476                     */
 477                    ((s->session->peer != NULL) &&
 478                     (s->verify_mode & SSL_VERIFY_CLIENT_ONCE)) ||
 479                    /*
 480                     * never request cert in anonymous ciphersuites (see
 481                     * section "Certificate request" in SSL 3 drafts and in
 482                     * RFC 2246):
 483                     */
 484                    ((s->s3->tmp.new_cipher->algorithm_auth & SSL_aNULL) &&
 485                    /*
 486                     * ... except when the application insists on
 487                     * verification (against the specs, but s3_clnt.c accepts
 488                     * this for SSL 3)
 489                     */
 490                    !(s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) ||
 491                    /* don't request certificate for SRP auth */
 492                    (s->s3->tmp.new_cipher->algorithm_auth & SSL_aSRP)
 493                    /*
 494                     * With normal PSK Certificates and Certificate Requests
 495                     * are omitted
 496                     */
 497                    || (s->s3->tmp.new_cipher->algorithm_mkey & SSL_PSK)) {
 498                 /* no cert request */
 499                 skip = 1;
 500                 s->s3->tmp.cert_request = 0;
 501                 s->state = SSL3_ST_SW_SRVR_DONE_A;
 502                 if (!ssl3_digest_cached_records(s, 0)) {
 503                     s->state = SSL_ST_ERR;
 504                     return -1;
 505                 }
 506             } else {
 507                 s->s3->tmp.cert_request = 1;
 508                 ret = ssl3_send_certificate_request(s);
 509                 if (ret <= 0)
 510                     goto end;
 511                 s->state = SSL3_ST_SW_SRVR_DONE_A;
 512                 s->init_num = 0;
 513             }
 514             break;
 515
 516         case SSL3_ST_SW_SRVR_DONE_A:
 517         case SSL3_ST_SW_SRVR_DONE_B:
 518             ret = ssl3_send_server_done(s);
 519             if (ret <= 0)
 520                 goto end;
 521             s->s3->tmp.next_state = SSL3_ST_SR_CERT_A;
 522             s->state = SSL3_ST_SW_FLUSH;
 523             s->init_num = 0;
 524             break;
 525
 526         case SSL3_ST_SW_FLUSH:
 527
 528             /*
 529              * This code originally checked to see if any data was pending
 530              * using BIO_CTRL_INFO and then flushed. This caused problems as
 531              * documented in PR#1939. The proposed fix doesn't completely
 532              * resolve this issue as buggy implementations of
 533              * BIO_CTRL_PENDING still exist. So instead we just flush
 534              * unconditionally.
 535              */
 536
 537             s->rwstate = SSL_WRITING;
 538             if (BIO_flush(s->wbio) <= 0) {
 539                 ret = -1;
 540                 goto end;
 541             }
 542             s->rwstate = SSL_NOTHING;
 543
 544             s->state = s->s3->tmp.next_state;
 545             break;
 546
 547         case SSL3_ST_SR_CERT_A:
 548         case SSL3_ST_SR_CERT_B:
 549             if (s->s3->tmp.cert_request) {
 550                 ret = ssl3_get_client_certificate(s);
 551                 if (ret <= 0)
 552                     goto end;
 553             }
 554             s->init_num = 0;
 555             s->state = SSL3_ST_SR_KEY_EXCH_A;
 556             break;
 557
 558         case SSL3_ST_SR_KEY_EXCH_A:
 559         case SSL3_ST_SR_KEY_EXCH_B:
 560             ret = ssl3_get_client_key_exchange(s);
 561             if (ret <= 0)
 562                 goto end;
 563             if (s->no_cert_verify) {
 564                 /*
 565                  * For the ECDH ciphersuites when the client sends its ECDH
 566                  * pub key in a certificate, the CertificateVerify message is
 567                  * not sent. Also for GOST ciphersuites when the client uses
 568                  * its key from the certificate for key exchange.
 569                  */
 570                 s->state = SSL3_ST_SR_CHANGE_A;
 571                 s->init_num = 0;
 572             } else if (SSL_USE_SIGALGS(s)) {
 573                 s->state = SSL3_ST_SR_CERT_VRFY_A;
 574                 s->init_num = 0;
 575                 if (!s->session->peer)
 576                     break;
 577                 if (!s->s3->handshake_buffer) {
 578                     SSLerr(SSL_F_SSL3_ACCEPT, ERR_R_INTERNAL_ERROR);
 579                     s->state = SSL_ST_ERR;
 580                     return -1;
 581                 }
 582                 /*
 583                  * For sigalgs freeze the handshake buffer. If we support
 584                  * extms we've done this already so this is a no-op
 585                  */
 586                 if (!ssl3_digest_cached_records(s, 1)) {
 587                     s->state = SSL_ST_ERR;
 588                     return -1;
 589                 }
 590             } else {
 591                 int offset = 0;
 592                 int dgst_num;
 593
 594                 s->state = SSL3_ST_SR_CERT_VRFY_A;
 595                 s->init_num = 0;
 596
 597                 /*
 598                  * We need to get hashes here so if there is a client cert,
 599                  * it can be verified FIXME - digest processing for
 600                  * CertificateVerify should be generalized. But it is next
 601                  * step
 602                  */
 603                 if (!ssl3_digest_cached_records(s, 0)) {
 604                     s->state = SSL_ST_ERR;
 605                     return -1;
 606                 }
 607                 for (dgst_num = 0; dgst_num < SSL_MAX_DIGEST; dgst_num++)
 608                     if (s->s3->handshake_dgst[dgst_num]) {
 609                         int dgst_size;
 610
 611                         s->method->ssl3_enc->cert_verify_mac(s,
 612                                                              EVP_MD_CTX_type
 613                                                              (s->
 614                                                               s3->handshake_dgst
 615                                                               [dgst_num]),
 616                                                              &(s->s3->
 617                                                                tmp.cert_verify_md
 618                                                                [offset]));
 619                         dgst_size =
 620                             EVP_MD_CTX_size(s->s3->handshake_dgst[dgst_num]);
 621                         if (dgst_size < 0) {
 622                             s->state = SSL_ST_ERR;
 623                             ret = -1;
 624                             goto end;
 625                         }
 626                         offset += dgst_size;
 627                     }
 628             }
 629             break;
 630
 631         case SSL3_ST_SR_CERT_VRFY_A:
 632         case SSL3_ST_SR_CERT_VRFY_B:
 633             ret = ssl3_get_cert_verify(s);
 634             if (ret <= 0)
 635                 goto end;
 636
 637             s->state = SSL3_ST_SR_CHANGE_A;
 638             s->init_num = 0;
 639             break;
 640
 641 #if !defined(OPENSSL_NO_NEXTPROTONEG)
 642         case SSL3_ST_SR_NEXT_PROTO_A:
 643         case SSL3_ST_SR_NEXT_PROTO_B:
 644             ret = ssl3_get_next_proto(s);
 645             if (ret <= 0)
 646                 goto end;
 647             s->init_num = 0;
 648             s->state = SSL3_ST_SR_FINISHED_A;
 649             break;
 650 #endif
 651
 652
 653         case SSL3_ST_SR_CHANGE_A:
 654         case SSL3_ST_SR_CHANGE_B:
 655             ret = ssl3_get_change_cipher_spec(s, SSL3_ST_SR_CHANGE_A,
 656                                               SSL3_ST_SR_CHANGE_B);
 657             if (ret <= 0)
 658                 goto end;
 659
 660 #if defined(OPENSSL_NO_NEXTPROTONEG)
 661             s->state = SSL3_ST_SR_FINISHED_A;
 662 #else
 663             if (s->s3->next_proto_neg_seen)
 664                 s->state = SSL3_ST_SR_NEXT_PROTO_A;
 665             else
 666                 s->state = SSL3_ST_SR_FINISHED_A;
 667 #endif
 668             s->init_num = 0;
 669             break;
 670
 671         case SSL3_ST_SR_FINISHED_A:
 672         case SSL3_ST_SR_FINISHED_B:
 673             ret = ssl3_get_finished(s, SSL3_ST_SR_FINISHED_A,
 674                                     SSL3_ST_SR_FINISHED_B);
 675             if (ret <= 0)
 676                 goto end;
 677             if (s->hit)
 678                 s->state = SSL_ST_OK;
 679             else if (s->tlsext_ticket_expected)
 680                 s->state = SSL3_ST_SW_SESSION_TICKET_A;
 681             else
 682                 s->state = SSL3_ST_SW_CHANGE_A;
 683             s->init_num = 0;
 684             break;
 685
 686         case SSL3_ST_SW_SESSION_TICKET_A:
 687         case SSL3_ST_SW_SESSION_TICKET_B:
 688             ret = ssl3_send_newsession_ticket(s);
 689             if (ret <= 0)
 690                 goto end;
 691             s->state = SSL3_ST_SW_CHANGE_A;
 692             s->init_num = 0;
 693             break;
 694
 695         case SSL3_ST_SW_CERT_STATUS_A:
 696         case SSL3_ST_SW_CERT_STATUS_B:
 697             ret = ssl3_send_cert_status(s);
 698             if (ret <= 0)
 699                 goto end;
 700             s->state = SSL3_ST_SW_KEY_EXCH_A;
 701             s->init_num = 0;
 702             break;
 703
 704         case SSL3_ST_SW_CHANGE_A:
 705         case SSL3_ST_SW_CHANGE_B:
 706
 707             s->session->cipher = s->s3->tmp.new_cipher;
 708             if (!s->method->ssl3_enc->setup_key_block(s)) {
 709                 ret = -1;
 710                 s->state = SSL_ST_ERR;
 711                 goto end;
 712             }
 713
 714             ret = ssl3_send_change_cipher_spec(s,
 715                                                SSL3_ST_SW_CHANGE_A,
 716                                                SSL3_ST_SW_CHANGE_B);
 717
 718             if (ret <= 0)
 719                 goto end;
 720             s->state = SSL3_ST_SW_FINISHED_A;
 721             s->init_num = 0;
 722
 723             if (!s->method->ssl3_enc->change_cipher_state(s,
 724                                                           SSL3_CHANGE_CIPHER_SERVER_WRITE))
 725             {
 726                 ret = -1;
 727                 s->state = SSL_ST_ERR;
 728                 goto end;
 729             }
 730
 731             break;
 732
 733         case SSL3_ST_SW_FINISHED_A:
 734         case SSL3_ST_SW_FINISHED_B:
 735             ret = ssl3_send_finished(s,
 736                                      SSL3_ST_SW_FINISHED_A,
 737                                      SSL3_ST_SW_FINISHED_B,
 738                                      s->method->
 739                                      ssl3_enc->server_finished_label,
 740                                      s->method->
 741                                      ssl3_enc->server_finished_label_len);
 742             if (ret <= 0)
 743                 goto end;
 744             s->state = SSL3_ST_SW_FLUSH;
 745             if (s->hit) {
 746                 s->s3->tmp.next_state = SSL3_ST_SR_CHANGE_A;
 747             } else
 748                 s->s3->tmp.next_state = SSL_ST_OK;
 749             s->init_num = 0;
 750             break;
 751
 752         case SSL_ST_OK:
 753             /* clean a few things up */
 754             ssl3_cleanup_key_block(s);
 755
 756             BUF_MEM_free(s->init_buf);
 757             s->init_buf = NULL;
 758
 759             /* remove buffering on output */
 760             ssl_free_wbio_buffer(s);
 761
 762             s->init_num = 0;
 763
 764             if (s->renegotiate == 2) { /* skipped if we just sent a
 765                                         * HelloRequest */
 766                 s->renegotiate = 0;
 767                 s->new_session = 0;
 768
 769                 ssl_update_cache(s, SSL_SESS_CACHE_SERVER);
 770
 771                 s->ctx->stats.sess_accept_good++;
 772                 /* s->server=1; */
 773                 s->handshake_func = ssl3_accept;
 774
 775                 if (cb != NULL)
 776                     cb(s, SSL_CB_HANDSHAKE_DONE, 1);
 777             }
 778
 779             ret = 1;
 780             goto end;
 781             /* break; */
 782
 783         case SSL_ST_ERR:
 784         default:
 785             SSLerr(SSL_F_SSL3_ACCEPT, SSL_R_UNKNOWN_STATE);
 786             ret = -1;
 787             goto end;
 788             /* break; */
 789         }
 790
 791         if (!s->s3->tmp.reuse_message && !skip) {
 792             if (s->debug) {
 793                 if ((ret = BIO_flush(s->wbio)) <= 0)
 794                     goto end;
 795             }
 796
 797             if ((cb != NULL) && (s->state != state)) {
 798                 new_state = s->state;
 799                 s->state = state;
 800                 cb(s, SSL_CB_ACCEPT_LOOP, 1);
 801                 s->state = new_state;
 802             }
 803         }
 804         skip = 0;
 805     }
 806  end:
 807     /* BIO_flush(s->wbio); */
 808
 809     s->in_handshake--;
 810     if (cb != NULL)
 811         cb(s, SSL_CB_ACCEPT_EXIT, ret);
 812     return (ret);
 813 }
 814
 815 int ssl3_send_hello_request(SSL *s)
 816 {
 817
 818     if (s->state == SSL3_ST_SW_HELLO_REQ_A) {
 819         if (tls_construct_hello_request(s) == 0) {
 820             return -1;
 821         }
 822         s->state = SSL3_ST_SW_HELLO_REQ_B;
 823     }
 824
 825     /* SSL3_ST_SW_HELLO_REQ_B */
 826     return ssl_do_write(s);
 827 }
 828
 829 int tls_construct_hello_request(SSL *s)
 830 {
 831     if (!ssl_set_handshake_header(s, SSL3_MT_HELLO_REQUEST, 0)) {
 832         SSLerr(SSL_F_TLS_CONSTRUCT_HELLO_REQUEST, ERR_R_INTERNAL_ERROR);
 833         statem_set_error(s);
 834         return 0;
 835     }
 836
 837     return 1;
 838 }
 839
 840 int ssl3_get_client_hello(SSL *s)
 841 {
 842     int ok;
 843     long n;
 844     enum WORK_STATE wst_ret;
 845
 846     if (s->state == SSL3_ST_SR_CLNT_HELLO_C && !s->first_packet)
 847         goto retry_cert;
 848
 849     /*
 850      * We do this so that we will respond with our native type. If we are
 851      * TLSv1 and we get SSLv3, we will respond with TLSv1, This down
 852      * switching should be handled by a different method. If we are SSLv3, we
 853      * will respond with SSLv3, even if prompted with TLSv1.
 854      */
 855     if (s->state == SSL3_ST_SR_CLNT_HELLO_A) {
 856         s->state = SSL3_ST_SR_CLNT_HELLO_B;
 857     }
 858     s->first_packet = 1;
 859     n = s->method->ssl_get_message(s,
 860                                    SSL3_ST_SR_CLNT_HELLO_B,
 861                                    SSL3_ST_SR_CLNT_HELLO_C,
 862                                    SSL3_MT_CLIENT_HELLO,
 863                                    SSL3_RT_MAX_PLAIN_LENGTH, &ok);
 864
 865     if (!ok)
 866         return ((int)n);
 867     s->first_packet = 0;
 868
 869     if (tls_process_client_hello(s, n) == 0)
 870         return -1;
 871
 872  retry_cert:
 873     wst_ret = tls_post_process_client_hello(s, WORK_MORE_A);
 874     if (wst_ret == WORK_MORE_A || wst_ret == WORK_ERROR)
 875         return -1;
 876     if (wst_ret == WORK_MORE_B) {
 877         s->state = SSL3_ST_SR_CLNT_HELLO_D;
 878         return -1;
 879     }
 880     return n;
 881 }
 882
 883 enum MSG_PROCESS_RETURN tls_process_client_hello(SSL *s, long n)
 884 {
 885     int i, al = SSL_AD_INTERNAL_ERROR;
 886     unsigned int j, complen = 0;
 887     unsigned long id;
 888     SSL_CIPHER *c;
 889 #ifndef OPENSSL_NO_COMP
 890     SSL_COMP *comp = NULL;
 891 #endif
 892     STACK_OF(SSL_CIPHER) *ciphers = NULL;
 893     int protverr = 1;
 894     /* |cookie| will only be initialized for DTLS. */
 895     PACKET pkt, session_id, cipher_suites, compression, extensions, cookie;
 896     int is_v2_record;
 897
 898     if (!PACKET_buf_init(&pkt, s->init_msg, n)) {
 899         SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
 900         al = SSL_AD_INTERNAL_ERROR;
 901         goto f_err;
 902     }
 903
 904     is_v2_record = RECORD_LAYER_is_sslv2_record(&s->rlayer);
 905
 906     PACKET_null_init(&cookie);
 907     /* First lets get s->client_version set correctly */
 908     if (is_v2_record) {
 909         unsigned int version;
 910         unsigned int mt;
 911         /*-
 912          * An SSLv3/TLSv1 backwards-compatible CLIENT-HELLO in an SSLv2
 913          * header is sent directly on the wire, not wrapped as a TLS
 914          * record. Our record layer just processes the message length and passes
 915          * the rest right through. Its format is:
 916          * Byte  Content
 917          * 0-1   msg_length - decoded by the record layer
 918          * 2     msg_type - s->init_msg points here
 919          * 3-4   version
 920          * 5-6   cipher_spec_length
 921          * 7-8   session_id_length
 922          * 9-10  challenge_length
 923          * ...   ...
 924          */
 925
 926         if (!PACKET_get_1(&pkt, &mt)
 927                 || mt != SSL2_MT_CLIENT_HELLO) {
 928             /*
 929              * Should never happen. We should have tested this in the record
 930              * layer in order to have determined that this is a SSLv2 record
 931              * in the first place
 932              */
 933             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
 934             goto err;
 935         }
 936
 937         if (!PACKET_get_net_2(&pkt, &version)) {
 938             /* No protocol version supplied! */
 939             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_UNKNOWN_PROTOCOL);
 940             goto err;
 941         }
 942         if (version == 0x0002) {
 943             /* This is real SSLv2. We don't support it. */
 944             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_UNKNOWN_PROTOCOL);
 945             goto err;
 946         } else if ((version & 0xff00) == (SSL3_VERSION_MAJOR << 8)) {
 947             /* SSLv3/TLS */
 948             s->client_version = version;
 949         } else {
 950             /* No idea what protocol this is */
 951             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_UNKNOWN_PROTOCOL);
 952             goto err;
 953         }
 954     } else {
 955         /*
 956          * use version from inside client hello, not from record header (may
 957          * differ: see RFC 2246, Appendix E, second paragraph)
 958          */
 959         if(!PACKET_get_net_2(&pkt, (unsigned int *)&s->client_version)) {
 960             al = SSL_AD_DECODE_ERROR;
 961             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_LENGTH_TOO_SHORT);
 962             goto f_err;
 963         }
 964     }
 965
 966     /* Do SSL/TLS version negotiation if applicable */
 967     if (!SSL_IS_DTLS(s)) {
 968         if (s->version != TLS_ANY_VERSION) {
 969             if (s->client_version >= s->version) {
 970                 protverr = 0;
 971             }
 972         } else if (s->client_version >= SSL3_VERSION) {
 973             switch(s->client_version) {
 974             default:
 975             case TLS1_2_VERSION:
 976                 if(!(s->options & SSL_OP_NO_TLSv1_2)) {
 977                     s->version = TLS1_2_VERSION;
 978                     s->method = TLSv1_2_server_method();
 979                     protverr = 0;
 980                     break;
 981                 }
 982                 /* Deliberately fall through */
 983             case TLS1_1_VERSION:
 984                 if(!(s->options & SSL_OP_NO_TLSv1_1)) {
 985                     s->version = TLS1_1_VERSION;
 986                     s->method = TLSv1_1_server_method();
 987                     protverr = 0;
 988                     break;
 989                 }
 990                 /* Deliberately fall through */
 991             case TLS1_VERSION:
 992                 if(!(s->options & SSL_OP_NO_TLSv1)) {
 993                     s->version = TLS1_VERSION;
 994                     s->method = TLSv1_server_method();
 995                     protverr = 0;
 996                     break;
 997                 }
 998                 /* Deliberately fall through */
 999             case SSL3_VERSION:
1000 #ifndef OPENSSL_NO_SSL3
1001                 if(!(s->options & SSL_OP_NO_SSLv3)) {
1002                     s->version = SSL3_VERSION;
1003                     s->method = SSLv3_server_method();
1004                     protverr = 0;
1005                     break;
1006                 }
1007 #else
1008                 break;
1009 #endif
1010             }
1011         }
1012     } else if (s->client_version <= s->version
1013                 || s->method->version == DTLS_ANY_VERSION) {
1014         /*
1015          * For DTLS we just check versions are potentially compatible. Version
1016          * negotiation comes later.
1017          */
1018         protverr = 0;
1019     }
1020
1021     if (protverr) {
1022         SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_UNKNOWN_PROTOCOL);
1023         if ((!s->enc_write_ctx && !s->write_hash)) {
1024             /*
1025              * similar to ssl3_get_record, send alert using remote version
1026              * number
1027              */
1028             s->version = s->client_version;
1029         }
1030         al = SSL_AD_PROTOCOL_VERSION;
1031         goto f_err;
1032     }
1033
1034     /* Parse the message and load client random. */
1035     if (is_v2_record) {
1036         /*
1037          * Handle an SSLv2 backwards compatible ClientHello
1038          * Note, this is only for SSLv3+ using the backward compatible format.
1039          * Real SSLv2 is not supported, and is rejected above.
1040          */
1041         unsigned int cipher_len, session_id_len, challenge_len;
1042         PACKET challenge;
1043
1044         if (!PACKET_get_net_2(&pkt, &cipher_len)
1045                 || !PACKET_get_net_2(&pkt, &session_id_len)
1046                 || !PACKET_get_net_2(&pkt, &challenge_len)) {
1047             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO,
1048                    SSL_R_RECORD_LENGTH_MISMATCH);
1049             al = SSL_AD_DECODE_ERROR;
1050             goto f_err;
1051         }
1052
1053         if (!PACKET_get_sub_packet(&pkt, &cipher_suites, cipher_len)
1054             || !PACKET_get_sub_packet(&pkt, &session_id, session_id_len)
1055             || !PACKET_get_sub_packet(&pkt, &challenge, challenge_len)
1056             /* No extensions. */
1057             || PACKET_remaining(&pkt) != 0) {
1058             SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_RECORD_LENGTH_MISMATCH);
1059             al = SSL_AD_DECODE_ERROR;
1060             goto f_err;
1061         }
1062
1063         /* Load the client random */
1064         challenge_len = challenge_len > SSL3_RANDOM_SIZE ? SSL3_RANDOM_SIZE :
1065             challenge_len;
1066         memset(s->s3->client_random, 0, SSL3_RANDOM_SIZE);
1067         if (!PACKET_copy_bytes(&challenge,
1068                                s->s3->client_random + SSL3_RANDOM_SIZE -
1069                                challenge_len, challenge_len)) {
1070             SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1071             al = SSL_AD_INTERNAL_ERROR;
1072             goto f_err;
1073         }
1074
1075         PACKET_null_init(&compression);
1076         PACKET_null_init(&extensions);
1077     } else {
1078         /* Regular ClientHello. */
1079         if (!PACKET_copy_bytes(&pkt, s->s3->client_random, SSL3_RANDOM_SIZE)
1080             || !PACKET_get_length_prefixed_1(&pkt, &session_id)) {
1081             al = SSL_AD_DECODE_ERROR;
1082             SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_LENGTH_MISMATCH);
1083             goto f_err;
1084         }
1085
1086         if (SSL_IS_DTLS(s)) {
1087             if (!PACKET_get_length_prefixed_1(&pkt, &cookie)) {
1088                 al = SSL_AD_DECODE_ERROR;
1089                 SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_LENGTH_MISMATCH);
1090                 goto f_err;
1091             }
1092             /*
1093              * If we require cookies and this ClientHello doesn't contain one,
1094              * just return since we do not want to allocate any memory yet.
1095              * So check cookie length...
1096              */
1097             if (SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE) {
1098                 if (PACKET_remaining(&cookie) == 0)
1099                 return 1;
1100             }
1101         }
1102
1103         if (!PACKET_get_length_prefixed_2(&pkt, &cipher_suites)
1104             || !PACKET_get_length_prefixed_1(&pkt, &compression)) {
1105                 al = SSL_AD_DECODE_ERROR;
1106                 SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_LENGTH_MISMATCH);
1107                 goto f_err;
1108         }
1109         /* Could be empty. */
1110         extensions = pkt;
1111     }
1112
1113     s->hit = 0;
1114
1115     /*
1116      * We don't allow resumption in a backwards compatible ClientHello.
1117      * TODO(openssl-team): in TLS1.1+, session_id MUST be empty.
1118      *
1119      * Versions before 0.9.7 always allow clients to resume sessions in
1120      * renegotiation. 0.9.7 and later allow this by default, but optionally
1121      * ignore resumption requests with flag
1122      * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION (it's a new flag rather
1123      * than a change to default behavior so that applications relying on
1124      * this for security won't even compile against older library versions).
1125      * 1.0.1 and later also have a function SSL_renegotiate_abbreviated() to
1126      * request renegotiation but not a new session (s->new_session remains
1127      * unset): for servers, this essentially just means that the
1128      * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION setting will be
1129      * ignored.
1130      */
1131     if (is_v2_record ||
1132         (s->new_session &&
1133          (s->options & SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION))) {
1134         if (!ssl_get_new_session(s, 1))
1135             goto err;
1136     } else {
1137         i = ssl_get_prev_session(s, &extensions, &session_id);
1138         /*
1139          * Only resume if the session's version matches the negotiated
1140          * version.
1141          * RFC 5246 does not provide much useful advice on resumption
1142          * with a different protocol version. It doesn't forbid it but
1143          * the sanity of such behaviour would be questionable.
1144          * In practice, clients do not accept a version mismatch and
1145          * will abort the handshake with an error.
1146          */
1147         if (i == 1 && s->version == s->session->ssl_version) {
1148             /* previous session */
1149             s->hit = 1;
1150         } else if (i == -1) {
1151             goto err;
1152         } else {
1153             /* i == 0 */
1154             if (!ssl_get_new_session(s, 1))
1155                 goto err;
1156         }
1157     }
1158
1159     if (SSL_IS_DTLS(s)) {
1160         /* Empty cookie was already handled above by returning early. */
1161         if (SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE) {
1162             if (s->ctx->app_verify_cookie_cb != NULL) {
1163                 if (s->ctx->app_verify_cookie_cb(s, PACKET_data(&cookie),
1164                                                  PACKET_remaining(&cookie)) == 0) {
1165                     al = SSL_AD_HANDSHAKE_FAILURE;
1166                     SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,
1167                            SSL_R_COOKIE_MISMATCH);
1168                     goto f_err;
1169                     /* else cookie verification succeeded */
1170                 }
1171             /* default verification */
1172             } else if (!PACKET_equal(&cookie, s->d1->cookie,
1173                                      s->d1->cookie_len)) {
1174                 al = SSL_AD_HANDSHAKE_FAILURE;
1175                 SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_COOKIE_MISMATCH);
1176                 goto f_err;
1177             }
1178             s->d1->cookie_verified = 1;
1179         }
1180         if (s->method->version == DTLS_ANY_VERSION) {
1181             /* Select version to use */
1182             if (s->client_version <= DTLS1_2_VERSION &&
1183                 !(s->options & SSL_OP_NO_DTLSv1_2)) {
1184                 s->version = DTLS1_2_VERSION;
1185                 s->method = DTLSv1_2_server_method();
1186             } else if (tls1_suiteb(s)) {
1187                 SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,
1188                        SSL_R_ONLY_DTLS_1_2_ALLOWED_IN_SUITEB_MODE);
1189                 s->version = s->client_version;
1190                 al = SSL_AD_PROTOCOL_VERSION;
1191                 goto f_err;
1192             } else if (s->client_version <= DTLS1_VERSION &&
1193                        !(s->options & SSL_OP_NO_DTLSv1)) {
1194                 s->version = DTLS1_VERSION;
1195                 s->method = DTLSv1_server_method();
1196             } else {
1197                 SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,
1198                        SSL_R_WRONG_VERSION_NUMBER);
1199                 s->version = s->client_version;
1200                 al = SSL_AD_PROTOCOL_VERSION;
1201                 goto f_err;
1202             }
1203             s->session->ssl_version = s->version;
1204         }
1205     }
1206
1207     if (ssl_bytes_to_cipher_list(s, &cipher_suites, &(ciphers),
1208                                  is_v2_record, &al) == NULL) {
1209         goto f_err;
1210     }
1211
1212     /* If it is a hit, check that the cipher is in the list */
1213     if (s->hit) {
1214         j = 0;
1215         id = s->session->cipher->id;
1216
1217 #ifdef CIPHER_DEBUG
1218         fprintf(stderr, "client sent %d ciphers\n",
1219                 sk_SSL_CIPHER_num(ciphers));
1220 #endif
1221         for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
1222             c = sk_SSL_CIPHER_value(ciphers, i);
1223 #ifdef CIPHER_DEBUG
1224             fprintf(stderr, "client [%2d of %2d]:%s\n",
1225                     i, sk_SSL_CIPHER_num(ciphers), SSL_CIPHER_get_name(c));
1226 #endif
1227             if (c->id == id) {
1228                 j = 1;
1229                 break;
1230             }
1231         }
1232         if (j == 0) {
1233             /*
1234              * we need to have the cipher in the cipher list if we are asked
1235              * to reuse it
1236              */
1237             al = SSL_AD_ILLEGAL_PARAMETER;
1238             SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,
1239                    SSL_R_REQUIRED_CIPHER_MISSING);
1240             goto f_err;
1241         }
1242     }
1243
1244     complen = PACKET_remaining(&compression);
1245     for (j = 0; j < complen; j++) {
1246         if (PACKET_data(&compression)[j] == 0)
1247             break;
1248     }
1249
1250     if (j >= complen) {
1251         /* no compress */
1252         al = SSL_AD_DECODE_ERROR;
1253         SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_NO_COMPRESSION_SPECIFIED);
1254         goto f_err;
1255     }
1256
1257     /* TLS extensions */
1258     if (s->version >= SSL3_VERSION) {
1259         if (!ssl_parse_clienthello_tlsext(s, &extensions)) {
1260             SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_PARSE_TLSEXT);
1261             goto err;
1262         }
1263     }
1264
1265     /*
1266      * Check if we want to use external pre-shared secret for this handshake
1267      * for not reused session only. We need to generate server_random before
1268      * calling tls_session_secret_cb in order to allow SessionTicket
1269      * processing to use it in key derivation.
1270      */
1271     {
1272         unsigned char *pos;
1273         pos = s->s3->server_random;
1274         if (ssl_fill_hello_random(s, 1, pos, SSL3_RANDOM_SIZE) <= 0) {
1275             goto f_err;
1276         }
1277     }
1278
1279     if (!s->hit && s->version >= TLS1_VERSION && s->tls_session_secret_cb) {
1280         SSL_CIPHER *pref_cipher = NULL;
1281
1282         s->session->master_key_length = sizeof(s->session->master_key);
1283         if (s->tls_session_secret_cb(s, s->session->master_key,
1284                                      &s->session->master_key_length, ciphers,
1285                                      &pref_cipher,
1286                                      s->tls_session_secret_cb_arg)) {
1287             s->hit = 1;
1288             s->session->ciphers = ciphers;
1289             s->session->verify_result = X509_V_OK;
1290
1291             ciphers = NULL;
1292
1293             /* check if some cipher was preferred by call back */
1294             pref_cipher =
1295                 pref_cipher ? pref_cipher : ssl3_choose_cipher(s,
1296                                                                s->
1297                                                                session->ciphers,
1298                                                                SSL_get_ciphers
1299                                                                (s));
1300             if (pref_cipher == NULL) {
1301                 al = SSL_AD_HANDSHAKE_FAILURE;
1302                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_NO_SHARED_CIPHER);
1303                 goto f_err;
1304             }
1305
1306             s->session->cipher = pref_cipher;
1307             sk_SSL_CIPHER_free(s->cipher_list);
1308             s->cipher_list = sk_SSL_CIPHER_dup(s->session->ciphers);
1309             sk_SSL_CIPHER_free(s->cipher_list_by_id);
1310             s->cipher_list_by_id = sk_SSL_CIPHER_dup(s->session->ciphers);
1311         }
1312     }
1313
1314     /*
1315      * Worst case, we will use the NULL compression, but if we have other
1316      * options, we will now look for them.  We have complen-1 compression
1317      * algorithms from the client, starting at q.
1318      */
1319     s->s3->tmp.new_compression = NULL;
1320 #ifndef OPENSSL_NO_COMP
1321     /* This only happens if we have a cache hit */
1322     if (s->session->compress_meth != 0) {
1323         int m, comp_id = s->session->compress_meth;
1324         unsigned int k;
1325         /* Perform sanity checks on resumed compression algorithm */
1326         /* Can't disable compression */
1327         if (!ssl_allow_compression(s)) {
1328             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO,
1329                    SSL_R_INCONSISTENT_COMPRESSION);
1330             goto f_err;
1331         }
1332         /* Look for resumed compression method */
1333         for (m = 0; m < sk_SSL_COMP_num(s->ctx->comp_methods); m++) {
1334             comp = sk_SSL_COMP_value(s->ctx->comp_methods, m);
1335             if (comp_id == comp->id) {
1336                 s->s3->tmp.new_compression = comp;
1337                 break;
1338             }
1339         }
1340         if (s->s3->tmp.new_compression == NULL) {
1341             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO,
1342                    SSL_R_INVALID_COMPRESSION_ALGORITHM);
1343             goto f_err;
1344         }
1345         /* Look for resumed method in compression list */
1346         for (k = 0; k < complen; k++) {
1347             if (PACKET_data(&compression)[k] == comp_id)
1348                 break;
1349         }
1350         if (k >= complen) {
1351             al = SSL_AD_ILLEGAL_PARAMETER;
1352             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO,
1353                    SSL_R_REQUIRED_COMPRESSSION_ALGORITHM_MISSING);
1354             goto f_err;
1355         }
1356     } else if (s->hit)
1357         comp = NULL;
1358     else if (ssl_allow_compression(s) && s->ctx->comp_methods) {
1359         /* See if we have a match */
1360         int m, nn, v, done = 0;
1361         unsigned int o;
1362
1363         nn = sk_SSL_COMP_num(s->ctx->comp_methods);
1364         for (m = 0; m < nn; m++) {
1365             comp = sk_SSL_COMP_value(s->ctx->comp_methods, m);
1366             v = comp->id;
1367             for (o = 0; o < complen; o++) {
1368                 if (v == PACKET_data(&compression)[o]) {
1369                     done = 1;
1370                     break;
1371                 }
1372             }
1373             if (done)
1374                 break;
1375         }
1376         if (done)
1377             s->s3->tmp.new_compression = comp;
1378         else
1379             comp = NULL;
1380     }
1381 #else
1382     /*
1383      * If compression is disabled we'd better not try to resume a session
1384      * using compression.
1385      */
1386     if (s->session->compress_meth != 0) {
1387         SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_INCONSISTENT_COMPRESSION);
1388         goto f_err;
1389     }
1390 #endif
1391
1392     /*
1393      * Given s->session->ciphers and SSL_get_ciphers, we must pick a cipher
1394      */
1395
1396     if (!s->hit) {
1397 #ifdef OPENSSL_NO_COMP
1398         s->session->compress_meth = 0;
1399 #else
1400         s->session->compress_meth = (comp == NULL) ? 0 : comp->id;
1401 #endif
1402         sk_SSL_CIPHER_free(s->session->ciphers);
1403         s->session->ciphers = ciphers;
1404         if (ciphers == NULL) {
1405             al = SSL_AD_INTERNAL_ERROR;
1406             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1407             goto f_err;
1408         }
1409         ciphers = NULL;
1410         if (!tls1_set_server_sigalgs(s)) {
1411             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_CLIENTHELLO_TLSEXT);
1412             goto err;
1413         }
1414     }
1415
1416     sk_SSL_CIPHER_free(ciphers);
1417     return MSG_PROCESS_CONTINUE_PROCESSING;
1418  f_err:
1419     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1420  err:
1421     statem_set_error(s);
1422
1423     sk_SSL_CIPHER_free(ciphers);
1424     return MSG_PROCESS_ERROR;
1425
1426 }
1427
1428 enum WORK_STATE tls_post_process_client_hello(SSL *s, enum WORK_STATE wst)
1429 {
1430     int al;
1431     SSL_CIPHER *cipher;
1432
1433     if (wst == WORK_MORE_A) {
1434         if (!s->hit) {
1435             /* Let cert callback update server certificates if required */
1436             if (s->cert->cert_cb) {
1437                 int rv = s->cert->cert_cb(s, s->cert->cert_cb_arg);
1438                 if (rv == 0) {
1439                     al = SSL_AD_INTERNAL_ERROR;
1440                     SSLerr(SSL_F_TLS_POST_PROCESS_CLIENT_HELLO, SSL_R_CERT_CB_ERROR);
1441                     goto f_err;
1442                 }
1443                 if (rv < 0) {
1444                     s->rwstate = SSL_X509_LOOKUP;
1445                     return WORK_MORE_A;
1446                 }
1447                 s->rwstate = SSL_NOTHING;
1448             }
1449             cipher = ssl3_choose_cipher(s, s->session->ciphers, SSL_get_ciphers(s));
1450
1451             if (cipher == NULL) {
1452                 al = SSL_AD_HANDSHAKE_FAILURE;
1453                 SSLerr(SSL_F_TLS_POST_PROCESS_CLIENT_HELLO, SSL_R_NO_SHARED_CIPHER);
1454                 goto f_err;
1455             }
1456             s->s3->tmp.new_cipher = cipher;
1457             /* check whether we should disable session resumption */
1458             if (s->not_resumable_session_cb != NULL)
1459                 s->session->not_resumable = s->not_resumable_session_cb(s,
1460                     ((cipher->algorithm_mkey & (SSL_kDHE | SSL_kECDHE)) != 0));
1461             if (s->session->not_resumable)
1462                 /* do not send a session ticket */
1463                 s->tlsext_ticket_expected = 0;
1464         } else {
1465             /* Session-id reuse */
1466             s->s3->tmp.new_cipher = s->session->cipher;
1467         }
1468
1469         if (!SSL_USE_SIGALGS(s) || !(s->verify_mode & SSL_VERIFY_PEER)) {
1470             if (!ssl3_digest_cached_records(s, 0))
1471                 goto f_err;
1472         }
1473
1474         /*-
1475          * we now have the following setup.
1476          * client_random
1477          * cipher_list          - our prefered list of ciphers
1478          * ciphers              - the clients prefered list of ciphers
1479          * compression          - basically ignored right now
1480          * ssl version is set   - sslv3
1481          * s->session           - The ssl session has been setup.
1482          * s->hit               - session reuse flag
1483          * s->s3->tmp.new_cipher- the new cipher to use.
1484          */
1485
1486         /* Handles TLS extensions that we couldn't check earlier */
1487         if (s->version >= SSL3_VERSION) {
1488             if (ssl_check_clienthello_tlsext_late(s) <= 0) {
1489                 SSLerr(SSL_F_TLS_POST_PROCESS_CLIENT_HELLO, SSL_R_CLIENTHELLO_TLSEXT);
1490                 goto f_err;
1491             }
1492         }
1493
1494         wst = WORK_MORE_B;
1495     }
1496 #ifndef OPENSSL_NO_SRP
1497     if (wst == WORK_MORE_B) {
1498         int ret;
1499         if ((ret = ssl_check_srp_ext_ClientHello(s, &al)) < 0) {
1500             /*
1501              * callback indicates further work to be done
1502              */
1503             s->rwstate = SSL_X509_LOOKUP;
1504             return WORK_MORE_B;
1505         }
1506         if (ret != SSL_ERROR_NONE) {
1507             /*
1508              * This is not really an error but the only means to for
1509              * a client to detect whether srp is supported.
1510              */
1511             if (al != TLS1_AD_UNKNOWN_PSK_IDENTITY)
1512                 SSLerr(SSL_F_TLS_POST_PROCESS_CLIENT_HELLO,
1513                            SSL_R_CLIENTHELLO_TLSEXT);
1514             goto f_err;
1515         }
1516     }
1517 #endif
1518     s->renegotiate = 2;
1519
1520     return WORK_FINISHED_STOP;
1521  f_err:
1522     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1523     statem_set_error(s);
1524     return WORK_ERROR;
1525 }
1526
1527 int ssl3_send_server_hello(SSL *s)
1528 {
1529     if (s->state == SSL3_ST_SW_SRVR_HELLO_A) {
1530         if (tls_construct_server_hello(s) != 1)
1531             return -1;
1532         s->state = SSL3_ST_SW_SRVR_HELLO_B;
1533     }
1534
1535     /* SSL3_ST_SW_SRVR_HELLO_B */
1536     return ssl_do_write(s);
1537 }
1538
1539 int tls_construct_server_hello(SSL *s)
1540 {
1541     unsigned char *buf;
1542     unsigned char *p, *d;
1543     int i, sl;
1544     int al = 0;
1545     unsigned long l;
1546
1547     buf = (unsigned char *)s->init_buf->data;
1548
1549     /* Do the message type and length last */
1550     d = p = ssl_handshake_start(s);
1551
1552     *(p++) = s->version >> 8;
1553     *(p++) = s->version & 0xff;
1554
1555     /*
1556      * Random stuff. Filling of the server_random takes place in
1557      * tls_process_client_hello()
1558      */
1559     memcpy(p, s->s3->server_random, SSL3_RANDOM_SIZE);
1560     p += SSL3_RANDOM_SIZE;
1561
1562     /*-
1563      * There are several cases for the session ID to send
1564      * back in the server hello:
1565      * - For session reuse from the session cache,
1566      *   we send back the old session ID.
1567      * - If stateless session reuse (using a session ticket)
1568      *   is successful, we send back the client's "session ID"
1569      *   (which doesn't actually identify the session).
1570      * - If it is a new session, we send back the new
1571      *   session ID.
1572      * - However, if we want the new session to be single-use,
1573      *   we send back a 0-length session ID.
1574      * s->hit is non-zero in either case of session reuse,
1575      * so the following won't overwrite an ID that we're supposed
1576      * to send back.
1577      */
1578     if (s->session->not_resumable ||
1579         (!(s->ctx->session_cache_mode & SSL_SESS_CACHE_SERVER)
1580          && !s->hit))
1581         s->session->session_id_length = 0;
1582
1583     sl = s->session->session_id_length;
1584     if (sl > (int)sizeof(s->session->session_id)) {
1585         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_HELLO, ERR_R_INTERNAL_ERROR);
1586         statem_set_error(s);
1587         return 0;
1588     }
1589     *(p++) = sl;
1590     memcpy(p, s->session->session_id, sl);
1591     p += sl;
1592
1593     /* put the cipher */
1594     i = ssl3_put_cipher_by_char(s->s3->tmp.new_cipher, p);
1595     p += i;
1596
1597     /* put the compression method */
1598 #ifdef OPENSSL_NO_COMP
1599     *(p++) = 0;
1600 #else
1601     if (s->s3->tmp.new_compression == NULL)
1602         *(p++) = 0;
1603     else
1604         *(p++) = s->s3->tmp.new_compression->id;
1605 #endif
1606
1607     if (ssl_prepare_serverhello_tlsext(s) <= 0) {
1608         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_HELLO, SSL_R_SERVERHELLO_TLSEXT);
1609         statem_set_error(s);
1610         return 0;
1611     }
1612     if ((p =
1613          ssl_add_serverhello_tlsext(s, p, buf + SSL3_RT_MAX_PLAIN_LENGTH,
1614                                     &al)) == NULL) {
1615         ssl3_send_alert(s, SSL3_AL_FATAL, al);
1616         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_HELLO, ERR_R_INTERNAL_ERROR);
1617         statem_set_error(s);
1618         return 0;
1619     }
1620
1621     /* do the header */
1622     l = (p - d);
1623     if (!ssl_set_handshake_header(s, SSL3_MT_SERVER_HELLO, l)) {
1624         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_HELLO, ERR_R_INTERNAL_ERROR);
1625         statem_set_error(s);
1626         return 0;
1627     }
1628
1629     return 1;
1630 }
1631
1632 int ssl3_send_server_done(SSL *s)
1633 {
1634
1635     if (s->state == SSL3_ST_SW_SRVR_DONE_A) {
1636         if (tls_construct_server_done(s) == 0)
1637             return -1;
1638         s->state = SSL3_ST_SW_SRVR_DONE_B;
1639     }
1640
1641     /* SSL3_ST_SW_SRVR_DONE_B */
1642     return ssl_do_write(s);
1643 }
1644
1645 int tls_construct_server_done(SSL *s)
1646 {
1647     if (!ssl_set_handshake_header(s, SSL3_MT_SERVER_DONE, 0)) {
1648         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_DONE, ERR_R_INTERNAL_ERROR);
1649         statem_set_error(s);
1650         return 0;
1651     }
1652
1653     if (!s->s3->tmp.cert_request) {
1654         if (!ssl3_digest_cached_records(s, 0)) {
1655             statem_set_error(s);
1656         }
1657     }
1658
1659     return 1;
1660 }
1661
1662 int ssl3_send_server_key_exchange(SSL *s)
1663 {
1664     if (s->state == SSL3_ST_SW_KEY_EXCH_A) {
1665         if (tls_construct_server_key_exchange(s) == 0)
1666             return -1;
1667     }
1668
1669     s->state = SSL3_ST_SW_KEY_EXCH_B;
1670     return ssl_do_write(s);
1671 }
1672
1673 int tls_construct_server_key_exchange(SSL *s)
1674 {
1675 #ifndef OPENSSL_NO_RSA
1676     unsigned char *q;
1677     int j, num;
1678     RSA *rsa;
1679     unsigned char md_buf[MD5_DIGEST_LENGTH + SHA_DIGEST_LENGTH];
1680     unsigned int u;
1681 #endif
1682 #ifndef OPENSSL_NO_DH
1683     DH *dh = NULL, *dhp;
1684 #endif
1685 #ifndef OPENSSL_NO_EC
1686     EC_KEY *ecdh = NULL, *ecdhp;
1687     unsigned char *encodedPoint = NULL;
1688     int encodedlen = 0;
1689     int curve_id = 0;
1690     BN_CTX *bn_ctx = NULL;
1691 #endif
1692     EVP_PKEY *pkey;
1693     const EVP_MD *md = NULL;
1694     unsigned char *p, *d;
1695     int al, i;
1696     unsigned long type;
1697     int n;
1698     CERT *cert;
1699     BIGNUM *r[4];
1700     int nr[4], kn;
1701     BUF_MEM *buf;
1702     EVP_MD_CTX md_ctx;
1703
1704     EVP_MD_CTX_init(&md_ctx);
1705
1706     type = s->s3->tmp.new_cipher->algorithm_mkey;
1707     cert = s->cert;
1708
1709     buf = s->init_buf;
1710
1711     r[0] = r[1] = r[2] = r[3] = NULL;
1712     n = 0;
1713 #ifndef OPENSSL_NO_PSK
1714     if (type & SSL_PSK) {
1715         /*
1716          * reserve size for record length and PSK identity hint
1717          */
1718         n += 2;
1719         if (s->cert->psk_identity_hint)
1720             n += strlen(s->cert->psk_identity_hint);
1721     }
1722     /* Plain PSK or RSAPSK nothing to do */
1723     if (type & (SSL_kPSK | SSL_kRSAPSK)) {
1724     } else
1725 #endif                          /* !OPENSSL_NO_PSK */
1726 #ifndef OPENSSL_NO_RSA
1727     if (type & SSL_kRSA) {
1728         rsa = cert->rsa_tmp;
1729         if ((rsa == NULL) && (s->cert->rsa_tmp_cb != NULL)) {
1730             rsa = s->cert->rsa_tmp_cb(s,
1731                                       SSL_C_IS_EXPORT(s->s3->
1732                                                       tmp.new_cipher),
1733                                       SSL_C_EXPORT_PKEYLENGTH(s->s3->
1734                                                               tmp.new_cipher));
1735             if (rsa == NULL) {
1736                 al = SSL_AD_HANDSHAKE_FAILURE;
1737                 SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1738                        SSL_R_ERROR_GENERATING_TMP_RSA_KEY);
1739                 goto f_err;
1740             }
1741             RSA_up_ref(rsa);
1742             cert->rsa_tmp = rsa;
1743         }
1744         if (rsa == NULL) {
1745             al = SSL_AD_HANDSHAKE_FAILURE;
1746             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1747                    SSL_R_MISSING_TMP_RSA_KEY);
1748             goto f_err;
1749         }
1750         r[0] = rsa->n;
1751         r[1] = rsa->e;
1752         s->s3->tmp.use_rsa_tmp = 1;
1753     } else
1754 #endif
1755 #ifndef OPENSSL_NO_DH
1756     if (type & (SSL_kDHE | SSL_kDHEPSK)) {
1757         if (s->cert->dh_tmp_auto) {
1758             dhp = ssl_get_auto_dh(s);
1759             if (dhp == NULL) {
1760                 al = SSL_AD_INTERNAL_ERROR;
1761                 SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1762                        ERR_R_INTERNAL_ERROR);
1763                 goto f_err;
1764             }
1765         } else
1766             dhp = cert->dh_tmp;
1767         if ((dhp == NULL) && (s->cert->dh_tmp_cb != NULL))
1768             dhp = s->cert->dh_tmp_cb(s,
1769                                      SSL_C_IS_EXPORT(s->s3->
1770                                                      tmp.new_cipher),
1771                                      SSL_C_EXPORT_PKEYLENGTH(s->s3->
1772                                                              tmp.new_cipher));
1773         if (dhp == NULL) {
1774             al = SSL_AD_HANDSHAKE_FAILURE;
1775             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1776                    SSL_R_MISSING_TMP_DH_KEY);
1777             goto f_err;
1778         }
1779         if (!ssl_security(s, SSL_SECOP_TMP_DH,
1780                           DH_security_bits(dhp), 0, dhp)) {
1781             al = SSL_AD_HANDSHAKE_FAILURE;
1782             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1783                    SSL_R_DH_KEY_TOO_SMALL);
1784             goto f_err;
1785         }
1786         if (s->s3->tmp.dh != NULL) {
1787             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1788                    ERR_R_INTERNAL_ERROR);
1789             goto err;
1790         }
1791
1792         if (s->cert->dh_tmp_auto)
1793             dh = dhp;
1794         else if ((dh = DHparams_dup(dhp)) == NULL) {
1795             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_DH_LIB);
1796             goto err;
1797         }
1798
1799         s->s3->tmp.dh = dh;
1800         if ((dhp->pub_key == NULL ||
1801              dhp->priv_key == NULL ||
1802              (s->options & SSL_OP_SINGLE_DH_USE))) {
1803             if (!DH_generate_key(dh)) {
1804                 SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_DH_LIB);
1805                 goto err;
1806             }
1807         } else {
1808             dh->pub_key = BN_dup(dhp->pub_key);
1809             dh->priv_key = BN_dup(dhp->priv_key);
1810             if ((dh->pub_key == NULL) || (dh->priv_key == NULL)) {
1811                 SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_DH_LIB);
1812                 goto err;
1813             }
1814         }
1815         r[0] = dh->p;
1816         r[1] = dh->g;
1817         r[2] = dh->pub_key;
1818     } else
1819 #endif
1820 #ifndef OPENSSL_NO_EC
1821     if (type & (SSL_kECDHE | SSL_kECDHEPSK)) {
1822         const EC_GROUP *group;
1823
1824         ecdhp = cert->ecdh_tmp;
1825         if (s->cert->ecdh_tmp_auto) {
1826             /* Get NID of appropriate shared curve */
1827             int nid = tls1_shared_curve(s, -2);
1828             if (nid != NID_undef)
1829                 ecdhp = EC_KEY_new_by_curve_name(nid);
1830         } else if ((ecdhp == NULL) && s->cert->ecdh_tmp_cb) {
1831             ecdhp = s->cert->ecdh_tmp_cb(s,
1832                                          SSL_C_IS_EXPORT(s->s3->
1833                                                          tmp.new_cipher),
1834                                          SSL_C_EXPORT_PKEYLENGTH(s->
1835                                                                  s3->tmp.new_cipher));
1836         }
1837         if (ecdhp == NULL) {
1838             al = SSL_AD_HANDSHAKE_FAILURE;
1839             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1840                    SSL_R_MISSING_TMP_ECDH_KEY);
1841             goto f_err;
1842         }
1843
1844         if (s->s3->tmp.ecdh != NULL) {
1845             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1846                    ERR_R_INTERNAL_ERROR);
1847             goto err;
1848         }
1849
1850         /* Duplicate the ECDH structure. */
1851         if (ecdhp == NULL) {
1852             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_ECDH_LIB);
1853             goto err;
1854         }
1855         if (s->cert->ecdh_tmp_auto)
1856             ecdh = ecdhp;
1857         else if ((ecdh = EC_KEY_dup(ecdhp)) == NULL) {
1858             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_ECDH_LIB);
1859             goto err;
1860         }
1861
1862         s->s3->tmp.ecdh = ecdh;
1863         if ((EC_KEY_get0_public_key(ecdh) == NULL) ||
1864             (EC_KEY_get0_private_key(ecdh) == NULL) ||
1865             (s->options & SSL_OP_SINGLE_ECDH_USE)) {
1866             if (!EC_KEY_generate_key(ecdh)) {
1867                 SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1868                        ERR_R_ECDH_LIB);
1869                 goto err;
1870             }
1871         }
1872
1873         if (((group = EC_KEY_get0_group(ecdh)) == NULL) ||
1874             (EC_KEY_get0_public_key(ecdh) == NULL) ||
1875             (EC_KEY_get0_private_key(ecdh) == NULL)) {
1876             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_ECDH_LIB);
1877             goto err;
1878         }
1879
1880         if (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher) &&
1881             (EC_GROUP_get_degree(group) > 163)) {
1882             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1883                    SSL_R_ECGROUP_TOO_LARGE_FOR_CIPHER);
1884             goto err;
1885         }
1886
1887         /*
1888          * XXX: For now, we only support ephemeral ECDH keys over named
1889          * (not generic) curves. For supported named curves, curve_id is
1890          * non-zero.
1891          */
1892         if ((curve_id =
1893              tls1_ec_nid2curve_id(EC_GROUP_get_curve_name(group)))
1894             == 0) {
1895             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1896                    SSL_R_UNSUPPORTED_ELLIPTIC_CURVE);
1897             goto err;
1898         }
1899
1900         /*
1901          * Encode the public key. First check the size of encoding and
1902          * allocate memory accordingly.
1903          */
1904         encodedlen = EC_POINT_point2oct(group,
1905                                         EC_KEY_get0_public_key(ecdh),
1906                                         POINT_CONVERSION_UNCOMPRESSED,
1907                                         NULL, 0, NULL);
1908
1909         encodedPoint = (unsigned char *)
1910             OPENSSL_malloc(encodedlen * sizeof(unsigned char));
1911         bn_ctx = BN_CTX_new();
1912         if ((encodedPoint == NULL) || (bn_ctx == NULL)) {
1913             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1914                    ERR_R_MALLOC_FAILURE);
1915             goto err;
1916         }
1917
1918         encodedlen = EC_POINT_point2oct(group,
1919                                         EC_KEY_get0_public_key(ecdh),
1920                                         POINT_CONVERSION_UNCOMPRESSED,
1921                                         encodedPoint, encodedlen, bn_ctx);
1922
1923         if (encodedlen == 0) {
1924             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_ECDH_LIB);
1925             goto err;
1926         }
1927
1928         BN_CTX_free(bn_ctx);
1929         bn_ctx = NULL;
1930
1931         /*
1932          * XXX: For now, we only support named (not generic) curves in
1933          * ECDH ephemeral key exchanges. In this situation, we need four
1934          * additional bytes to encode the entire ServerECDHParams
1935          * structure.
1936          */
1937         n += 4 + encodedlen;
1938
1939         /*
1940          * We'll generate the serverKeyExchange message explicitly so we
1941          * can set these to NULLs
1942          */
1943         r[0] = NULL;
1944         r[1] = NULL;
1945         r[2] = NULL;
1946         r[3] = NULL;
1947     } else
1948 #endif                          /* !OPENSSL_NO_EC */
1949 #ifndef OPENSSL_NO_SRP
1950     if (type & SSL_kSRP) {
1951         if ((s->srp_ctx.N == NULL) ||
1952             (s->srp_ctx.g == NULL) ||
1953             (s->srp_ctx.s == NULL) || (s->srp_ctx.B == NULL)) {
1954             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1955                    SSL_R_MISSING_SRP_PARAM);
1956             goto err;
1957         }
1958         r[0] = s->srp_ctx.N;
1959         r[1] = s->srp_ctx.g;
1960         r[2] = s->srp_ctx.s;
1961         r[3] = s->srp_ctx.B;
1962     } else
1963 #endif
1964     {
1965         al = SSL_AD_HANDSHAKE_FAILURE;
1966         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1967                SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE);
1968         goto f_err;
1969     }
1970     for (i = 0; i < 4 && r[i] != NULL; i++) {
1971         nr[i] = BN_num_bytes(r[i]);
1972 #ifndef OPENSSL_NO_SRP
1973         if ((i == 2) && (type & SSL_kSRP))
1974             n += 1 + nr[i];
1975         else
1976 #endif
1977             n += 2 + nr[i];
1978     }
1979
1980     if (!(s->s3->tmp.new_cipher->algorithm_auth & (SSL_aNULL|SSL_aSRP))
1981         && !(s->s3->tmp.new_cipher->algorithm_mkey & SSL_PSK)) {
1982         if ((pkey = ssl_get_sign_pkey(s, s->s3->tmp.new_cipher, &md))
1983             == NULL) {
1984             al = SSL_AD_DECODE_ERROR;
1985             goto f_err;
1986         }
1987         kn = EVP_PKEY_size(pkey);
1988     } else {
1989         pkey = NULL;
1990         kn = 0;
1991     }
1992
1993     if (!BUF_MEM_grow_clean(buf, n + SSL_HM_HEADER_LENGTH(s) + kn)) {
1994         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_LIB_BUF);
1995         goto err;
1996     }
1997     d = p = ssl_handshake_start(s);
1998
1999 #ifndef OPENSSL_NO_PSK
2000     if (type & SSL_PSK) {
2001         /* copy PSK identity hint */
2002         if (s->cert->psk_identity_hint) {
2003             s2n(strlen(s->cert->psk_identity_hint), p);
2004             strncpy((char *)p, s->cert->psk_identity_hint,
2005                     strlen(s->cert->psk_identity_hint));
2006             p += strlen(s->cert->psk_identity_hint);
2007         } else {
2008             s2n(0, p);
2009         }
2010     }
2011 #endif
2012
2013     for (i = 0; i < 4 && r[i] != NULL; i++) {
2014 #ifndef OPENSSL_NO_SRP
2015         if ((i == 2) && (type & SSL_kSRP)) {
2016             *p = nr[i];
2017             p++;
2018         } else
2019 #endif
2020             s2n(nr[i], p);
2021         BN_bn2bin(r[i], p);
2022         p += nr[i];
2023     }
2024
2025 #ifndef OPENSSL_NO_EC
2026     if (type & (SSL_kECDHE | SSL_kECDHEPSK)) {
2027         /*
2028          * XXX: For now, we only support named (not generic) curves. In
2029          * this situation, the serverKeyExchange message has: [1 byte
2030          * CurveType], [2 byte CurveName] [1 byte length of encoded
2031          * point], followed by the actual encoded point itself
2032          */
2033         *p = NAMED_CURVE_TYPE;
2034         p += 1;
2035         *p = 0;
2036         p += 1;
2037         *p = curve_id;
2038         p += 1;
2039         *p = encodedlen;
2040         p += 1;
2041         memcpy(p, encodedPoint, encodedlen);
2042         OPENSSL_free(encodedPoint);
2043         encodedPoint = NULL;
2044         p += encodedlen;
2045     }
2046 #endif
2047
2048     /* not anonymous */
2049     if (pkey != NULL) {
2050         /*
2051          * n is the length of the params, they start at &(d[4]) and p
2052          * points to the space at the end.
2053          */
2054 #ifndef OPENSSL_NO_RSA
2055         if (pkey->type == EVP_PKEY_RSA && !SSL_USE_SIGALGS(s)) {
2056             q = md_buf;
2057             j = 0;
2058             for (num = 2; num > 0; num--) {
2059                 EVP_MD_CTX_set_flags(&md_ctx,
2060                                      EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
2061                 EVP_DigestInit_ex(&md_ctx, (num == 2)
2062                                   ? s->ctx->md5 : s->ctx->sha1, NULL);
2063                 EVP_DigestUpdate(&md_ctx, &(s->s3->client_random[0]),
2064                                  SSL3_RANDOM_SIZE);
2065                 EVP_DigestUpdate(&md_ctx, &(s->s3->server_random[0]),
2066                                  SSL3_RANDOM_SIZE);
2067                 EVP_DigestUpdate(&md_ctx, d, n);
2068                 EVP_DigestFinal_ex(&md_ctx, q, (unsigned int *)&i);
2069                 q += i;
2070                 j += i;
2071             }
2072             if (RSA_sign(NID_md5_sha1, md_buf, j,
2073                          &(p[2]), &u, pkey->pkey.rsa) <= 0) {
2074                 SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_LIB_RSA);
2075                 goto err;
2076             }
2077             s2n(u, p);
2078             n += u + 2;
2079         } else
2080 #endif
2081         if (md) {
2082             /* send signature algorithm */
2083             if (SSL_USE_SIGALGS(s)) {
2084                 if (!tls12_get_sigandhash(p, pkey, md)) {
2085                     /* Should never happen */
2086                     al = SSL_AD_INTERNAL_ERROR;
2087                     SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2088                            ERR_R_INTERNAL_ERROR);
2089                     goto f_err;
2090                 }
2091                 p += 2;
2092             }
2093 #ifdef SSL_DEBUG
2094             fprintf(stderr, "Using hash %s\n", EVP_MD_name(md));
2095 #endif
2096             EVP_SignInit_ex(&md_ctx, md, NULL);
2097             EVP_SignUpdate(&md_ctx, &(s->s3->client_random[0]),
2098                            SSL3_RANDOM_SIZE);
2099             EVP_SignUpdate(&md_ctx, &(s->s3->server_random[0]),
2100                            SSL3_RANDOM_SIZE);
2101             EVP_SignUpdate(&md_ctx, d, n);
2102             if (!EVP_SignFinal(&md_ctx, &(p[2]),
2103                                (unsigned int *)&i, pkey)) {
2104                 SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_LIB_EVP);
2105                 goto err;
2106             }
2107             s2n(i, p);
2108             n += i + 2;
2109             if (SSL_USE_SIGALGS(s))
2110                 n += 2;
2111         } else {
2112             /* Is this error check actually needed? */
2113             al = SSL_AD_HANDSHAKE_FAILURE;
2114             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2115                    SSL_R_UNKNOWN_PKEY_TYPE);
2116             goto f_err;
2117         }
2118     }
2119
2120     if (!ssl_set_handshake_header(s, SSL3_MT_SERVER_KEY_EXCHANGE, n)) {
2121         al = SSL_AD_HANDSHAKE_FAILURE;
2122         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2123         goto f_err;
2124     }
2125
2126     EVP_MD_CTX_cleanup(&md_ctx);
2127     return 1;
2128  f_err:
2129     ssl3_send_alert(s, SSL3_AL_FATAL, al);
2130  err:
2131 #ifndef OPENSSL_NO_EC
2132     OPENSSL_free(encodedPoint);
2133     BN_CTX_free(bn_ctx);
2134 #endif
2135     EVP_MD_CTX_cleanup(&md_ctx);
2136     statem_set_error(s);
2137     return 0;
2138 }
2139
2140 int ssl3_send_certificate_request(SSL *s)
2141 {
2142     if (s->state == SSL3_ST_SW_CERT_REQ_A) {
2143         if (tls_construct_certificate_request(s) == 0)
2144             return -1;
2145         s->state = SSL3_ST_SW_CERT_REQ_B;
2146     }
2147
2148     /* SSL3_ST_SW_CERT_REQ_B */
2149     return ssl_do_write(s);
2150 }
2151
2152 int tls_construct_certificate_request(SSL *s)
2153 {
2154     unsigned char *p, *d;
2155     int i, j, nl, off, n;
2156     STACK_OF(X509_NAME) *sk = NULL;
2157     X509_NAME *name;
2158     BUF_MEM *buf;
2159
2160     buf = s->init_buf;
2161
2162     d = p = ssl_handshake_start(s);
2163
2164     /* get the list of acceptable cert types */
2165     p++;
2166     n = ssl3_get_req_cert_type(s, p);
2167     d[0] = n;
2168     p += n;
2169     n++;
2170
2171     if (SSL_USE_SIGALGS(s)) {
2172         const unsigned char *psigs;
2173         unsigned char *etmp = p;
2174         nl = tls12_get_psigalgs(s, &psigs);
2175         /* Skip over length for now */
2176         p += 2;
2177         nl = tls12_copy_sigalgs(s, p, psigs, nl);
2178         /* Now fill in length */
2179         s2n(nl, etmp);
2180         p += nl;
2181         n += nl + 2;
2182     }
2183
2184     off = n;
2185     p += 2;
2186     n += 2;
2187
2188     sk = SSL_get_client_CA_list(s);
2189     nl = 0;
2190     if (sk != NULL) {
2191         for (i = 0; i < sk_X509_NAME_num(sk); i++) {
2192             name = sk_X509_NAME_value(sk, i);
2193             j = i2d_X509_NAME(name, NULL);
2194             if (!BUF_MEM_grow_clean
2195                 (buf, SSL_HM_HEADER_LENGTH(s) + n + j + 2)) {
2196                 SSLerr(SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST,
2197                        ERR_R_BUF_LIB);
2198                 goto err;
2199             }
2200             p = ssl_handshake_start(s) + n;
2201             s2n(j, p);
2202             i2d_X509_NAME(name, &p);
2203             n += 2 + j;
2204             nl += 2 + j;
2205         }
2206     }
2207     /* else no CA names */
2208     p = ssl_handshake_start(s) + off;
2209     s2n(nl, p);
2210
2211     if (!ssl_set_handshake_header(s, SSL3_MT_CERTIFICATE_REQUEST, n)) {
2212         SSLerr(SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST, ERR_R_INTERNAL_ERROR);
2213         goto err;
2214     }
2215
2216     s->s3->tmp.cert_request = 1;
2217
2218     return 1;
2219  err:
2220     statem_set_error(s);
2221     return 0;
2222 }
2223
2224 int ssl3_get_client_key_exchange(SSL *s)
2225 {
2226     int ok;
2227     long n;
2228
2229     n = s->method->ssl_get_message(s,
2230                                    SSL3_ST_SR_KEY_EXCH_A,
2231                                    SSL3_ST_SR_KEY_EXCH_B,
2232                                    SSL3_MT_CLIENT_KEY_EXCHANGE, 2048, &ok);
2233
2234     if (!ok)
2235         return ((int)n);
2236
2237     if (tls_process_client_key_exchange(s, n) == 0)
2238         return -1;
2239
2240     return n;
2241 }
2242
2243 enum MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL *s, long n)
2244 {
2245     int al;
2246     unsigned int i;
2247     unsigned long alg_k;
2248 #ifndef OPENSSL_NO_RSA
2249     RSA *rsa = NULL;
2250     EVP_PKEY *pkey = NULL;
2251 #endif
2252 #ifndef OPENSSL_NO_DH
2253     BIGNUM *pub = NULL;
2254     DH *dh_srvr, *dh_clnt = NULL;
2255 #endif
2256 #ifndef OPENSSL_NO_EC
2257     EC_KEY *srvr_ecdh = NULL;
2258     EVP_PKEY *clnt_pub_pkey = NULL;
2259     EC_POINT *clnt_ecpoint = NULL;
2260     BN_CTX *bn_ctx = NULL;
2261 #endif
2262     PACKET pkt, enc_premaster;
2263     unsigned char *data, *rsa_decrypt = NULL;
2264
2265     if (!PACKET_buf_init(&pkt, s->init_msg, n)) {
2266         al = SSL_AD_INTERNAL_ERROR;
2267         SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2268         goto f_err;
2269     }
2270
2271     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
2272
2273 #ifndef OPENSSL_NO_PSK
2274     /* For PSK parse and retrieve identity, obtain PSK key */
2275     if (alg_k & SSL_PSK) {
2276         unsigned char psk[PSK_MAX_PSK_LEN];
2277         size_t psklen;
2278         PACKET psk_identity;
2279
2280         if (!PACKET_get_length_prefixed_2(&pkt, &psk_identity)) {
2281             al = SSL_AD_DECODE_ERROR;
2282             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, SSL_R_LENGTH_MISMATCH);
2283             goto f_err;
2284         }
2285         if (PACKET_remaining(&psk_identity) > PSK_MAX_IDENTITY_LEN) {
2286             al = SSL_AD_DECODE_ERROR;
2287             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2288                    SSL_R_DATA_LENGTH_TOO_LONG);
2289             goto f_err;
2290         }
2291         if (s->psk_server_callback == NULL) {
2292             al = SSL_AD_INTERNAL_ERROR;
2293             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2294                    SSL_R_PSK_NO_SERVER_CB);
2295             goto f_err;
2296         }
2297
2298         if (!PACKET_strndup(&psk_identity, &s->session->psk_identity)) {
2299             SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2300             al = SSL_AD_INTERNAL_ERROR;
2301             goto f_err;
2302         }
2303
2304         psklen = s->psk_server_callback(s, s->session->psk_identity,
2305                                          psk, sizeof(psk));
2306
2307         if (psklen > PSK_MAX_PSK_LEN) {
2308             al = SSL_AD_INTERNAL_ERROR;
2309             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2310             goto f_err;
2311         } else if (psklen == 0) {
2312             /*
2313              * PSK related to the given identity not found
2314              */
2315             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2316                    SSL_R_PSK_IDENTITY_NOT_FOUND);
2317             al = SSL_AD_UNKNOWN_PSK_IDENTITY;
2318             goto f_err;
2319         }
2320
2321         OPENSSL_free(s->s3->tmp.psk);
2322         s->s3->tmp.psk = BUF_memdup(psk, psklen);
2323         OPENSSL_cleanse(psk, psklen);
2324
2325         if (s->s3->tmp.psk == NULL) {
2326             al = SSL_AD_INTERNAL_ERROR;
2327             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
2328             goto f_err;
2329         }
2330
2331         s->s3->tmp.psklen = psklen;
2332     }
2333     if (alg_k & SSL_kPSK) {
2334         /* Identity extracted earlier: should be nothing left */
2335         if (PACKET_remaining(&pkt) != 0) {
2336             al = SSL_AD_HANDSHAKE_FAILURE;
2337             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, SSL_R_LENGTH_MISMATCH);
2338             goto f_err;
2339         }
2340         /* PSK handled by ssl_generate_master_secret */
2341         if (!ssl_generate_master_secret(s, NULL, 0, 0)) {
2342             al = SSL_AD_INTERNAL_ERROR;
2343             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2344             goto f_err;
2345         }
2346     } else
2347 #endif
2348 #ifndef OPENSSL_NO_RSA
2349     if (alg_k & (SSL_kRSA | SSL_kRSAPSK)) {
2350         unsigned char rand_premaster_secret[SSL_MAX_MASTER_KEY_LENGTH];
2351         int decrypt_len;
2352         unsigned char decrypt_good, version_good;
2353         size_t j;
2354
2355         /* FIX THIS UP EAY EAY EAY EAY */
2356         if (s->s3->tmp.use_rsa_tmp) {
2357             if ((s->cert != NULL) && (s->cert->rsa_tmp != NULL))
2358                 rsa = s->cert->rsa_tmp;
2359             /*
2360              * Don't do a callback because rsa_tmp should be sent already
2361              */
2362             if (rsa == NULL) {
2363                 al = SSL_AD_HANDSHAKE_FAILURE;
2364                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2365                        SSL_R_MISSING_TMP_RSA_PKEY);
2366                 goto f_err;
2367
2368             }
2369         } else {
2370             pkey = s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey;
2371             if ((pkey == NULL) ||
2372                 (pkey->type != EVP_PKEY_RSA) || (pkey->pkey.rsa == NULL)) {
2373                 al = SSL_AD_HANDSHAKE_FAILURE;
2374                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2375                        SSL_R_MISSING_RSA_CERTIFICATE);
2376                 goto f_err;
2377             }
2378             rsa = pkey->pkey.rsa;
2379         }
2380
2381         /* SSLv3 and pre-standard DTLS omit the length bytes. */
2382         if (s->version == SSL3_VERSION || s->version == DTLS1_BAD_VER) {
2383             enc_premaster = pkt;
2384         } else {
2385             PACKET orig = pkt;
2386             if (!PACKET_get_length_prefixed_2(&pkt, &enc_premaster)
2387                 || PACKET_remaining(&pkt) != 0) {
2388                 /* Try SSLv3 behaviour for TLS. */
2389                 if (s->options & SSL_OP_TLS_D5_BUG) {
2390                     enc_premaster = orig;
2391                 } else {
2392                     al = SSL_AD_DECODE_ERROR;
2393                     SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE, SSL_R_LENGTH_MISMATCH);
2394                     goto f_err;
2395                 }
2396             }
2397         }
2398
2399         /*
2400          * We want to be sure that the plaintext buffer size makes it safe to
2401          * iterate over the entire size of a premaster secret
2402          * (SSL_MAX_MASTER_KEY_LENGTH). Reject overly short RSA keys because
2403          * their ciphertext cannot accommodate a premaster secret anyway.
2404          */
2405         if (RSA_size(rsa) < SSL_MAX_MASTER_KEY_LENGTH) {
2406             al = SSL_AD_INTERNAL_ERROR;
2407             SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE,
2408                    RSA_R_KEY_SIZE_TOO_SMALL);
2409             goto f_err;
2410         }
2411
2412         rsa_decrypt = OPENSSL_malloc(RSA_size(rsa));
2413         if (rsa_decrypt == NULL) {
2414             al = SSL_AD_INTERNAL_ERROR;
2415             SSLerr(SSL_F_SSL3_GET_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
2416             goto f_err;
2417         }
2418
2419         /*
2420          * We must not leak whether a decryption failure occurs because of
2421          * Bleichenbacher's attack on PKCS #1 v1.5 RSA padding (see RFC 2246,
2422          * section 7.4.7.1). The code follows that advice of the TLS RFC and
2423          * generates a random premaster secret for the case that the decrypt
2424          * fails. See https://tools.ietf.org/html/rfc5246#section-7.4.7.1
2425          */
2426
2427         if (RAND_bytes(rand_premaster_secret,
2428                        sizeof(rand_premaster_secret)) <= 0) {
2429             goto err;
2430         }
2431
2432         decrypt_len = RSA_private_decrypt(PACKET_remaining(&enc_premaster),
2433                                           PACKET_data(&enc_premaster),
2434                                           rsa_decrypt, rsa, RSA_PKCS1_PADDING);
2435         ERR_clear_error();
2436
2437         /*
2438          * decrypt_len should be SSL_MAX_MASTER_KEY_LENGTH. decrypt_good will
2439          * be 0xff if so and zero otherwise.
2440          */
2441         decrypt_good =
2442             constant_time_eq_int_8(decrypt_len, SSL_MAX_MASTER_KEY_LENGTH);
2443
2444         /*
2445          * If the version in the decrypted pre-master secret is correct then
2446          * version_good will be 0xff, otherwise it'll be zero. The
2447          * Klima-Pokorny-Rosa extension of Bleichenbacher's attack
2448          * (http://eprint.iacr.org/2003/052/) exploits the version number
2449          * check as a "bad version oracle". Thus version checks are done in
2450          * constant time and are treated like any other decryption error.
2451          */
2452         version_good =
2453             constant_time_eq_8(rsa_decrypt[0],
2454                                (unsigned)(s->client_version >> 8));
2455         version_good &=
2456             constant_time_eq_8(rsa_decrypt[1],
2457                                (unsigned)(s->client_version & 0xff));
2458
2459         /*
2460          * The premaster secret must contain the same version number as the
2461          * ClientHello to detect version rollback attacks (strangely, the
2462          * protocol does not offer such protection for DH ciphersuites).
2463          * However, buggy clients exist that send the negotiated protocol
2464          * version instead if the server does not support the requested
2465          * protocol version. If SSL_OP_TLS_ROLLBACK_BUG is set, tolerate such
2466          * clients.
2467          */
2468         if (s->options & SSL_OP_TLS_ROLLBACK_BUG) {
2469             unsigned char workaround_good;
2470             workaround_good =
2471                 constant_time_eq_8(rsa_decrypt[0], (unsigned)(s->version >> 8));
2472             workaround_good &=
2473                 constant_time_eq_8(rsa_decrypt[1],
2474                                    (unsigned)(s->version & 0xff));
2475             version_good |= workaround_good;
2476         }
2477
2478         /*
2479          * Both decryption and version must be good for decrypt_good to
2480          * remain non-zero (0xff).
2481          */
2482         decrypt_good &= version_good;
2483
2484         /*
2485          * Now copy rand_premaster_secret over from p using
2486          * decrypt_good_mask. If decryption failed, then p does not
2487          * contain valid plaintext, however, a check above guarantees
2488          * it is still sufficiently large to read from.
2489          */
2490         for (j = 0; j < sizeof(rand_premaster_secret); j++) {
2491             rsa_decrypt[j] =
2492                 constant_time_select_8(decrypt_good, rsa_decrypt[j],
2493                                        rand_premaster_secret[j]);
2494         }
2495
2496         if (!ssl_generate_master_secret(s, rsa_decrypt,
2497                                         sizeof(rand_premaster_secret), 0)) {
2498             al = SSL_AD_INTERNAL_ERROR;
2499             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2500             goto f_err;
2501         }
2502         OPENSSL_free(rsa_decrypt);
2503         rsa_decrypt = NULL;
2504     } else
2505 #endif
2506 #ifndef OPENSSL_NO_DH
2507     if (alg_k & (SSL_kDHE | SSL_kDHr | SSL_kDHd | SSL_kDHEPSK)) {
2508         int idx = -1;
2509         EVP_PKEY *skey = NULL;
2510         PACKET bookmark = pkt;
2511         unsigned char shared[(OPENSSL_DH_MAX_MODULUS_BITS + 7) / 8];
2512
2513         if (!PACKET_get_net_2(&pkt, &i)) {
2514             if (alg_k & (SSL_kDHE | SSL_kDHEPSK)) {
2515                 al = SSL_AD_HANDSHAKE_FAILURE;
2516                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2517                        SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG);
2518                 goto f_err;
2519             }
2520             i = 0;
2521         }
2522         if (PACKET_remaining(&pkt) != i) {
2523             if (!(s->options & SSL_OP_SSLEAY_080_CLIENT_DH_BUG)) {
2524                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2525                        SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG);
2526                 goto err;
2527             } else {
2528                 pkt = bookmark;
2529                 i = PACKET_remaining(&pkt);
2530             }
2531         }
2532         if (alg_k & SSL_kDHr)
2533             idx = SSL_PKEY_DH_RSA;
2534         else if (alg_k & SSL_kDHd)
2535             idx = SSL_PKEY_DH_DSA;
2536         if (idx >= 0) {
2537             skey = s->cert->pkeys[idx].privatekey;
2538             if ((skey == NULL) ||
2539                 (skey->type != EVP_PKEY_DH) || (skey->pkey.dh == NULL)) {
2540                 al = SSL_AD_HANDSHAKE_FAILURE;
2541                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2542                        SSL_R_MISSING_RSA_CERTIFICATE);
2543                 goto f_err;
2544             }
2545             dh_srvr = skey->pkey.dh;
2546         } else if (s->s3->tmp.dh == NULL) {
2547             al = SSL_AD_HANDSHAKE_FAILURE;
2548             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2549                    SSL_R_MISSING_TMP_DH_KEY);
2550             goto f_err;
2551         } else
2552             dh_srvr = s->s3->tmp.dh;
2553
2554         if (n == 0L) {
2555             /* Get pubkey from cert */
2556             EVP_PKEY *clkey = X509_get_pubkey(s->session->peer);
2557             if (clkey) {
2558                 if (EVP_PKEY_cmp_parameters(clkey, skey) == 1)
2559                     dh_clnt = EVP_PKEY_get1_DH(clkey);
2560             }
2561             if (dh_clnt == NULL) {
2562                 al = SSL_AD_HANDSHAKE_FAILURE;
2563                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2564                        SSL_R_MISSING_TMP_DH_KEY);
2565                 goto f_err;
2566             }
2567             EVP_PKEY_free(clkey);
2568             pub = dh_clnt->pub_key;
2569         } else {
2570             if (!PACKET_get_bytes(&pkt, &data, i)) {
2571                 /* We already checked we have enough data */
2572                 al = SSL_AD_INTERNAL_ERROR;
2573                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2574                        ERR_R_INTERNAL_ERROR);
2575                 goto f_err;
2576             }
2577             pub = BN_bin2bn(data, i, NULL);
2578         }
2579         if (pub == NULL) {
2580             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, SSL_R_BN_LIB);
2581             goto err;
2582         }
2583
2584         i = DH_compute_key(shared, pub, dh_srvr);
2585
2586         if (i <= 0) {
2587             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_DH_LIB);
2588             BN_clear_free(pub);
2589             goto err;
2590         }
2591
2592         DH_free(s->s3->tmp.dh);
2593         s->s3->tmp.dh = NULL;
2594         if (dh_clnt)
2595             DH_free(dh_clnt);
2596         else
2597             BN_clear_free(pub);
2598         pub = NULL;
2599         if (!ssl_generate_master_secret(s, shared, i, 0)) {
2600             al = SSL_AD_INTERNAL_ERROR;
2601             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2602             goto f_err;
2603         }
2604         if (dh_clnt) {
2605             s->no_cert_verify = 1;
2606             return MSG_PROCESS_CONTINUE_PROCESSING;
2607         }
2608     } else
2609 #endif
2610
2611 #ifndef OPENSSL_NO_EC
2612     if (alg_k & (SSL_kECDHE | SSL_kECDHr | SSL_kECDHe | SSL_kECDHEPSK)) {
2613         int field_size = 0;
2614         const EC_KEY *tkey;
2615         const EC_GROUP *group;
2616         const BIGNUM *priv_key;
2617         unsigned char *shared;
2618
2619         /* initialize structures for server's ECDH key pair */
2620         if ((srvr_ecdh = EC_KEY_new()) == NULL) {
2621             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
2622             goto err;
2623         }
2624
2625         /* Let's get server private key and group information */
2626         if (alg_k & (SSL_kECDHr | SSL_kECDHe)) {
2627             /* use the certificate */
2628             tkey = s->cert->pkeys[SSL_PKEY_ECC].privatekey->pkey.ec;
2629         } else {
2630             /*
2631              * use the ephermeral values we saved when generating the
2632              * ServerKeyExchange msg.
2633              */
2634             tkey = s->s3->tmp.ecdh;
2635         }
2636
2637         group = EC_KEY_get0_group(tkey);
2638         priv_key = EC_KEY_get0_private_key(tkey);
2639
2640         if (!EC_KEY_set_group(srvr_ecdh, group) ||
2641             !EC_KEY_set_private_key(srvr_ecdh, priv_key)) {
2642             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_EC_LIB);
2643             goto err;
2644         }
2645
2646         /* Let's get client's public key */
2647         if ((clnt_ecpoint = EC_POINT_new(group)) == NULL) {
2648             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
2649             goto err;
2650         }
2651
2652         if (n == 0L) {
2653             /* Client Publickey was in Client Certificate */
2654
2655             if (alg_k & (SSL_kECDHE | SSL_kECDHEPSK)) {
2656                 al = SSL_AD_HANDSHAKE_FAILURE;
2657                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2658                        SSL_R_MISSING_TMP_ECDH_KEY);
2659                 goto f_err;
2660             }
2661             if (((clnt_pub_pkey = X509_get_pubkey(s->session->peer))
2662                  == NULL) || (clnt_pub_pkey->type != EVP_PKEY_EC)) {
2663                 /*
2664                  * XXX: For now, we do not support client authentication
2665                  * using ECDH certificates so this branch (n == 0L) of the
2666                  * code is never executed. When that support is added, we
2667                  * ought to ensure the key received in the certificate is
2668                  * authorized for key agreement. ECDH_compute_key implicitly
2669                  * checks that the two ECDH shares are for the same group.
2670                  */
2671                 al = SSL_AD_HANDSHAKE_FAILURE;
2672                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2673                        SSL_R_UNABLE_TO_DECODE_ECDH_CERTS);
2674                 goto f_err;
2675             }
2676
2677             if (EC_POINT_copy(clnt_ecpoint,
2678                               EC_KEY_get0_public_key(clnt_pub_pkey->
2679                                                      pkey.ec)) == 0) {
2680                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_EC_LIB);
2681                 goto err;
2682             }
2683             s->no_cert_verify = 1;
2684         } else {
2685             /*
2686              * Get client's public key from encoded point in the
2687              * ClientKeyExchange message.
2688              */
2689             if ((bn_ctx = BN_CTX_new()) == NULL) {
2690                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2691                        ERR_R_MALLOC_FAILURE);
2692                 goto err;
2693             }
2694
2695             /* Get encoded point length */
2696             if (!PACKET_get_1(&pkt, &i)) {
2697                 al = SSL_AD_DECODE_ERROR;
2698                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2699                        SSL_R_LENGTH_MISMATCH);
2700                 goto f_err;
2701             }
2702             if (!PACKET_get_bytes(&pkt, &data, i)
2703                     || PACKET_remaining(&pkt) != 0) {
2704                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_EC_LIB);
2705                 goto err;
2706             }
2707             if (EC_POINT_oct2point(group, clnt_ecpoint, data, i, bn_ctx) == 0) {
2708                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_EC_LIB);
2709                 goto err;
2710             }
2711         }
2712
2713         /* Compute the shared pre-master secret */
2714         field_size = EC_GROUP_get_degree(group);
2715         if (field_size <= 0) {
2716             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_ECDH_LIB);
2717             goto err;
2718         }
2719         shared = OPENSSL_malloc((field_size + 7) / 8);
2720         if (shared == NULL) {
2721             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
2722             goto err;
2723         }
2724         i = ECDH_compute_key(shared, (field_size + 7) / 8, clnt_ecpoint,
2725                              srvr_ecdh, NULL);
2726         if (i <= 0) {
2727             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_ECDH_LIB);
2728             OPENSSL_free(shared);
2729             goto err;
2730         }
2731
2732         EVP_PKEY_free(clnt_pub_pkey);
2733         EC_POINT_free(clnt_ecpoint);
2734         EC_KEY_free(srvr_ecdh);
2735         BN_CTX_free(bn_ctx);
2736         EC_KEY_free(s->s3->tmp.ecdh);
2737         s->s3->tmp.ecdh = NULL;
2738
2739         if (!ssl_generate_master_secret(s, shared, i, 1)) {
2740             al = SSL_AD_INTERNAL_ERROR;
2741             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2742             goto f_err;
2743         }
2744         return MSG_PROCESS_CONTINUE_PROCESSING;
2745     } else
2746 #endif
2747 #ifndef OPENSSL_NO_SRP
2748     if (alg_k & SSL_kSRP) {
2749         if (!PACKET_get_net_2(&pkt, &i)
2750                 || !PACKET_get_bytes(&pkt, &data, i)) {
2751             al = SSL_AD_DECODE_ERROR;
2752             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, SSL_R_BAD_SRP_A_LENGTH);
2753             goto f_err;
2754         }
2755         if ((s->srp_ctx.A = BN_bin2bn(data, i, NULL)) == NULL) {
2756             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_BN_LIB);
2757             goto err;
2758         }
2759         if (BN_ucmp(s->srp_ctx.A, s->srp_ctx.N) >= 0
2760             || BN_is_zero(s->srp_ctx.A)) {
2761             al = SSL_AD_ILLEGAL_PARAMETER;
2762             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2763                    SSL_R_BAD_SRP_PARAMETERS);
2764             goto f_err;
2765         }
2766         OPENSSL_free(s->session->srp_username);
2767         s->session->srp_username = BUF_strdup(s->srp_ctx.login);
2768         if (s->session->srp_username == NULL) {
2769             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
2770             goto err;
2771         }
2772
2773         if (!srp_generate_server_master_secret(s)) {
2774             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2775             goto err;
2776         }
2777     } else
2778 #endif                          /* OPENSSL_NO_SRP */
2779     if (alg_k & SSL_kGOST) {
2780         EVP_PKEY_CTX *pkey_ctx;
2781         EVP_PKEY *client_pub_pkey = NULL, *pk = NULL;
2782         unsigned char premaster_secret[32], *start;
2783         size_t outlen = 32, inlen;
2784         unsigned long alg_a;
2785         int Ttag, Tclass;
2786         long Tlen;
2787
2788         /* Get our certificate private key */
2789         alg_a = s->s3->tmp.new_cipher->algorithm_auth;
2790         if (alg_a & SSL_aGOST01)
2791             pk = s->cert->pkeys[SSL_PKEY_GOST01].privatekey;
2792
2793         pkey_ctx = EVP_PKEY_CTX_new(pk, NULL);
2794         EVP_PKEY_decrypt_init(pkey_ctx);
2795         /*
2796          * If client certificate is present and is of the same type, maybe
2797          * use it for key exchange.  Don't mind errors from
2798          * EVP_PKEY_derive_set_peer, because it is completely valid to use a
2799          * client certificate for authorization only.
2800          */
2801         client_pub_pkey = X509_get_pubkey(s->session->peer);
2802         if (client_pub_pkey) {
2803             if (EVP_PKEY_derive_set_peer(pkey_ctx, client_pub_pkey) <= 0)
2804                 ERR_clear_error();
2805         }
2806         /* Decrypt session key */
2807         if (!PACKET_get_bytes(&pkt, &data, n)) {
2808             al = SSL_AD_INTERNAL_ERROR;
2809             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2810             goto f_err;
2811         }
2812         if (ASN1_get_object
2813             ((const unsigned char **)&data, &Tlen, &Ttag, &Tclass,
2814              n) != V_ASN1_CONSTRUCTED || Ttag != V_ASN1_SEQUENCE
2815             || Tclass != V_ASN1_UNIVERSAL) {
2816             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2817                    SSL_R_DECRYPTION_FAILED);
2818             goto gerr;
2819         }
2820         start = data;
2821         inlen = Tlen;
2822         if (EVP_PKEY_decrypt
2823             (pkey_ctx, premaster_secret, &outlen, start, inlen) <= 0) {
2824             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2825                    SSL_R_DECRYPTION_FAILED);
2826             goto gerr;
2827         }
2828         /* Generate master secret */
2829         if (!ssl_generate_master_secret(s, premaster_secret,
2830                                         sizeof(premaster_secret), 0)) {
2831             al = SSL_AD_INTERNAL_ERROR;
2832             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2833             goto f_err;
2834         }
2835         /* Check if pubkey from client certificate was used */
2836         if (EVP_PKEY_CTX_ctrl
2837             (pkey_ctx, -1, -1, EVP_PKEY_CTRL_PEER_KEY, 2, NULL) > 0)
2838             s->no_cert_verify = 1;
2839
2840         EVP_PKEY_free(client_pub_pkey);
2841         EVP_PKEY_CTX_free(pkey_ctx);
2842         return MSG_PROCESS_CONTINUE_PROCESSING;
2843  gerr:
2844         EVP_PKEY_free(client_pub_pkey);
2845         EVP_PKEY_CTX_free(pkey_ctx);
2846         goto err;
2847     } else {
2848         al = SSL_AD_HANDSHAKE_FAILURE;
2849         SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, SSL_R_UNKNOWN_CIPHER_TYPE);
2850         goto f_err;
2851     }
2852
2853     return MSG_PROCESS_CONTINUE_PROCESSING;
2854  f_err:
2855     ssl3_send_alert(s, SSL3_AL_FATAL, al);
2856 #if !defined(OPENSSL_NO_DH) || !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_EC) || defined(OPENSSL_NO_SRP)
2857  err:
2858 #endif
2859 #ifndef OPENSSL_NO_EC
2860     EVP_PKEY_free(clnt_pub_pkey);
2861     EC_POINT_free(clnt_ecpoint);
2862     EC_KEY_free(srvr_ecdh);
2863     BN_CTX_free(bn_ctx);
2864     OPENSSL_free(rsa_decrypt);
2865 #endif
2866 #ifndef OPENSSL_NO_PSK
2867     OPENSSL_clear_free(s->s3->tmp.psk, s->s3->tmp.psklen);
2868     s->s3->tmp.psk = NULL;
2869 #endif
2870     statem_set_error(s);
2871     return MSG_PROCESS_ERROR;
2872 }
2873
2874 int ssl3_get_cert_verify(SSL *s)
2875 {
2876     int ok, ret = 1;
2877     long n;
2878
2879     /*
2880      * We should only process a CertificateVerify message if we have received
2881      * a Certificate from the client. If so then |s->session->peer| will be non
2882      * NULL. In some instances a CertificateVerify message is not required even
2883      * if the peer has sent a Certificate (e.g. such as in the case of static
2884      * DH). In that case the ClientKeyExchange processing will skip the
2885      * CertificateVerify state so we should not arrive here.
2886      */
2887     if (s->session->peer == NULL) {
2888         goto end;
2889     }
2890
2891     n = s->method->ssl_get_message(s,
2892                                    SSL3_ST_SR_CERT_VRFY_A,
2893                                    SSL3_ST_SR_CERT_VRFY_B,
2894                                    SSL3_MT_CERTIFICATE_VERIFY,
2895                                    SSL3_RT_MAX_PLAIN_LENGTH, &ok);
2896
2897     if (!ok)
2898         return ((int)n);
2899
2900     if (tls_process_cert_verify(s, n) == 0)
2901         ret = -1;
2902
2903  end:
2904     BIO_free(s->s3->handshake_buffer);
2905     s->s3->handshake_buffer = NULL;
2906     return ret;
2907 }
2908
2909
2910 enum MSG_PROCESS_RETURN tls_process_cert_verify(SSL *s, long n)
2911 {
2912     EVP_PKEY *pkey = NULL;
2913     unsigned char *sig, *data;
2914     int al, ret = MSG_PROCESS_ERROR;
2915     int type = 0, i, j;
2916     unsigned int len;
2917     X509 *peer;
2918     const EVP_MD *md = NULL;
2919     EVP_MD_CTX mctx;
2920     PACKET pkt;
2921     EVP_MD_CTX_init(&mctx);
2922
2923     peer = s->session->peer;
2924     pkey = X509_get_pubkey(peer);
2925     type = X509_certificate_type(peer, pkey);
2926
2927     if (!(type & EVP_PKT_SIGN)) {
2928         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY,
2929                SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE);
2930         al = SSL_AD_ILLEGAL_PARAMETER;
2931         goto f_err;
2932     }
2933
2934     /* we now have a signature that we need to verify */
2935     if (!PACKET_buf_init(&pkt, s->init_msg, n)) {
2936         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_INTERNAL_ERROR);
2937         al = SSL_AD_INTERNAL_ERROR;
2938         goto f_err;
2939     }
2940     /* Check for broken implementations of GOST ciphersuites */
2941     /*
2942      * If key is GOST and n is exactly 64, it is bare signature without
2943      * length field
2944      */
2945     if (n == 64 && pkey->type == NID_id_GostR3410_2001) {
2946         len = 64;
2947     } else {
2948         if (SSL_USE_SIGALGS(s)) {
2949             int rv;
2950
2951             if (!PACKET_get_bytes(&pkt, &sig, 2)) {
2952                 al = SSL_AD_DECODE_ERROR;
2953                 goto f_err;
2954             }
2955             rv = tls12_check_peer_sigalg(&md, s, sig, pkey);
2956             if (rv == -1) {
2957                 al = SSL_AD_INTERNAL_ERROR;
2958                 goto f_err;
2959             } else if (rv == 0) {
2960                 al = SSL_AD_DECODE_ERROR;
2961                 goto f_err;
2962             }
2963 #ifdef SSL_DEBUG
2964             fprintf(stderr, "USING TLSv1.2 HASH %s\n", EVP_MD_name(md));
2965 #endif
2966         }
2967         if (!PACKET_get_net_2(&pkt, &len)) {
2968             SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_LENGTH_MISMATCH);
2969             al = SSL_AD_DECODE_ERROR;
2970             goto f_err;
2971         }
2972     }
2973     j = EVP_PKEY_size(pkey);
2974     if (((int)len > j) || ((int)PACKET_remaining(&pkt) > j) || (n <= 0)) {
2975         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_WRONG_SIGNATURE_SIZE);
2976         al = SSL_AD_DECODE_ERROR;
2977         goto f_err;
2978     }
2979     if (!PACKET_get_bytes(&pkt, &data, len)) {
2980         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_LENGTH_MISMATCH);
2981         al = SSL_AD_DECODE_ERROR;
2982         goto f_err;
2983     }
2984
2985     if (SSL_USE_SIGALGS(s)) {
2986         long hdatalen = 0;
2987         void *hdata;
2988         hdatalen = BIO_get_mem_data(s->s3->handshake_buffer, &hdata);
2989         if (hdatalen <= 0) {
2990             SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_INTERNAL_ERROR);
2991             al = SSL_AD_INTERNAL_ERROR;
2992             goto f_err;
2993         }
2994 #ifdef SSL_DEBUG
2995         fprintf(stderr, "Using TLS 1.2 with client verify alg %s\n",
2996                 EVP_MD_name(md));
2997 #endif
2998         if (!EVP_VerifyInit_ex(&mctx, md, NULL)
2999             || !EVP_VerifyUpdate(&mctx, hdata, hdatalen)) {
3000             SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_EVP_LIB);
3001             al = SSL_AD_INTERNAL_ERROR;
3002             goto f_err;
3003         }
3004
3005         if (EVP_VerifyFinal(&mctx, data, len, pkey) <= 0) {
3006             al = SSL_AD_DECRYPT_ERROR;
3007             SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_BAD_SIGNATURE);
3008             goto f_err;
3009         }
3010     } else
3011 #ifndef OPENSSL_NO_RSA
3012     if (pkey->type == EVP_PKEY_RSA) {
3013         i = RSA_verify(NID_md5_sha1, s->s3->tmp.cert_verify_md,
3014                        MD5_DIGEST_LENGTH + SHA_DIGEST_LENGTH, data, len,
3015                        pkey->pkey.rsa);
3016         if (i < 0) {
3017             al = SSL_AD_DECRYPT_ERROR;
3018             SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_BAD_RSA_DECRYPT);
3019             goto f_err;
3020         }
3021         if (i == 0) {
3022             al = SSL_AD_DECRYPT_ERROR;
3023             SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_BAD_RSA_SIGNATURE);
3024             goto f_err;
3025         }
3026     } else
3027 #endif
3028 #ifndef OPENSSL_NO_DSA
3029     if (pkey->type == EVP_PKEY_DSA) {
3030         j = DSA_verify(pkey->save_type,
3031                        &(s->s3->tmp.cert_verify_md[MD5_DIGEST_LENGTH]),
3032                        SHA_DIGEST_LENGTH, data, len, pkey->pkey.dsa);
3033         if (j <= 0) {
3034             /* bad signature */
3035             al = SSL_AD_DECRYPT_ERROR;
3036             SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_BAD_DSA_SIGNATURE);
3037             goto f_err;
3038         }
3039     } else
3040 #endif
3041 #ifndef OPENSSL_NO_EC
3042     if (pkey->type == EVP_PKEY_EC) {
3043         j = ECDSA_verify(pkey->save_type,
3044                          &(s->s3->tmp.cert_verify_md[MD5_DIGEST_LENGTH]),
3045                          SHA_DIGEST_LENGTH, data, len, pkey->pkey.ec);
3046         if (j <= 0) {
3047             /* bad signature */
3048             al = SSL_AD_DECRYPT_ERROR;
3049             SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_BAD_ECDSA_SIGNATURE);
3050             goto f_err;
3051         }
3052     } else
3053 #endif
3054     if (pkey->type == NID_id_GostR3410_2001) {
3055         unsigned char signature[64];
3056         int idx;
3057         EVP_PKEY_CTX *pctx = EVP_PKEY_CTX_new(pkey, NULL);
3058         EVP_PKEY_verify_init(pctx);
3059         if (len != 64) {
3060             fprintf(stderr, "GOST signature length is %d", len);
3061         }
3062         for (idx = 0; idx < 64; idx++) {
3063             signature[63 - idx] = data[idx];
3064         }
3065         j = EVP_PKEY_verify(pctx, signature, 64, s->s3->tmp.cert_verify_md,
3066                             32);
3067         EVP_PKEY_CTX_free(pctx);
3068         if (j <= 0) {
3069             al = SSL_AD_DECRYPT_ERROR;
3070             SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_BAD_ECDSA_SIGNATURE);
3071             goto f_err;
3072         }
3073     } else {
3074         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_INTERNAL_ERROR);
3075         al = SSL_AD_UNSUPPORTED_CERTIFICATE;
3076         goto f_err;
3077     }
3078
3079     ret = MSG_PROCESS_CONTINUE_READING;
3080     if (0) {
3081  f_err:
3082         ssl3_send_alert(s, SSL3_AL_FATAL, al);
3083         statem_set_error(s);
3084     }
3085     BIO_free(s->s3->handshake_buffer);
3086     s->s3->handshake_buffer = NULL;
3087     EVP_MD_CTX_cleanup(&mctx);
3088     EVP_PKEY_free(pkey);
3089     return ret;
3090 }
3091
3092 int ssl3_get_client_certificate(SSL *s)
3093 {
3094     int ok, al;
3095     long n;
3096
3097     n = s->method->ssl_get_message(s,
3098                                    SSL3_ST_SR_CERT_A,
3099                                    SSL3_ST_SR_CERT_B,
3100                                    -1, s->max_cert_list, &ok);
3101
3102     if (!ok)
3103         return ((int)n);
3104
3105     if (s->s3->tmp.message_type == SSL3_MT_CLIENT_KEY_EXCHANGE) {
3106         if ((s->verify_mode & SSL_VERIFY_PEER) &&
3107             (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) {
3108             SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,
3109                    SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
3110             al = SSL_AD_HANDSHAKE_FAILURE;
3111             goto f_err;
3112         }
3113         /*
3114          * If tls asked for a client cert, the client must return a 0 list
3115          */
3116         if ((s->version > SSL3_VERSION) && s->s3->tmp.cert_request) {
3117             SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE,
3118                    SSL_R_TLS_PEER_DID_NOT_RESPOND_WITH_CERTIFICATE_LIST);
3119             al = SSL_AD_UNEXPECTED_MESSAGE;
3120             goto f_err;
3121         }
3122         s->s3->tmp.reuse_message = 1;
3123         return 1;
3124     }
3125
3126     if (s->s3->tmp.message_type != SSL3_MT_CERTIFICATE) {
3127         al = SSL_AD_UNEXPECTED_MESSAGE;
3128         SSLerr(SSL_F_SSL3_GET_CLIENT_CERTIFICATE, SSL_R_WRONG_MESSAGE_TYPE);
3129         goto f_err;
3130     }
3131
3132     if (tls_process_client_certificate(s, n) == 0)
3133         goto f_err;
3134
3135     return 1;
3136  f_err:
3137     ssl3_send_alert(s, SSL3_AL_FATAL, al);
3138     s->state = SSL_ST_ERR;
3139     return -1;
3140 }
3141
3142 enum MSG_PROCESS_RETURN tls_process_client_certificate(SSL *s, long n)
3143 {
3144     int i, al, ret = MSG_PROCESS_ERROR;
3145     X509 *x = NULL;
3146     unsigned long l, llen;
3147     const unsigned char *certstart;
3148     unsigned char *certbytes;
3149     STACK_OF(X509) *sk = NULL;
3150     PACKET pkt, spkt;
3151
3152     if (!PACKET_buf_init(&pkt, s->init_msg, n)) {
3153         al = SSL_AD_INTERNAL_ERROR;
3154         SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, ERR_R_INTERNAL_ERROR);
3155         goto f_err;
3156     }
3157
3158     if ((sk = sk_X509_new_null()) == NULL) {
3159         SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, ERR_R_MALLOC_FAILURE);
3160         goto f_err;
3161     }
3162
3163     if (!PACKET_get_net_3(&pkt, &llen)
3164             || !PACKET_get_sub_packet(&pkt, &spkt, llen)
3165             || PACKET_remaining(&pkt) != 0) {
3166         al = SSL_AD_DECODE_ERROR;
3167         SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, SSL_R_LENGTH_MISMATCH);
3168         goto f_err;
3169     }
3170
3171     while (PACKET_remaining(&spkt) > 0) {
3172         if (!PACKET_get_net_3(&spkt, &l)
3173                 || !PACKET_get_bytes(&spkt, &certbytes, l)) {
3174             al = SSL_AD_DECODE_ERROR;
3175             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
3176                    SSL_R_CERT_LENGTH_MISMATCH);
3177             goto f_err;
3178         }
3179
3180         certstart = certbytes;
3181         x = d2i_X509(NULL, (const unsigned char **)&certbytes, l);
3182         if (x == NULL) {
3183             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, ERR_R_ASN1_LIB);
3184             goto f_err;
3185         }
3186         if (certbytes != (certstart + l)) {
3187             al = SSL_AD_DECODE_ERROR;
3188             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
3189                    SSL_R_CERT_LENGTH_MISMATCH);
3190             goto f_err;
3191         }
3192         if (!sk_X509_push(sk, x)) {
3193             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, ERR_R_MALLOC_FAILURE);
3194             goto f_err;
3195         }
3196         x = NULL;
3197     }
3198
3199     if (sk_X509_num(sk) <= 0) {
3200         /* TLS does not mind 0 certs returned */
3201         if (s->version == SSL3_VERSION) {
3202             al = SSL_AD_HANDSHAKE_FAILURE;
3203             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
3204                    SSL_R_NO_CERTIFICATES_RETURNED);
3205             goto f_err;
3206         }
3207         /* Fail for TLS only if we required a certificate */
3208         else if ((s->verify_mode & SSL_VERIFY_PEER) &&
3209                  (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) {
3210             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
3211                    SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
3212             al = SSL_AD_HANDSHAKE_FAILURE;
3213             goto f_err;
3214         }
3215         /* No client certificate so digest cached records */
3216         if (s->s3->handshake_buffer && !ssl3_digest_cached_records(s, 0)) {
3217             al = SSL_AD_INTERNAL_ERROR;
3218             goto f_err;
3219         }
3220     } else {
3221         EVP_PKEY *pkey;
3222         i = ssl_verify_cert_chain(s, sk);
3223         if (i <= 0) {
3224             al = ssl_verify_alarm_type(s->verify_result);
3225             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
3226                    SSL_R_CERTIFICATE_VERIFY_FAILED);
3227             goto f_err;
3228         }
3229         if (i > 1) {
3230             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, i);
3231             al = SSL_AD_HANDSHAKE_FAILURE;
3232             goto f_err;
3233         }
3234         pkey = X509_get_pubkey(sk_X509_value(sk, 0));
3235         if (pkey == NULL) {
3236             al = SSL3_AD_HANDSHAKE_FAILURE;
3237             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
3238                    SSL_R_UNKNOWN_CERTIFICATE_TYPE);
3239             goto f_err;
3240         }
3241         EVP_PKEY_free(pkey);
3242     }
3243
3244     X509_free(s->session->peer);
3245     s->session->peer = sk_X509_shift(sk);
3246     s->session->verify_result = s->verify_result;
3247
3248     sk_X509_pop_free(s->session->peer_chain, X509_free);
3249     s->session->peer_chain = sk;
3250     /*
3251      * Inconsistency alert: cert_chain does *not* include the peer's own
3252      * certificate, while we do include it in s3_clnt.c
3253      */
3254     sk = NULL;
3255     ret = MSG_PROCESS_CONTINUE_READING;
3256     goto done;
3257
3258  f_err:
3259     ssl3_send_alert(s, SSL3_AL_FATAL, al);
3260     statem_set_error(s);
3261  done:
3262     X509_free(x);
3263     sk_X509_pop_free(sk, X509_free);
3264     return ret;
3265 }
3266
3267 int ssl3_send_server_certificate(SSL *s)
3268 {
3269     if (s->state == SSL3_ST_SW_CERT_A) {
3270         if (tls_construct_server_certificate(s) == 0)
3271             return 0;
3272         s->state = SSL3_ST_SW_CERT_B;
3273     }
3274
3275     /* SSL3_ST_SW_CERT_B */
3276     return ssl_do_write(s);
3277 }
3278
3279 int tls_construct_server_certificate(SSL *s)
3280 {
3281     CERT_PKEY *cpk;
3282
3283     cpk = ssl_get_server_send_pkey(s);
3284     if (cpk == NULL) {
3285         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_CERTIFICATE, ERR_R_INTERNAL_ERROR);
3286         statem_set_error(s);
3287         return 0;
3288     }
3289
3290     if (!ssl3_output_cert_chain(s, cpk)) {
3291         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_CERTIFICATE, ERR_R_INTERNAL_ERROR);
3292         statem_set_error(s);
3293         return 0;
3294     }
3295
3296     return 1;
3297 }
3298
3299 /* send a new session ticket (not necessarily for a new session) */
3300 int ssl3_send_newsession_ticket(SSL *s)
3301 {
3302     if (s->state == SSL3_ST_SW_SESSION_TICKET_A) {
3303         if (tls_construct_new_session_ticket(s) == 0)
3304             return -1;
3305
3306         s->state = SSL3_ST_SW_SESSION_TICKET_B;
3307     }
3308
3309     /* SSL3_ST_SW_SESSION_TICKET_B */
3310     return ssl_do_write(s);
3311 }
3312
3313 int tls_construct_new_session_ticket(SSL *s)
3314 {
3315     unsigned char *senc = NULL;
3316     EVP_CIPHER_CTX ctx;
3317     HMAC_CTX hctx;
3318     unsigned char *p, *macstart;
3319     const unsigned char *const_p;
3320     int len, slen_full, slen;
3321     SSL_SESSION *sess;
3322     unsigned int hlen;
3323     SSL_CTX *tctx = s->initial_ctx;
3324     unsigned char iv[EVP_MAX_IV_LENGTH];
3325     unsigned char key_name[16];
3326
3327     /* get session encoding length */
3328     slen_full = i2d_SSL_SESSION(s->session, NULL);
3329     /*
3330      * Some length values are 16 bits, so forget it if session is too
3331      * long
3332      */
3333     if (slen_full == 0 || slen_full > 0xFF00) {
3334         statem_set_error(s);
3335         return 0;
3336     }
3337     senc = OPENSSL_malloc(slen_full);
3338     if (!senc) {
3339         statem_set_error(s);
3340         return 0;
3341     }
3342
3343     EVP_CIPHER_CTX_init(&ctx);
3344     HMAC_CTX_init(&hctx);
3345
3346     p = senc;
3347     if (!i2d_SSL_SESSION(s->session, &p))
3348         goto err;
3349
3350     /*
3351      * create a fresh copy (not shared with other threads) to clean up
3352      */
3353     const_p = senc;
3354     sess = d2i_SSL_SESSION(NULL, &const_p, slen_full);
3355     if (sess == NULL)
3356         goto err;
3357     sess->session_id_length = 0; /* ID is irrelevant for the ticket */
3358
3359     slen = i2d_SSL_SESSION(sess, NULL);
3360     if (slen == 0 || slen > slen_full) { /* shouldn't ever happen */
3361         SSL_SESSION_free(sess);
3362         goto err;
3363     }
3364     p = senc;
3365     if (!i2d_SSL_SESSION(sess, &p)) {
3366         SSL_SESSION_free(sess);
3367         goto err;
3368     }
3369     SSL_SESSION_free(sess);
3370
3371     /*-
3372      * Grow buffer if need be: the length calculation is as
3373      * follows handshake_header_length +
3374      * 4 (ticket lifetime hint) + 2 (ticket length) +
3375      * 16 (key name) + max_iv_len (iv length) +
3376      * session_length + max_enc_block_size (max encrypted session
3377      * length) + max_md_size (HMAC).
3378      */
3379     if (!BUF_MEM_grow(s->init_buf,
3380                       SSL_HM_HEADER_LENGTH(s) + 22 + EVP_MAX_IV_LENGTH +
3381                       EVP_MAX_BLOCK_LENGTH + EVP_MAX_MD_SIZE + slen))
3382         goto err;
3383
3384     p = ssl_handshake_start(s);
3385     /*
3386      * Initialize HMAC and cipher contexts. If callback present it does
3387      * all the work otherwise use generated values from parent ctx.
3388      */
3389     if (tctx->tlsext_ticket_key_cb) {
3390         if (tctx->tlsext_ticket_key_cb(s, key_name, iv, &ctx,
3391                                        &hctx, 1) < 0)
3392             goto err;
3393     } else {
3394         if (RAND_bytes(iv, 16) <= 0)
3395             goto err;
3396         if (!EVP_EncryptInit_ex(&ctx, EVP_aes_128_cbc(), NULL,
3397                                 tctx->tlsext_tick_aes_key, iv))
3398             goto err;
3399         if (!HMAC_Init_ex(&hctx, tctx->tlsext_tick_hmac_key, 16,
3400                           EVP_sha256(), NULL))
3401             goto err;
3402         memcpy(key_name, tctx->tlsext_tick_key_name, 16);
3403     }
3404
3405     /*
3406      * Ticket lifetime hint (advisory only): We leave this unspecified
3407      * for resumed session (for simplicity), and guess that tickets for
3408      * new sessions will live as long as their sessions.
3409      */
3410     l2n(s->hit ? 0 : s->session->timeout, p);
3411
3412     /* Skip ticket length for now */
3413     p += 2;
3414     /* Output key name */
3415     macstart = p;
3416     memcpy(p, key_name, 16);
3417     p += 16;
3418     /* output IV */
3419     memcpy(p, iv, EVP_CIPHER_CTX_iv_length(&ctx));
3420     p += EVP_CIPHER_CTX_iv_length(&ctx);
3421     /* Encrypt session data */
3422     if (!EVP_EncryptUpdate(&ctx, p, &len, senc, slen))
3423         goto err;
3424     p += len;
3425     if (!EVP_EncryptFinal(&ctx, p, &len))
3426         goto err;
3427     p += len;
3428
3429     if (!HMAC_Update(&hctx, macstart, p - macstart))
3430         goto err;
3431     if (!HMAC_Final(&hctx, p, &hlen))
3432         goto err;
3433
3434     EVP_CIPHER_CTX_cleanup(&ctx);
3435     HMAC_CTX_cleanup(&hctx);
3436
3437     p += hlen;
3438     /* Now write out lengths: p points to end of data written */
3439     /* Total length */
3440     len = p - ssl_handshake_start(s);
3441     /* Skip ticket lifetime hint */
3442     p = ssl_handshake_start(s) + 4;
3443     s2n(len - 6, p);
3444     if (!ssl_set_handshake_header(s, SSL3_MT_NEWSESSION_TICKET, len))
3445         goto err;
3446     OPENSSL_free(senc);
3447
3448     return 1;
3449  err:
3450     OPENSSL_free(senc);
3451     EVP_CIPHER_CTX_cleanup(&ctx);
3452     HMAC_CTX_cleanup(&hctx);
3453     statem_set_error(s);
3454     return 0;
3455 }
3456
3457 int ssl3_send_cert_status(SSL *s)
3458 {
3459     if (s->state == SSL3_ST_SW_CERT_STATUS_A) {
3460         if (tls_construct_cert_status(s) == 0)
3461             return -1;
3462
3463         s->state = SSL3_ST_SW_CERT_STATUS_B;
3464     }
3465
3466     /* SSL3_ST_SW_CERT_STATUS_B */
3467     return (ssl3_do_write(s, SSL3_RT_HANDSHAKE));
3468 }
3469
3470 int tls_construct_cert_status(SSL *s)
3471 {
3472     unsigned char *p;
3473     /*-
3474      * Grow buffer if need be: the length calculation is as
3475      * follows 1 (message type) + 3 (message length) +
3476      * 1 (ocsp response type) + 3 (ocsp response length)
3477      * + (ocsp response)
3478      */
3479     if (!BUF_MEM_grow(s->init_buf, 8 + s->tlsext_ocsp_resplen)) {
3480         statem_set_error(s);
3481         return 0;
3482     }
3483
3484     p = (unsigned char *)s->init_buf->data;
3485
3486     /* do the header */
3487     *(p++) = SSL3_MT_CERTIFICATE_STATUS;
3488     /* message length */
3489     l2n3(s->tlsext_ocsp_resplen + 4, p);
3490     /* status type */
3491     *(p++) = s->tlsext_status_type;
3492     /* length of OCSP response */
3493     l2n3(s->tlsext_ocsp_resplen, p);
3494     /* actual response */
3495     memcpy(p, s->tlsext_ocsp_resp, s->tlsext_ocsp_resplen);
3496     /* number of bytes to write */
3497     s->init_num = 8 + s->tlsext_ocsp_resplen;
3498     s->init_off = 0;
3499
3500     return 1;
3501 }
3502
3503 #ifndef OPENSSL_NO_NEXTPROTONEG
3504 /*