ssl/s3_clnt.c

   1 /* ssl/s3_clnt.c */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   5  * This package is an SSL implementation written
   6  * by Eric Young (eay@cryptsoft.com).
   7  * The implementation was written so as to conform with Netscapes SSL.
   8  *
   9  * This library is free for commercial and non-commercial use as long as
  10  * the following conditions are aheared to.  The following conditions
  11  * apply to all code found in this distribution, be it the RC4, RSA,
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13  * included with this distribution is covered by the same copyright terms
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15  *
  16  * Copyright remains Eric Young's, and as such any Copyright notices in
  17  * the code are not to be removed.
  18  * If this package is used in a product, Eric Young should be given attribution
  19  * as the author of the parts of the library used.
  20  * This can be in the form of a textual message at program startup or
  21  * in documentation (online or textual) provided with the package.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *    "This product includes cryptographic software written by
  34  *     Eric Young (eay@cryptsoft.com)"
  35  *    The word 'cryptographic' can be left out if the rouines from the library
  36  *    being used are not cryptographic related :-).
  37  * 4. If you include any Windows specific code (or a derivative thereof) from
  38  *    the apps directory (application code) you must include an acknowledgement:
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  *
  53  * The licence and distribution terms for any publically available version or
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55  * copied and put under another distribution licence
  56  * [including the GNU Public Licence.]
  57  */
  58 /* ====================================================================
  59  * Copyright (c) 1998-2007 The OpenSSL Project.  All rights reserved.
  60  *
  61  * Redistribution and use in source and binary forms, with or without
  62  * modification, are permitted provided that the following conditions
  63  * are met:
  64  *
  65  * 1. Redistributions of source code must retain the above copyright
  66  *    notice, this list of conditions and the following disclaimer.
  67  *
  68  * 2. Redistributions in binary form must reproduce the above copyright
  69  *    notice, this list of conditions and the following disclaimer in
  70  *    the documentation and/or other materials provided with the
  71  *    distribution.
  72  *
  73  * 3. All advertising materials mentioning features or use of this
  74  *    software must display the following acknowledgment:
  75  *    "This product includes software developed by the OpenSSL Project
  76  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  77  *
  78  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  79  *    endorse or promote products derived from this software without
  80  *    prior written permission. For written permission, please contact
  81  *    openssl-core@openssl.org.
  82  *
  83  * 5. Products derived from this software may not be called "OpenSSL"
  84  *    nor may "OpenSSL" appear in their names without prior written
  85  *    permission of the OpenSSL Project.
  86  *
  87  * 6. Redistributions of any form whatsoever must retain the following
  88  *    acknowledgment:
  89  *    "This product includes software developed by the OpenSSL Project
  90  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  91  *
  92  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  93  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  94  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  95  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  96  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  97  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  98  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  99  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 100  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 101  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 102  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 103  * OF THE POSSIBILITY OF SUCH DAMAGE.
 104  * ====================================================================
 105  *
 106  * This product includes cryptographic software written by Eric Young
 107  * (eay@cryptsoft.com).  This product includes software written by Tim
 108  * Hudson (tjh@cryptsoft.com).
 109  *
 110  */
 111 /* ====================================================================
 112  * 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 #include <stdio.h>
 152 #include "ssl_locl.h"
 153 #include <openssl/buffer.h>
 154 #include <openssl/rand.h>
 155 #include <openssl/objects.h>
 156 #include <openssl/evp.h>
 157 #include <openssl/md5.h>
 158 #ifndef OPENSSL_NO_DH
 159 # include <openssl/dh.h>
 160 #endif
 161 #include <openssl/bn.h>
 162 #ifndef OPENSSL_NO_ENGINE
 163 # include <openssl/engine.h>
 164 #endif
 165
 166 static int ssl_set_version(SSL *s);
 167 static int ca_dn_cmp(const X509_NAME *const *a, const X509_NAME *const *b);
 168 #if 0
 169 /*
 170  * Temporarily disabled during development of new state machine code.
 171  * TODO: Clean me up
 172  */
 173 static int ssl3_check_change(SSL *s);
 174 #endif
 175 static int ssl_cipher_list_to_bytes(SSL *s, STACK_OF(SSL_CIPHER) *sk,
 176                                     unsigned char *p);
 177
 178
 179 #if 0
 180 /*
 181  * Temporarily disabled during development of new state machine code.
 182  * TODO: Clean me up
 183  */
 184 int ssl3_connect(SSL *s)
 185 {
 186     BUF_MEM *buf = NULL;
 187     unsigned long Time = (unsigned long)time(NULL);
 188     void (*cb) (const SSL *ssl, int type, int val) = NULL;
 189     int ret = -1;
 190     int new_state, state, skip = 0;
 191
 192     RAND_add(&Time, sizeof(Time), 0);
 193     ERR_clear_error();
 194     clear_sys_error();
 195
 196     if (s->info_callback != NULL)
 197         cb = s->info_callback;
 198     else if (s->ctx->info_callback != NULL)
 199         cb = s->ctx->info_callback;
 200
 201     s->in_handshake++;
 202     if (!SSL_in_init(s) || SSL_in_before(s)) {
 203         if (!SSL_clear(s))
 204             return -1;
 205     }
 206
 207 #ifndef OPENSSL_NO_HEARTBEATS
 208     /*
 209      * If we're awaiting a HeartbeatResponse, pretend we already got and
 210      * don't await it anymore, because Heartbeats don't make sense during
 211      * handshakes anyway.
 212      */
 213     if (s->tlsext_hb_pending) {
 214         s->tlsext_hb_pending = 0;
 215         s->tlsext_hb_seq++;
 216     }
 217 #endif
 218
 219     for (;;) {
 220         state = s->state;
 221
 222         switch (s->state) {
 223         case SSL_ST_RENEGOTIATE:
 224             s->renegotiate = 1;
 225             s->state = SSL_ST_CONNECT;
 226             s->ctx->stats.sess_connect_renegotiate++;
 227             /* break */
 228         case SSL_ST_BEFORE:
 229         case SSL_ST_CONNECT:
 230         case SSL_ST_BEFORE | SSL_ST_CONNECT:
 231         case SSL_ST_OK | SSL_ST_CONNECT:
 232
 233             s->server = 0;
 234             if (cb != NULL)
 235                 cb(s, SSL_CB_HANDSHAKE_START, 1);
 236
 237             if ((s->version >> 8) != SSL3_VERSION_MAJOR
 238                     && s->version != TLS_ANY_VERSION) {
 239                 SSLerr(SSL_F_SSL3_CONNECT, ERR_R_INTERNAL_ERROR);
 240                 s->state = SSL_ST_ERR;
 241                 ret = -1;
 242                 goto end;
 243             }
 244
 245             if (s->version != TLS_ANY_VERSION &&
 246                     !ssl_security(s, SSL_SECOP_VERSION, 0, s->version, NULL)) {
 247                 SSLerr(SSL_F_SSL3_CONNECT, SSL_R_VERSION_TOO_LOW);
 248                 return -1;
 249             }
 250
 251             /* s->version=SSL3_VERSION; */
 252             s->type = SSL_ST_CONNECT;
 253
 254             if (s->init_buf == NULL) {
 255                 if ((buf = BUF_MEM_new()) == NULL) {
 256                     ret = -1;
 257                     s->state = SSL_ST_ERR;
 258                     goto end;
 259                 }
 260                 if (!BUF_MEM_grow(buf, SSL3_RT_MAX_PLAIN_LENGTH)) {
 261                     ret = -1;
 262                     s->state = SSL_ST_ERR;
 263                     goto end;
 264                 }
 265                 s->init_buf = buf;
 266                 buf = NULL;
 267             }
 268
 269             if (!ssl3_setup_buffers(s)) {
 270                 ret = -1;
 271                 goto end;
 272             }
 273
 274             /* setup buffing BIO */
 275             if (!ssl_init_wbio_buffer(s, 0)) {
 276                 ret = -1;
 277                 s->state = SSL_ST_ERR;
 278                 goto end;
 279             }
 280
 281             /* don't push the buffering BIO quite yet */
 282
 283             ssl3_init_finished_mac(s);
 284
 285             s->state = SSL3_ST_CW_CLNT_HELLO_A;
 286             s->ctx->stats.sess_connect++;
 287             s->init_num = 0;
 288             /*
 289              * Should have been reset by ssl3_get_finished, too.
 290              */
 291             s->s3->change_cipher_spec = 0;
 292             break;
 293
 294         case SSL3_ST_CW_CLNT_HELLO_A:
 295         case SSL3_ST_CW_CLNT_HELLO_B:
 296
 297             s->shutdown = 0;
 298             ret = ssl3_client_hello(s);
 299             if (ret <= 0)
 300                 goto end;
 301             s->state = SSL3_ST_CR_SRVR_HELLO_A;
 302             s->init_num = 0;
 303
 304             /* turn on buffering for the next lot of output */
 305             if (s->bbio != s->wbio)
 306                 s->wbio = BIO_push(s->bbio, s->wbio);
 307
 308             break;
 309
 310         case SSL3_ST_CR_SRVR_HELLO_A:
 311         case SSL3_ST_CR_SRVR_HELLO_B:
 312             ret = ssl3_get_server_hello(s);
 313             if (ret <= 0)
 314                 goto end;
 315
 316             if (s->hit) {
 317                 s->state = SSL3_ST_CR_CHANGE_A;
 318                 if (s->tlsext_ticket_expected) {
 319                     /* receive renewed session ticket */
 320                     s->state = SSL3_ST_CR_SESSION_TICKET_A;
 321                 }
 322             } else {
 323                 s->state = SSL3_ST_CR_CERT_A;
 324             }
 325             s->init_num = 0;
 326             break;
 327         case SSL3_ST_CR_CERT_A:
 328         case SSL3_ST_CR_CERT_B:
 329             /* Noop (ret = 0) for everything but EAP-FAST. */
 330             ret = ssl3_check_change(s);
 331             if (ret < 0)
 332                 goto end;
 333             if (ret == 1) {
 334                 s->hit = 1;
 335                 s->state = SSL3_ST_CR_CHANGE_A;
 336                 s->init_num = 0;
 337                 break;
 338             }
 339
 340             /* Check if it is anon DH/ECDH, SRP auth */
 341             /* or PSK */
 342             if (!(s->s3->tmp.new_cipher->algorithm_auth &
 343                     (SSL_aNULL | SSL_aSRP | SSL_aPSK))) {
 344                 ret = ssl3_get_server_certificate(s);
 345                 if (ret <= 0)
 346                     goto end;
 347
 348                 if (s->tlsext_status_expected)
 349                     s->state = SSL3_ST_CR_CERT_STATUS_A;
 350                 else
 351                     s->state = SSL3_ST_CR_KEY_EXCH_A;
 352             } else {
 353                 skip = 1;
 354                 s->state = SSL3_ST_CR_KEY_EXCH_A;
 355             }
 356
 357             s->init_num = 0;
 358             break;
 359
 360         case SSL3_ST_CR_KEY_EXCH_A:
 361         case SSL3_ST_CR_KEY_EXCH_B:
 362             ret = ssl3_get_key_exchange(s);
 363             if (ret <= 0)
 364                 goto end;
 365             s->state = SSL3_ST_CR_CERT_REQ_A;
 366             s->init_num = 0;
 367
 368             /*
 369              * at this point we check that we have the required stuff from
 370              * the server
 371              */
 372             if (!ssl3_check_cert_and_algorithm(s)) {
 373                 ret = -1;
 374                 s->state = SSL_ST_ERR;
 375                 goto end;
 376             }
 377             break;
 378
 379         case SSL3_ST_CR_CERT_REQ_A:
 380         case SSL3_ST_CR_CERT_REQ_B:
 381             ret = ssl3_get_certificate_request(s);
 382             if (ret <= 0)
 383                 goto end;
 384             s->state = SSL3_ST_CR_SRVR_DONE_A;
 385             s->init_num = 0;
 386             break;
 387
 388         case SSL3_ST_CR_SRVR_DONE_A:
 389         case SSL3_ST_CR_SRVR_DONE_B:
 390             ret = ssl3_get_server_done(s);
 391             if (ret <= 0)
 392                 goto end;
 393
 394             if (s->s3->tmp.cert_req)
 395                 s->state = SSL3_ST_CW_CERT_A;
 396             else
 397                 s->state = SSL3_ST_CW_KEY_EXCH_A;
 398             s->init_num = 0;
 399
 400             break;
 401
 402         case SSL3_ST_CW_CERT_A:
 403         case SSL3_ST_CW_CERT_B:
 404         case SSL3_ST_CW_CERT_C:
 405         case SSL3_ST_CW_CERT_D:
 406             ret = ssl3_send_client_certificate(s);
 407             if (ret <= 0)
 408                 goto end;
 409             s->state = SSL3_ST_CW_KEY_EXCH_A;
 410             s->init_num = 0;
 411             break;
 412
 413         case SSL3_ST_CW_KEY_EXCH_A:
 414         case SSL3_ST_CW_KEY_EXCH_B:
 415             ret = ssl3_send_client_key_exchange(s);
 416             if (ret <= 0)
 417                 goto end;
 418             /*
 419              * EAY EAY EAY need to check for DH fix cert sent back
 420              */
 421             /*
 422              * For TLS, cert_req is set to 2, so a cert chain of nothing is
 423              * sent, but no verify packet is sent
 424              */
 425             /*
 426              * XXX: For now, we do not support client authentication in ECDH
 427              * cipher suites with ECDH (rather than ECDSA) certificates. We
 428              * need to skip the certificate verify message when client's
 429              * ECDH public key is sent inside the client certificate.
 430              */
 431             if (s->s3->tmp.cert_req == 1) {
 432                 s->state = SSL3_ST_CW_CERT_VRFY_A;
 433             } else {
 434                 s->state = SSL3_ST_CW_CHANGE_A;
 435             }
 436             if (s->s3->flags & TLS1_FLAGS_SKIP_CERT_VERIFY) {
 437                 s->state = SSL3_ST_CW_CHANGE_A;
 438             }
 439
 440             s->init_num = 0;
 441             break;
 442
 443         case SSL3_ST_CW_CERT_VRFY_A:
 444         case SSL3_ST_CW_CERT_VRFY_B:
 445             ret = ssl3_send_client_verify(s);
 446             if (ret <= 0)
 447                 goto end;
 448             s->state = SSL3_ST_CW_CHANGE_A;
 449             s->init_num = 0;
 450             break;
 451
 452         case SSL3_ST_CW_CHANGE_A:
 453         case SSL3_ST_CW_CHANGE_B:
 454             ret = ssl3_send_change_cipher_spec(s,
 455                                                SSL3_ST_CW_CHANGE_A,
 456                                                SSL3_ST_CW_CHANGE_B);
 457             if (ret <= 0)
 458                 goto end;
 459
 460 #if defined(OPENSSL_NO_NEXTPROTONEG)
 461             s->state = SSL3_ST_CW_FINISHED_A;
 462 #else
 463             if (s->s3->next_proto_neg_seen)
 464                 s->state = SSL3_ST_CW_NEXT_PROTO_A;
 465             else
 466                 s->state = SSL3_ST_CW_FINISHED_A;
 467 #endif
 468             s->init_num = 0;
 469
 470             s->session->cipher = s->s3->tmp.new_cipher;
 471 #ifdef OPENSSL_NO_COMP
 472             s->session->compress_meth = 0;
 473 #else
 474             if (s->s3->tmp.new_compression == NULL)
 475                 s->session->compress_meth = 0;
 476             else
 477                 s->session->compress_meth = s->s3->tmp.new_compression->id;
 478 #endif
 479             if (!s->method->ssl3_enc->setup_key_block(s)) {
 480                 ret = -1;
 481                 s->state = SSL_ST_ERR;
 482                 goto end;
 483             }
 484
 485             if (!s->method->ssl3_enc->change_cipher_state(s,
 486                                                           SSL3_CHANGE_CIPHER_CLIENT_WRITE))
 487             {
 488                 ret = -1;
 489                 s->state = SSL_ST_ERR;
 490                 goto end;
 491             }
 492
 493             break;
 494
 495 #if !defined(OPENSSL_NO_NEXTPROTONEG)
 496         case SSL3_ST_CW_NEXT_PROTO_A:
 497         case SSL3_ST_CW_NEXT_PROTO_B:
 498             ret = ssl3_send_next_proto(s);
 499             if (ret <= 0)
 500                 goto end;
 501             s->state = SSL3_ST_CW_FINISHED_A;
 502             break;
 503 #endif
 504
 505         case SSL3_ST_CW_FINISHED_A:
 506         case SSL3_ST_CW_FINISHED_B:
 507             ret = ssl3_send_finished(s,
 508                                      SSL3_ST_CW_FINISHED_A,
 509                                      SSL3_ST_CW_FINISHED_B,
 510                                      s->method->
 511                                      ssl3_enc->client_finished_label,
 512                                      s->method->
 513                                      ssl3_enc->client_finished_label_len);
 514             if (ret <= 0)
 515                 goto end;
 516             s->state = SSL3_ST_CW_FLUSH;
 517
 518             if (s->hit) {
 519                 s->s3->tmp.next_state = SSL_ST_OK;
 520             } else {
 521                 /*
 522                  * Allow NewSessionTicket if ticket expected
 523                  */
 524                 if (s->tlsext_ticket_expected)
 525                     s->s3->tmp.next_state = SSL3_ST_CR_SESSION_TICKET_A;
 526                 else
 527                     s->s3->tmp.next_state = SSL3_ST_CR_CHANGE_A;
 528             }
 529             s->init_num = 0;
 530             break;
 531
 532         case SSL3_ST_CR_SESSION_TICKET_A:
 533         case SSL3_ST_CR_SESSION_TICKET_B:
 534             ret = ssl3_get_new_session_ticket(s);
 535             if (ret <= 0)
 536                 goto end;
 537             s->state = SSL3_ST_CR_CHANGE_A;
 538             s->init_num = 0;
 539             break;
 540
 541         case SSL3_ST_CR_CERT_STATUS_A:
 542         case SSL3_ST_CR_CERT_STATUS_B:
 543             ret = ssl3_get_cert_status(s);
 544             if (ret <= 0)
 545                 goto end;
 546             s->state = SSL3_ST_CR_KEY_EXCH_A;
 547             s->init_num = 0;
 548             break;
 549
 550         case SSL3_ST_CR_CHANGE_A:
 551         case SSL3_ST_CR_CHANGE_B:
 552             ret = ssl3_get_change_cipher_spec(s, SSL3_ST_CR_CHANGE_A,
 553                                               SSL3_ST_CR_CHANGE_B);
 554             if (ret <= 0)
 555                 goto end;
 556
 557             s->state = SSL3_ST_CR_FINISHED_A;
 558             s->init_num = 0;
 559             break;
 560
 561         case SSL3_ST_CR_FINISHED_A:
 562         case SSL3_ST_CR_FINISHED_B:
 563             ret = ssl3_get_finished(s, SSL3_ST_CR_FINISHED_A,
 564                                     SSL3_ST_CR_FINISHED_B);
 565             if (ret <= 0)
 566                 goto end;
 567
 568             if (s->hit)
 569                 s->state = SSL3_ST_CW_CHANGE_A;
 570             else
 571                 s->state = SSL_ST_OK;
 572             s->init_num = 0;
 573             break;
 574
 575         case SSL3_ST_CW_FLUSH:
 576             s->rwstate = SSL_WRITING;
 577             if (BIO_flush(s->wbio) <= 0) {
 578                 ret = -1;
 579                 goto end;
 580             }
 581             s->rwstate = SSL_NOTHING;
 582             s->state = s->s3->tmp.next_state;
 583             break;
 584
 585         case SSL_ST_OK:
 586             /* clean a few things up */
 587             ssl3_cleanup_key_block(s);
 588             BUF_MEM_free(s->init_buf);
 589             s->init_buf = NULL;
 590
 591             /* remove the buffering */
 592             ssl_free_wbio_buffer(s);
 593
 594             s->init_num = 0;
 595             s->renegotiate = 0;
 596             s->new_session = 0;
 597
 598             ssl_update_cache(s, SSL_SESS_CACHE_CLIENT);
 599             if (s->hit)
 600                 s->ctx->stats.sess_hit++;
 601
 602             ret = 1;
 603             /* s->server=0; */
 604             s->handshake_func = ssl3_connect;
 605             s->ctx->stats.sess_connect_good++;
 606
 607             if (cb != NULL)
 608                 cb(s, SSL_CB_HANDSHAKE_DONE, 1);
 609
 610             goto end;
 611             /* break; */
 612
 613         case SSL_ST_ERR:
 614         default:
 615             SSLerr(SSL_F_SSL3_CONNECT, SSL_R_UNKNOWN_STATE);
 616             ret = -1;
 617             goto end;
 618             /* break; */
 619         }
 620
 621         /* did we do anything */
 622         if (!s->s3->tmp.reuse_message && !skip) {
 623             if (s->debug) {
 624                 if ((ret = BIO_flush(s->wbio)) <= 0)
 625                     goto end;
 626             }
 627
 628             if ((cb != NULL) && (s->state != state)) {
 629                 new_state = s->state;
 630                 s->state = state;
 631                 cb(s, SSL_CB_CONNECT_LOOP, 1);
 632                 s->state = new_state;
 633             }
 634         }
 635         skip = 0;
 636     }
 637  end:
 638     s->in_handshake--;
 639     BUF_MEM_free(buf);
 640     if (cb != NULL)
 641         cb(s, SSL_CB_CONNECT_EXIT, ret);
 642     return (ret);
 643 }
 644
 645 #endif /* End temp disabled ssl3_connect */
 646 /*
 647  * Work out what version we should be using for the initial ClientHello if
 648  * the version is currently set to (D)TLS_ANY_VERSION.
 649  * Returns 1 on success
 650  * Returns 0 on error
 651  */
 652 static int ssl_set_version(SSL *s)
 653 {
 654     unsigned long mask, options = s->options;
 655
 656     if (s->method->version == TLS_ANY_VERSION) {
 657         /*
 658          * SSL_OP_NO_X disables all protocols above X *if* there are
 659          * some protocols below X enabled. This is required in order
 660          * to maintain "version capability" vector contiguous. So
 661          * that if application wants to disable TLS1.0 in favour of
 662          * TLS1>=1, it would be insufficient to pass SSL_NO_TLSv1, the
 663          * answer is SSL_OP_NO_TLSv1|SSL_OP_NO_SSLv3.
 664          */
 665         mask = SSL_OP_NO_TLSv1_1 | SSL_OP_NO_TLSv1
 666 #if !defined(OPENSSL_NO_SSL3)
 667             | SSL_OP_NO_SSLv3
 668 #endif
 669             ;
 670 #if !defined(OPENSSL_NO_TLS1_2_CLIENT)
 671         if (options & SSL_OP_NO_TLSv1_2) {
 672             if ((options & mask) != mask) {
 673                 s->version = TLS1_1_VERSION;
 674             } else {
 675                 SSLerr(SSL_F_SSL_SET_VERSION, SSL_R_NO_PROTOCOLS_AVAILABLE);
 676                 return 0;
 677             }
 678         } else {
 679             s->version = TLS1_2_VERSION;
 680         }
 681 #else
 682         if ((options & mask) == mask) {
 683             SSLerr(SSL_F_SSL_SET_VERSION, SSL_R_NO_PROTOCOLS_AVAILABLE);
 684             return 0;
 685         }
 686         s->version = TLS1_1_VERSION;
 687 #endif
 688
 689         mask &= ~SSL_OP_NO_TLSv1_1;
 690         if ((options & SSL_OP_NO_TLSv1_1) && (options & mask) != mask)
 691             s->version = TLS1_VERSION;
 692         mask &= ~SSL_OP_NO_TLSv1;
 693 #if !defined(OPENSSL_NO_SSL3)
 694         if ((options & SSL_OP_NO_TLSv1) && (options & mask) != mask)
 695             s->version = SSL3_VERSION;
 696 #endif
 697
 698         if (s->version != TLS1_2_VERSION && tls1_suiteb(s)) {
 699             SSLerr(SSL_F_SSL_SET_VERSION,
 700                    SSL_R_ONLY_TLS_1_2_ALLOWED_IN_SUITEB_MODE);
 701             return 0;
 702         }
 703
 704         if (s->version == SSL3_VERSION && FIPS_mode()) {
 705             SSLerr(SSL_F_SSL_SET_VERSION, SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
 706             return 0;
 707         }
 708
 709     } else if (s->method->version == DTLS_ANY_VERSION) {
 710         /* Determine which DTLS version to use */
 711         /* If DTLS 1.2 disabled correct the version number */
 712         if (options & SSL_OP_NO_DTLSv1_2) {
 713             if (tls1_suiteb(s)) {
 714                 SSLerr(SSL_F_SSL_SET_VERSION,
 715                        SSL_R_ONLY_DTLS_1_2_ALLOWED_IN_SUITEB_MODE);
 716                 return 0;
 717             }
 718             /*
 719              * Disabling all versions is silly: return an error.
 720              */
 721             if (options & SSL_OP_NO_DTLSv1) {
 722                 SSLerr(SSL_F_SSL_SET_VERSION, SSL_R_WRONG_SSL_VERSION);
 723                 return 0;
 724             }
 725             /*
 726              * Update method so we don't use any DTLS 1.2 features.
 727              */
 728             s->method = DTLSv1_client_method();
 729             s->version = DTLS1_VERSION;
 730         } else {
 731             /*
 732              * We only support one version: update method
 733              */
 734             if (options & SSL_OP_NO_DTLSv1)
 735                 s->method = DTLSv1_2_client_method();
 736             s->version = DTLS1_2_VERSION;
 737         }
 738     }
 739
 740     s->client_version = s->version;
 741
 742     return 1;
 743 }
 744
 745 int ssl3_client_hello(SSL *s)
 746 {
 747     if (s->state == SSL3_ST_CW_CLNT_HELLO_A) {
 748         if(tls_construct_client_hello(s) == 0)
 749             goto err;
 750
 751         s->state = SSL3_ST_CW_CLNT_HELLO_B;
 752     }
 753
 754     /* SSL3_ST_CW_CLNT_HELLO_B */
 755     return ssl_do_write(s);
 756  err:
 757     s->state = SSL_ST_ERR;
 758     return -1;
 759
 760 }
 761
 762 int tls_construct_client_hello(SSL *s)
 763 {
 764     unsigned char *buf;
 765     unsigned char *p, *d;
 766     int i;
 767     unsigned long l;
 768     int al = 0;
 769 #ifndef OPENSSL_NO_COMP
 770     int j;
 771     SSL_COMP *comp;
 772 #endif
 773     SSL_SESSION *sess = s->session;
 774
 775     buf = (unsigned char *)s->init_buf->data;
 776
 777     /* Work out what SSL/TLS/DTLS version to use */
 778     if (ssl_set_version(s) == 0)
 779         goto err;
 780
 781     if ((sess == NULL) || (sess->ssl_version != s->version) ||
 782         /*
 783          * In the case of EAP-FAST, we can have a pre-shared
 784          * "ticket" without a session ID.
 785          */
 786         (!sess->session_id_length && !sess->tlsext_tick) ||
 787         (sess->not_resumable)) {
 788         if (!ssl_get_new_session(s, 0))
 789             goto err;
 790     }
 791     /* else use the pre-loaded session */
 792
 793     p = s->s3->client_random;
 794
 795     /*
 796      * for DTLS if client_random is initialized, reuse it, we are
 797      * required to use same upon reply to HelloVerify
 798      */
 799     if (SSL_IS_DTLS(s)) {
 800         size_t idx;
 801         i = 1;
 802         for (idx = 0; idx < sizeof(s->s3->client_random); idx++) {
 803             if (p[idx]) {
 804                 i = 0;
 805                 break;
 806             }
 807         }
 808     } else
 809         i = 1;
 810
 811     if (i && ssl_fill_hello_random(s, 0, p,
 812                                    sizeof(s->s3->client_random)) <= 0)
 813         goto err;
 814
 815     /* Do the message type and length last */
 816     d = p = ssl_handshake_start(s);
 817
 818     /*-
 819      * version indicates the negotiated version: for example from
 820      * an SSLv2/v3 compatible client hello). The client_version
 821      * field is the maximum version we permit and it is also
 822      * used in RSA encrypted premaster secrets. Some servers can
 823      * choke if we initially report a higher version then
 824      * renegotiate to a lower one in the premaster secret. This
 825      * didn't happen with TLS 1.0 as most servers supported it
 826      * but it can with TLS 1.1 or later if the server only supports
 827      * 1.0.
 828      *
 829      * Possible scenario with previous logic:
 830      *      1. Client hello indicates TLS 1.2
 831      *      2. Server hello says TLS 1.0
 832      *      3. RSA encrypted premaster secret uses 1.2.
 833      *      4. Handhaked proceeds using TLS 1.0.
 834      *      5. Server sends hello request to renegotiate.
 835      *      6. Client hello indicates TLS v1.0 as we now
 836      *         know that is maximum server supports.
 837      *      7. Server chokes on RSA encrypted premaster secret
 838      *         containing version 1.0.
 839      *
 840      * For interoperability it should be OK to always use the
 841      * maximum version we support in client hello and then rely
 842      * on the checking of version to ensure the servers isn't
 843      * being inconsistent: for example initially negotiating with
 844      * TLS 1.0 and renegotiating with TLS 1.2. We do this by using
 845      * client_version in client hello and not resetting it to
 846      * the negotiated version.
 847      */
 848     *(p++) = s->client_version >> 8;
 849     *(p++) = s->client_version & 0xff;
 850
 851     /* Random stuff */
 852     memcpy(p, s->s3->client_random, SSL3_RANDOM_SIZE);
 853     p += SSL3_RANDOM_SIZE;
 854
 855     /* Session ID */
 856     if (s->new_session)
 857         i = 0;
 858     else
 859         i = s->session->session_id_length;
 860     *(p++) = i;
 861     if (i != 0) {
 862         if (i > (int)sizeof(s->session->session_id)) {
 863             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
 864             goto err;
 865         }
 866         memcpy(p, s->session->session_id, i);
 867         p += i;
 868     }
 869
 870     /* cookie stuff for DTLS */
 871     if (SSL_IS_DTLS(s)) {
 872         if (s->d1->cookie_len > sizeof(s->d1->cookie)) {
 873             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
 874             goto err;
 875         }
 876         *(p++) = s->d1->cookie_len;
 877         memcpy(p, s->d1->cookie, s->d1->cookie_len);
 878         p += s->d1->cookie_len;
 879     }
 880
 881     /* Ciphers supported */
 882     i = ssl_cipher_list_to_bytes(s, SSL_get_ciphers(s), &(p[2]));
 883     if (i == 0) {
 884         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, SSL_R_NO_CIPHERS_AVAILABLE);
 885         goto err;
 886     }
 887 #ifdef OPENSSL_MAX_TLS1_2_CIPHER_LENGTH
 888     /*
 889      * Some servers hang if client hello > 256 bytes as hack workaround
 890      * chop number of supported ciphers to keep it well below this if we
 891      * use TLS v1.2
 892      */
 893     if (TLS1_get_version(s) >= TLS1_2_VERSION
 894         && i > OPENSSL_MAX_TLS1_2_CIPHER_LENGTH)
 895         i = OPENSSL_MAX_TLS1_2_CIPHER_LENGTH & ~1;
 896 #endif
 897     s2n(i, p);
 898     p += i;
 899
 900     /* COMPRESSION */
 901 #ifdef OPENSSL_NO_COMP
 902     *(p++) = 1;
 903 #else
 904
 905     if (!ssl_allow_compression(s) || !s->ctx->comp_methods)
 906         j = 0;
 907     else
 908         j = sk_SSL_COMP_num(s->ctx->comp_methods);
 909     *(p++) = 1 + j;
 910     for (i = 0; i < j; i++) {
 911         comp = sk_SSL_COMP_value(s->ctx->comp_methods, i);
 912         *(p++) = comp->id;
 913     }
 914 #endif
 915     *(p++) = 0;             /* Add the NULL method */
 916
 917     /* TLS extensions */
 918     if (ssl_prepare_clienthello_tlsext(s) <= 0) {
 919         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, SSL_R_CLIENTHELLO_TLSEXT);
 920         goto err;
 921     }
 922     if ((p =
 923          ssl_add_clienthello_tlsext(s, p, buf + SSL3_RT_MAX_PLAIN_LENGTH,
 924                                     &al)) == NULL) {
 925         ssl3_send_alert(s, SSL3_AL_FATAL, al);
 926         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
 927         goto err;
 928     }
 929
 930     l = p - d;
 931     if (!ssl_set_handshake_header(s, SSL3_MT_CLIENT_HELLO, l)) {
 932         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_HANDSHAKE_FAILURE);
 933         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
 934         goto err;
 935     }
 936
 937     return 1;
 938  err:
 939     statem_set_error(s);
 940     return 0;
 941 }
 942
 943 int ssl3_get_server_hello(SSL *s)
 944 {
 945     int ok, al;
 946     long n;
 947     /*
 948      * Hello verify request and/or server hello version may not match so set
 949      * first packet if we're negotiating version.
 950      */
 951     s->first_packet = 1;
 952
 953     n = s->method->ssl_get_message(s,
 954                                    SSL3_ST_CR_SRVR_HELLO_A,
 955                                    SSL3_ST_CR_SRVR_HELLO_B, -1, 20000, &ok);
 956
 957     if (!ok)
 958         return ((int)n);
 959
 960     s->first_packet = 0;
 961     if (SSL_IS_DTLS(s)) {
 962         if (s->s3->tmp.message_type == DTLS1_MT_HELLO_VERIFY_REQUEST) {
 963             if (s->d1->send_cookie == 0) {
 964                 s->s3->tmp.reuse_message = 1;
 965                 return 1;
 966             } else {            /* already sent a cookie */
 967
 968                 al = SSL_AD_UNEXPECTED_MESSAGE;
 969                 SSLerr(SSL_F_SSL3_GET_SERVER_HELLO, SSL_R_BAD_MESSAGE_TYPE);
 970                 goto f_err;
 971             }
 972         }
 973     }
 974
 975     if (s->s3->tmp.message_type != SSL3_MT_SERVER_HELLO) {
 976         al = SSL_AD_UNEXPECTED_MESSAGE;
 977         SSLerr(SSL_F_SSL3_GET_SERVER_HELLO, SSL_R_BAD_MESSAGE_TYPE);
 978         goto f_err;
 979     }
 980
 981     return tls_process_server_hello(s, (unsigned long)n);
 982  f_err:
 983     ssl3_send_alert(s, SSL3_AL_FATAL, al);
 984     s->state = SSL_ST_ERR;
 985     return (-1);
 986 }
 987
 988 enum MSG_PROCESS_RETURN tls_process_server_hello(SSL *s, unsigned long n)
 989 {
 990     STACK_OF(SSL_CIPHER) *sk;
 991     const SSL_CIPHER *c;
 992     PACKET pkt, session_id;
 993     size_t session_id_len;
 994     unsigned char *cipherchars;
 995     int i, al = SSL_AD_INTERNAL_ERROR;
 996     unsigned int compression;
 997 #ifndef OPENSSL_NO_COMP
 998     SSL_COMP *comp;
 999 #endif
1000
1001     if (!PACKET_buf_init(&pkt, s->init_msg, n)) {
1002         al = SSL_AD_INTERNAL_ERROR;
1003         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, ERR_R_INTERNAL_ERROR);
1004         goto f_err;
1005     }
1006
1007     if (s->method->version == TLS_ANY_VERSION) {
1008         unsigned int sversion;
1009
1010         if (!PACKET_get_net_2(&pkt, &sversion)) {
1011             al = SSL_AD_DECODE_ERROR;
1012             SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_LENGTH_MISMATCH);
1013             goto f_err;
1014         }
1015
1016 #if TLS_MAX_VERSION != TLS1_2_VERSION
1017 #error Code needs updating for new TLS version
1018 #endif
1019 #ifndef OPENSSL_NO_SSL3
1020         if ((sversion == SSL3_VERSION) && !(s->options & SSL_OP_NO_SSLv3)) {
1021             if (FIPS_mode()) {
1022                 SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO,
1023                        SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
1024                 al = SSL_AD_PROTOCOL_VERSION;
1025                 goto f_err;
1026             }
1027             s->method = SSLv3_client_method();
1028         } else
1029 #endif
1030         if ((sversion == TLS1_VERSION) && !(s->options & SSL_OP_NO_TLSv1)) {
1031             s->method = TLSv1_client_method();
1032         } else if ((sversion == TLS1_1_VERSION) &&
1033                    !(s->options & SSL_OP_NO_TLSv1_1)) {
1034             s->method = TLSv1_1_client_method();
1035         } else if ((sversion == TLS1_2_VERSION) &&
1036                    !(s->options & SSL_OP_NO_TLSv1_2)) {
1037             s->method = TLSv1_2_client_method();
1038         } else {
1039             SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_UNSUPPORTED_PROTOCOL);
1040             al = SSL_AD_PROTOCOL_VERSION;
1041             goto f_err;
1042         }
1043         s->session->ssl_version = s->version = s->method->version;
1044
1045         if (!ssl_security(s, SSL_SECOP_VERSION, 0, s->version, NULL)) {
1046             SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_VERSION_TOO_LOW);
1047             al = SSL_AD_PROTOCOL_VERSION;
1048             goto f_err;
1049         }
1050     } else if (s->method->version == DTLS_ANY_VERSION) {
1051         /* Work out correct protocol version to use */
1052         unsigned int hversion;
1053         int options;
1054
1055         if (!PACKET_get_net_2(&pkt, &hversion)) {
1056             al = SSL_AD_DECODE_ERROR;
1057             SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_LENGTH_MISMATCH);
1058             goto f_err;
1059         }
1060
1061         options = s->options;
1062         if (hversion == DTLS1_2_VERSION && !(options & SSL_OP_NO_DTLSv1_2))
1063             s->method = DTLSv1_2_client_method();
1064         else if (tls1_suiteb(s)) {
1065             SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO,
1066                    SSL_R_ONLY_DTLS_1_2_ALLOWED_IN_SUITEB_MODE);
1067             s->version = hversion;
1068             al = SSL_AD_PROTOCOL_VERSION;
1069             goto f_err;
1070         } else if (hversion == DTLS1_VERSION && !(options & SSL_OP_NO_DTLSv1))
1071             s->method = DTLSv1_client_method();
1072         else {
1073             SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_WRONG_SSL_VERSION);
1074             s->version = hversion;
1075             al = SSL_AD_PROTOCOL_VERSION;
1076             goto f_err;
1077         }
1078         s->session->ssl_version = s->version = s->method->version;
1079     } else {
1080         unsigned char *vers;
1081
1082         if (!PACKET_get_bytes(&pkt, &vers, 2)) {
1083             al = SSL_AD_DECODE_ERROR;
1084             SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_LENGTH_MISMATCH);
1085             goto f_err;
1086         }
1087         if ((vers[0] != (s->version >> 8))
1088                 || (vers[1] != (s->version & 0xff))) {
1089             SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_WRONG_SSL_VERSION);
1090             s->version = (s->version & 0xff00) | vers[1];
1091             al = SSL_AD_PROTOCOL_VERSION;
1092             goto f_err;
1093         }
1094     }
1095
1096     /* load the server hello data */
1097     /* load the server random */
1098     if (!PACKET_copy_bytes(&pkt, s->s3->server_random, SSL3_RANDOM_SIZE)) {
1099         al = SSL_AD_DECODE_ERROR;
1100         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_LENGTH_MISMATCH);
1101         goto f_err;
1102     }
1103
1104     s->hit = 0;
1105
1106     /* Get the session-id. */
1107     if (!PACKET_get_length_prefixed_1(&pkt, &session_id)) {
1108         al = SSL_AD_DECODE_ERROR;
1109         SSLerr(SSL_F_SSL3_GET_SERVER_HELLO, SSL_R_LENGTH_MISMATCH);
1110         goto f_err;
1111     }
1112     session_id_len = PACKET_remaining(&session_id);
1113     if (session_id_len > sizeof s->session->session_id
1114         || session_id_len > SSL3_SESSION_ID_SIZE) {
1115         al = SSL_AD_ILLEGAL_PARAMETER;
1116         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_SSL3_SESSION_ID_TOO_LONG);
1117         goto f_err;
1118     }
1119
1120     if (!PACKET_get_bytes(&pkt, &cipherchars, TLS_CIPHER_LEN)) {
1121         SSLerr(SSL_F_SSL3_GET_SERVER_HELLO, SSL_R_LENGTH_MISMATCH);
1122         al = SSL_AD_DECODE_ERROR;
1123         goto f_err;
1124     }
1125
1126     /*
1127      * Check if we can resume the session based on external pre-shared secret.
1128      * EAP-FAST (RFC 4851) supports two types of session resumption.
1129      * Resumption based on server-side state works with session IDs.
1130      * Resumption based on pre-shared Protected Access Credentials (PACs)
1131      * works by overriding the SessionTicket extension at the application
1132      * layer, and does not send a session ID. (We do not know whether EAP-FAST
1133      * servers would honour the session ID.) Therefore, the session ID alone
1134      * is not a reliable indicator of session resumption, so we first check if
1135      * we can resume, and later peek at the next handshake message to see if the
1136      * server wants to resume.
1137      */
1138     if (s->version >= TLS1_VERSION && s->tls_session_secret_cb &&
1139         s->session->tlsext_tick) {
1140         SSL_CIPHER *pref_cipher = NULL;
1141         s->session->master_key_length = sizeof(s->session->master_key);
1142         if (s->tls_session_secret_cb(s, s->session->master_key,
1143                                      &s->session->master_key_length,
1144                                      NULL, &pref_cipher,
1145                                      s->tls_session_secret_cb_arg)) {
1146             s->session->cipher = pref_cipher ?
1147                 pref_cipher : ssl_get_cipher_by_char(s, cipherchars);
1148         } else {
1149             SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, ERR_R_INTERNAL_ERROR);
1150             al = SSL_AD_INTERNAL_ERROR;
1151             goto f_err;
1152         }
1153     }
1154
1155     if (session_id_len != 0 && session_id_len == s->session->session_id_length
1156         && memcmp(PACKET_data(&session_id), s->session->session_id,
1157                   session_id_len) == 0) {
1158         if (s->sid_ctx_length != s->session->sid_ctx_length
1159             || memcmp(s->session->sid_ctx, s->sid_ctx, s->sid_ctx_length)) {
1160             /* actually a client application bug */
1161             al = SSL_AD_ILLEGAL_PARAMETER;
1162             SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO,
1163                    SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT);
1164             goto f_err;
1165         }
1166         s->hit = 1;
1167     } else {
1168         /*
1169          * If we were trying for session-id reuse but the server
1170          * didn't echo the ID, make a new SSL_SESSION.
1171          * In the case of EAP-FAST and PAC, we do not send a session ID,
1172          * so the PAC-based session secret is always preserved. It'll be
1173          * overwritten if the server refuses resumption.
1174          */
1175         if (s->session->session_id_length > 0) {
1176             if (!ssl_get_new_session(s, 0)) {
1177                 goto f_err;
1178             }
1179         }
1180
1181         s->session->session_id_length = session_id_len;
1182         /* session_id_len could be 0 */
1183         memcpy(s->session->session_id, PACKET_data(&session_id),
1184                session_id_len);
1185     }
1186
1187     c = ssl_get_cipher_by_char(s, cipherchars);
1188     if (c == NULL) {
1189         /* unknown cipher */
1190         al = SSL_AD_ILLEGAL_PARAMETER;
1191         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_UNKNOWN_CIPHER_RETURNED);
1192         goto f_err;
1193     }
1194     /* Set version disabled mask now we know version */
1195     if (!SSL_USE_TLS1_2_CIPHERS(s))
1196         s->s3->tmp.mask_ssl = SSL_TLSV1_2;
1197     else
1198         s->s3->tmp.mask_ssl = 0;
1199     /*
1200      * If it is a disabled cipher we didn't send it in client hello, so
1201      * return an error.
1202      */
1203     if (ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_CHECK)) {
1204         al = SSL_AD_ILLEGAL_PARAMETER;
1205         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_WRONG_CIPHER_RETURNED);
1206         goto f_err;
1207     }
1208
1209     sk = ssl_get_ciphers_by_id(s);
1210     i = sk_SSL_CIPHER_find(sk, c);
1211     if (i < 0) {
1212         /* we did not say we would use this cipher */
1213         al = SSL_AD_ILLEGAL_PARAMETER;
1214         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_WRONG_CIPHER_RETURNED);
1215         goto f_err;
1216     }
1217
1218     /*
1219      * Depending on the session caching (internal/external), the cipher
1220      * and/or cipher_id values may not be set. Make sure that cipher_id is
1221      * set and use it for comparison.
1222      */
1223     if (s->session->cipher)
1224         s->session->cipher_id = s->session->cipher->id;
1225     if (s->hit && (s->session->cipher_id != c->id)) {
1226         al = SSL_AD_ILLEGAL_PARAMETER;
1227         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO,
1228                SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED);
1229         goto f_err;
1230     }
1231     s->s3->tmp.new_cipher = c;
1232     /*
1233      * Don't digest cached records if no sigalgs: we may need them for client
1234      * authentication.
1235      */
1236     if (!SSL_USE_SIGALGS(s) && !ssl3_digest_cached_records(s, 0))
1237         goto f_err;
1238     /* lets get the compression algorithm */
1239     /* COMPRESSION */
1240     if (!PACKET_get_1(&pkt, &compression)) {
1241         SSLerr(SSL_F_SSL3_GET_SERVER_HELLO, SSL_R_LENGTH_MISMATCH);
1242         al = SSL_AD_DECODE_ERROR;
1243         goto f_err;
1244     }
1245 #ifdef OPENSSL_NO_COMP
1246     if (compression != 0) {
1247         al = SSL_AD_ILLEGAL_PARAMETER;
1248         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO,
1249                SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM);
1250         goto f_err;
1251     }
1252     /*
1253      * If compression is disabled we'd better not try to resume a session
1254      * using compression.
1255      */
1256     if (s->session->compress_meth != 0) {
1257         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_INCONSISTENT_COMPRESSION);
1258         goto f_err;
1259     }
1260 #else
1261     if (s->hit && compression != s->session->compress_meth) {
1262         al = SSL_AD_ILLEGAL_PARAMETER;
1263         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO,
1264                SSL_R_OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED);
1265         goto f_err;
1266     }
1267     if (compression == 0)
1268         comp = NULL;
1269     else if (!ssl_allow_compression(s)) {
1270         al = SSL_AD_ILLEGAL_PARAMETER;
1271         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_COMPRESSION_DISABLED);
1272         goto f_err;
1273     } else {
1274         comp = ssl3_comp_find(s->ctx->comp_methods, compression);
1275     }
1276
1277     if (compression != 0 && comp == NULL) {
1278         al = SSL_AD_ILLEGAL_PARAMETER;
1279         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO,
1280                SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM);
1281         goto f_err;
1282     } else {
1283         s->s3->tmp.new_compression = comp;
1284     }
1285 #endif
1286
1287     /* TLS extensions */
1288     if (!ssl_parse_serverhello_tlsext(s, &pkt)) {
1289         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_PARSE_TLSEXT);
1290         goto err;
1291     }
1292
1293     if (PACKET_remaining(&pkt) != 0) {
1294         /* wrong packet length */
1295         al = SSL_AD_DECODE_ERROR;
1296         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_BAD_PACKET_LENGTH);
1297         goto f_err;
1298     }
1299
1300 #ifndef OPENSSL_NO_SCTP
1301     if (SSL_IS_DTLS(s) && s->hit) {
1302         unsigned char sctpauthkey[64];
1303         char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)];
1304
1305         /*
1306          * Add new shared key for SCTP-Auth, will be ignored if
1307          * no SCTP used.
1308          */
1309         snprintf((char *)labelbuffer,
1310                  sizeof(DTLS1_SCTP_AUTH_LABEL),
1311                  DTLS1_SCTP_AUTH_LABEL);
1312
1313         if (SSL_export_keying_material(s, sctpauthkey,
1314                                    sizeof(sctpauthkey),
1315                                    labelbuffer,
1316                                    sizeof(labelbuffer), NULL, 0,
1317                                    0) <= 0)
1318             goto err;
1319
1320         BIO_ctrl(SSL_get_wbio(s),
1321                  BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
1322                  sizeof(sctpauthkey), sctpauthkey);
1323     }
1324 #endif
1325
1326     return MSG_PROCESS_CONTINUE_READING;
1327  f_err:
1328     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1329  err:
1330     statem_set_error(s);
1331     return MSG_PROCESS_ERROR;
1332 }
1333
1334 int ssl3_get_server_certificate(SSL *s)
1335 {
1336     long n;
1337     int ok, al;
1338
1339     n = s->method->ssl_get_message(s,
1340                                    SSL3_ST_CR_CERT_A,
1341                                    SSL3_ST_CR_CERT_B,
1342                                    -1, s->max_cert_list, &ok);
1343
1344     if (!ok)
1345         return ((int)n);
1346
1347     if (s->s3->tmp.message_type == SSL3_MT_SERVER_KEY_EXCHANGE) {
1348         s->s3->tmp.reuse_message = 1;
1349         return (1);
1350     }
1351
1352     if (s->s3->tmp.message_type != SSL3_MT_CERTIFICATE) {
1353         al = SSL_AD_UNEXPECTED_MESSAGE;
1354         SSLerr(SSL_F_SSL3_GET_SERVER_CERTIFICATE, SSL_R_BAD_MESSAGE_TYPE);
1355         goto f_err;
1356     }
1357
1358     return tls_process_server_certificate(s, (unsigned long)n);
1359  f_err:
1360     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1361     s->state = SSL_ST_ERR;
1362     return -1;
1363 }
1364
1365 enum MSG_PROCESS_RETURN tls_process_server_certificate(SSL *s, unsigned long n)
1366 {
1367     int al, i, ret = MSG_PROCESS_ERROR, exp_idx;
1368     unsigned long cert_list_len, cert_len;
1369     X509 *x = NULL;
1370     unsigned char *certstart, *certbytes;
1371     STACK_OF(X509) *sk = NULL;
1372     EVP_PKEY *pkey = NULL;
1373     PACKET pkt;
1374
1375     if (!PACKET_buf_init(&pkt, s->init_msg, n)) {
1376         al = SSL_AD_INTERNAL_ERROR;
1377         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE, ERR_R_INTERNAL_ERROR);
1378         goto f_err;
1379     }
1380
1381     if ((sk = sk_X509_new_null()) == NULL) {
1382         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE, ERR_R_MALLOC_FAILURE);
1383         goto err;
1384     }
1385
1386     if (!PACKET_get_net_3(&pkt, &cert_list_len)
1387             || PACKET_remaining(&pkt) != cert_list_len) {
1388         al = SSL_AD_DECODE_ERROR;
1389         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE, SSL_R_LENGTH_MISMATCH);
1390         goto f_err;
1391     }
1392     while (PACKET_remaining(&pkt)) {
1393         if (!PACKET_get_net_3(&pkt, &cert_len)
1394                 || !PACKET_get_bytes(&pkt, &certbytes, cert_len)) {
1395             al = SSL_AD_DECODE_ERROR;
1396             SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE,
1397                    SSL_R_CERT_LENGTH_MISMATCH);
1398             goto f_err;
1399         }
1400
1401         certstart = certbytes;
1402         x = d2i_X509(NULL, (const unsigned char **)&certbytes, cert_len);
1403         if (x == NULL) {
1404             al = SSL_AD_BAD_CERTIFICATE;
1405             SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE, ERR_R_ASN1_LIB);
1406             goto f_err;
1407         }
1408         if (certbytes != (certstart + cert_len)) {
1409             al = SSL_AD_DECODE_ERROR;
1410             SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE,
1411                    SSL_R_CERT_LENGTH_MISMATCH);
1412             goto f_err;
1413         }
1414         if (!sk_X509_push(sk, x)) {
1415             SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE, ERR_R_MALLOC_FAILURE);
1416             goto err;
1417         }
1418         x = NULL;
1419     }
1420
1421     i = ssl_verify_cert_chain(s, sk);
1422     if (s->verify_mode != SSL_VERIFY_NONE && i <= 0) {
1423         al = ssl_verify_alarm_type(s->verify_result);
1424         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE,
1425                SSL_R_CERTIFICATE_VERIFY_FAILED);
1426         goto f_err;
1427     }
1428     ERR_clear_error();          /* but we keep s->verify_result */
1429     if (i > 1) {
1430         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE, i);
1431         al = SSL_AD_HANDSHAKE_FAILURE;
1432         goto f_err;
1433     }
1434
1435     s->session->peer_chain = sk;
1436     /*
1437      * Inconsistency alert: cert_chain does include the peer's certificate,
1438      * which we don't include in s3_srvr.c
1439      */
1440     x = sk_X509_value(sk, 0);
1441     sk = NULL;
1442     /*
1443      * VRS 19990621: possible memory leak; sk=null ==> !sk_pop_free() @end
1444      */
1445
1446     pkey = X509_get_pubkey(x);
1447
1448     if (pkey == NULL || EVP_PKEY_missing_parameters(pkey)) {
1449         x = NULL;
1450         al = SSL3_AL_FATAL;
1451         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE,
1452                SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS);
1453         goto f_err;
1454     }
1455
1456     i = ssl_cert_type(x, pkey);
1457     if (i < 0) {
1458         x = NULL;
1459         al = SSL3_AL_FATAL;
1460         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE,
1461                SSL_R_UNKNOWN_CERTIFICATE_TYPE);
1462         goto f_err;
1463     }
1464
1465     exp_idx = ssl_cipher_get_cert_index(s->s3->tmp.new_cipher);
1466     if (exp_idx >= 0 && i != exp_idx) {
1467         x = NULL;
1468         al = SSL_AD_ILLEGAL_PARAMETER;
1469         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE,
1470                SSL_R_WRONG_CERTIFICATE_TYPE);
1471         goto f_err;
1472     }
1473     s->session->peer_type = i;
1474
1475     X509_free(s->session->peer);
1476     X509_up_ref(x);
1477     s->session->peer = x;
1478     s->session->verify_result = s->verify_result;
1479
1480     x = NULL;
1481     ret = MSG_PROCESS_CONTINUE_READING;
1482     goto done;
1483
1484  f_err:
1485     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1486  err:
1487     statem_set_error(s);
1488  done:
1489     EVP_PKEY_free(pkey);
1490     X509_free(x);
1491     sk_X509_pop_free(sk, X509_free);
1492     return ret;
1493 }
1494
1495 int ssl3_get_key_exchange(SSL *s)
1496 {
1497     long n;
1498     int ok;
1499     long alg_k;
1500
1501     /*
1502      * use same message size as in ssl3_get_certificate_request() as
1503      * ServerKeyExchange message may be skipped
1504      */
1505     n = s->method->ssl_get_message(s,
1506                                    SSL3_ST_CR_KEY_EXCH_A,
1507                                    SSL3_ST_CR_KEY_EXCH_B,
1508                                    -1, s->max_cert_list, &ok);
1509     if (!ok)
1510         return ((int)n);
1511
1512     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
1513
1514     if (s->s3->tmp.message_type != SSL3_MT_SERVER_KEY_EXCHANGE) {
1515         /*
1516          * Can't skip server key exchange if this is an ephemeral
1517          * ciphersuite.
1518          */
1519         if (alg_k & (SSL_kDHE | SSL_kECDHE | SSL_kDHEPSK | SSL_kECDHEPSK)) {
1520             SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, SSL_R_UNEXPECTED_MESSAGE);
1521             ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_UNEXPECTED_MESSAGE);
1522             return -1;
1523         }
1524
1525         s->s3->tmp.reuse_message = 1;
1526         return 1;
1527     }
1528
1529     return tls_process_key_exchange(s, (unsigned long)n);
1530 }
1531
1532 enum MSG_PROCESS_RETURN tls_process_key_exchange(SSL *s, unsigned long n)
1533 {
1534 #ifndef OPENSSL_NO_RSA
1535     unsigned char *q, md_buf[EVP_MAX_MD_SIZE * 2];
1536 #endif
1537     EVP_MD_CTX md_ctx;
1538     int al, j, verify_ret;
1539     long alg_k, alg_a;
1540     EVP_PKEY *pkey = NULL;
1541     const EVP_MD *md = NULL;
1542 #ifndef OPENSSL_NO_RSA
1543     RSA *rsa = NULL;
1544 #endif
1545 #ifndef OPENSSL_NO_DH
1546     DH *dh = NULL;
1547 #endif
1548 #ifndef OPENSSL_NO_EC
1549     EC_KEY *ecdh = NULL;
1550     BN_CTX *bn_ctx = NULL;
1551     EC_POINT *srvr_ecpoint = NULL;
1552     int curve_nid = 0;
1553 #endif
1554     PACKET pkt, save_param_start, signature;
1555
1556     EVP_MD_CTX_init(&md_ctx);
1557
1558     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
1559
1560     if (!PACKET_buf_init(&pkt, s->init_msg, n)) {
1561             SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
1562             al = SSL_AD_INTERNAL_ERROR;
1563             goto f_err;
1564     }
1565     save_param_start = pkt;
1566
1567 #ifndef OPENSSL_NO_RSA
1568     RSA_free(s->s3->peer_rsa_tmp);
1569     s->s3->peer_rsa_tmp = NULL;
1570 #endif
1571 #ifndef OPENSSL_NO_DH
1572     DH_free(s->s3->peer_dh_tmp);
1573     s->s3->peer_dh_tmp = NULL;
1574 #endif
1575 #ifndef OPENSSL_NO_EC
1576     EC_KEY_free(s->s3->peer_ecdh_tmp);
1577     s->s3->peer_ecdh_tmp = NULL;
1578 #endif
1579
1580     alg_a = s->s3->tmp.new_cipher->algorithm_auth;
1581
1582     al = SSL_AD_DECODE_ERROR;
1583
1584 #ifndef OPENSSL_NO_PSK
1585     /* PSK ciphersuites are preceded by an identity hint */
1586     if (alg_k & SSL_PSK) {
1587         PACKET psk_identity_hint;
1588         if (!PACKET_get_length_prefixed_2(&pkt, &psk_identity_hint)) {
1589             SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, SSL_R_LENGTH_MISMATCH);
1590             goto f_err;
1591         }
1592
1593         /*
1594          * Store PSK identity hint for later use, hint is used in
1595          * ssl3_send_client_key_exchange.  Assume that the maximum length of
1596          * a PSK identity hint can be as long as the maximum length of a PSK
1597          * identity.
1598          */
1599         if (PACKET_remaining(&psk_identity_hint) > PSK_MAX_IDENTITY_LEN) {
1600             al = SSL_AD_HANDSHAKE_FAILURE;
1601             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, SSL_R_DATA_LENGTH_TOO_LONG);
1602             goto f_err;
1603         }
1604
1605         if (!PACKET_strndup(&psk_identity_hint,
1606                             &s->session->psk_identity_hint)) {
1607             al = SSL_AD_INTERNAL_ERROR;
1608             goto f_err;
1609         }
1610     }
1611
1612     /* Nothing else to do for plain PSK or RSAPSK */
1613     if (alg_k & (SSL_kPSK | SSL_kRSAPSK)) {
1614     } else
1615 #endif                          /* !OPENSSL_NO_PSK */
1616 #ifndef OPENSSL_NO_SRP
1617     if (alg_k & SSL_kSRP) {
1618         PACKET prime, generator, salt, server_pub;
1619         if (!PACKET_get_length_prefixed_2(&pkt, &prime)
1620             || !PACKET_get_length_prefixed_2(&pkt, &generator)
1621             || !PACKET_get_length_prefixed_1(&pkt, &salt)
1622             || !PACKET_get_length_prefixed_2(&pkt, &server_pub)) {
1623             SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, SSL_R_LENGTH_MISMATCH);
1624             goto f_err;
1625         }
1626
1627         if ((s->srp_ctx.N =
1628              BN_bin2bn(PACKET_data(&prime),
1629                        PACKET_remaining(&prime), NULL)) == NULL
1630             || (s->srp_ctx.g =
1631                 BN_bin2bn(PACKET_data(&generator),
1632                           PACKET_remaining(&generator), NULL)) == NULL
1633             || (s->srp_ctx.s =
1634                 BN_bin2bn(PACKET_data(&salt),
1635                           PACKET_remaining(&salt), NULL)) == NULL
1636             || (s->srp_ctx.B =
1637                 BN_bin2bn(PACKET_data(&server_pub),
1638                           PACKET_remaining(&server_pub), NULL)) == NULL) {
1639             SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, ERR_R_BN_LIB);
1640             goto err;
1641         }
1642
1643         if (!srp_verify_server_param(s, &al)) {
1644             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, SSL_R_BAD_SRP_PARAMETERS);
1645             goto f_err;
1646         }
1647
1648 /* We must check if there is a certificate */
1649         if (alg_a & (SSL_aRSA|SSL_aDSS))
1650             pkey = X509_get_pubkey(s->session->peer);
1651     } else
1652 #endif                          /* !OPENSSL_NO_SRP */
1653 #ifndef OPENSSL_NO_RSA
1654     if (alg_k & SSL_kRSA) {
1655         PACKET mod, exp;
1656         /* Temporary RSA keys only allowed in export ciphersuites */
1657         if (!SSL_C_IS_EXPORT(s->s3->tmp.new_cipher)) {
1658             al = SSL_AD_UNEXPECTED_MESSAGE;
1659             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, SSL_R_UNEXPECTED_MESSAGE);
1660             goto f_err;
1661         }
1662
1663         if (!PACKET_get_length_prefixed_2(&pkt, &mod)
1664             || !PACKET_get_length_prefixed_2(&pkt, &exp)) {
1665             SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, SSL_R_LENGTH_MISMATCH);
1666             goto f_err;
1667         }
1668
1669         if ((rsa = RSA_new()) == NULL) {
1670             SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
1671             goto err;
1672         }
1673
1674         if ((rsa->n = BN_bin2bn(PACKET_data(&mod), PACKET_remaining(&mod),
1675                                 rsa->n)) == NULL
1676             || (rsa->e = BN_bin2bn(PACKET_data(&exp), PACKET_remaining(&exp),
1677                                    rsa->e)) == NULL) {
1678             SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, ERR_R_BN_LIB);
1679             goto err;
1680         }
1681
1682         /* this should be because we are using an export cipher */
1683         if (alg_a & SSL_aRSA)
1684             pkey = X509_get_pubkey(s->session->peer);
1685         else {
1686             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
1687             goto err;
1688         }
1689
1690         if (EVP_PKEY_bits(pkey) <= SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher)) {
1691             al = SSL_AD_UNEXPECTED_MESSAGE;
1692             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, SSL_R_UNEXPECTED_MESSAGE);
1693             goto f_err;
1694         }
1695
1696         s->s3->peer_rsa_tmp = rsa;
1697         rsa = NULL;
1698     }
1699 #else                           /* OPENSSL_NO_RSA */
1700     if (0) ;
1701 #endif
1702 #ifndef OPENSSL_NO_DH
1703     else if (alg_k & (SSL_kDHE | SSL_kDHEPSK)) {
1704         PACKET prime, generator, pub_key;
1705
1706         if (!PACKET_get_length_prefixed_2(&pkt, &prime)
1707             || !PACKET_get_length_prefixed_2(&pkt, &generator)
1708             || !PACKET_get_length_prefixed_2(&pkt, &pub_key)) {
1709             SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, SSL_R_LENGTH_MISMATCH);
1710             goto f_err;
1711         }
1712
1713         if ((dh = DH_new()) == NULL) {
1714             SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, ERR_R_DH_LIB);
1715             goto err;
1716         }
1717
1718         if ((dh->p = BN_bin2bn(PACKET_data(&prime),
1719                                PACKET_remaining(&prime), NULL)) == NULL
1720             || (dh->g = BN_bin2bn(PACKET_data(&generator),
1721                                   PACKET_remaining(&generator), NULL)) == NULL
1722             || (dh->pub_key =
1723                 BN_bin2bn(PACKET_data(&pub_key),
1724                           PACKET_remaining(&pub_key), NULL)) == NULL) {
1725             SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, ERR_R_BN_LIB);
1726             goto err;
1727         }
1728
1729         if (BN_is_zero(dh->p) || BN_is_zero(dh->g) || BN_is_zero(dh->pub_key)) {
1730             SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, SSL_R_BAD_DH_VALUE);
1731             goto f_err;
1732         }
1733
1734         if (!ssl_security(s, SSL_SECOP_TMP_DH, DH_security_bits(dh), 0, dh)) {
1735             al = SSL_AD_HANDSHAKE_FAILURE;
1736             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, SSL_R_DH_KEY_TOO_SMALL);
1737             goto f_err;
1738         }
1739         if (alg_a & (SSL_aRSA|SSL_aDSS))
1740             pkey = X509_get_pubkey(s->session->peer);
1741         /* else anonymous DH, so no certificate or pkey. */
1742
1743         s->s3->peer_dh_tmp = dh;
1744         dh = NULL;
1745     }
1746 #endif                          /* !OPENSSL_NO_DH */
1747
1748 #ifndef OPENSSL_NO_EC
1749     else if (alg_k & (SSL_kECDHE | SSL_kECDHEPSK)) {
1750         EC_GROUP *ngroup;
1751         const EC_GROUP *group;
1752         PACKET encoded_pt;
1753         unsigned char *ecparams;
1754
1755         if ((ecdh = EC_KEY_new()) == NULL) {
1756             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
1757             goto err;
1758         }
1759
1760         /*
1761          * Extract elliptic curve parameters and the server's ephemeral ECDH
1762          * public key. For now we only support named (not generic) curves and
1763          * ECParameters in this case is just three bytes.
1764          */
1765         if (!PACKET_get_bytes(&pkt, &ecparams, 3)) {
1766             SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, SSL_R_LENGTH_TOO_SHORT);
1767             goto f_err;
1768         }
1769         /*
1770          * Check curve is one of our preferences, if not server has sent an
1771          * invalid curve. ECParameters is 3 bytes.
1772          */
1773         if (!tls1_check_curve(s, ecparams, 3)) {
1774             SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, SSL_R_WRONG_CURVE);
1775             goto f_err;
1776         }
1777
1778         if ((curve_nid = tls1_ec_curve_id2nid(*(ecparams + 2))) == 0) {
1779             al = SSL_AD_INTERNAL_ERROR;
1780             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE,
1781                    SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS);
1782             goto f_err;
1783         }
1784
1785         ngroup = EC_GROUP_new_by_curve_name(curve_nid);
1786         if (ngroup == NULL) {
1787             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, ERR_R_EC_LIB);
1788             goto err;
1789         }
1790         if (EC_KEY_set_group(ecdh, ngroup) == 0) {
1791             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, ERR_R_EC_LIB);
1792             goto err;
1793         }
1794         EC_GROUP_free(ngroup);
1795
1796         group = EC_KEY_get0_group(ecdh);
1797
1798         if (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher) &&
1799             (EC_GROUP_get_degree(group) > 163)) {
1800             al = SSL_AD_EXPORT_RESTRICTION;
1801             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE,
1802                    SSL_R_ECGROUP_TOO_LARGE_FOR_CIPHER);
1803             goto f_err;
1804         }
1805
1806         /* Next, get the encoded ECPoint */
1807         if (((srvr_ecpoint = EC_POINT_new(group)) == NULL) ||
1808             ((bn_ctx = BN_CTX_new()) == NULL)) {
1809             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
1810             goto err;
1811         }
1812
1813         if (!PACKET_get_length_prefixed_1(&pkt, &encoded_pt)) {
1814             SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, SSL_R_LENGTH_MISMATCH);
1815             goto f_err;
1816         }
1817
1818         if (EC_POINT_oct2point(group, srvr_ecpoint, PACKET_data(&encoded_pt),
1819                                PACKET_remaining(&encoded_pt), bn_ctx) == 0) {
1820             SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, SSL_R_BAD_ECPOINT);
1821             goto f_err;
1822         }
1823
1824         /*
1825          * The ECC/TLS specification does not mention the use of DSA to sign
1826          * ECParameters in the server key exchange message. We do support RSA
1827          * and ECDSA.
1828          */
1829         if (0) ;
1830 # ifndef OPENSSL_NO_RSA
1831         else if (alg_a & SSL_aRSA)
1832             pkey = X509_get_pubkey(s->session->peer);
1833 # endif
1834 # ifndef OPENSSL_NO_EC
1835         else if (alg_a & SSL_aECDSA)
1836             pkey = X509_get_pubkey(s->session->peer);
1837 # endif
1838         /* else anonymous ECDH, so no certificate or pkey. */
1839         EC_KEY_set_public_key(ecdh, srvr_ecpoint);
1840         s->s3->peer_ecdh_tmp = ecdh;
1841         ecdh = NULL;
1842         BN_CTX_free(bn_ctx);
1843         bn_ctx = NULL;
1844         EC_POINT_free(srvr_ecpoint);
1845         srvr_ecpoint = NULL;
1846     } else if (alg_k) {
1847         al = SSL_AD_UNEXPECTED_MESSAGE;
1848         SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, SSL_R_UNEXPECTED_MESSAGE);
1849         goto f_err;
1850     }
1851 #endif                          /* !OPENSSL_NO_EC */
1852
1853     /* if it was signed, check the signature */
1854     if (pkey != NULL) {
1855         PACKET params;
1856         /*
1857          * |pkt| now points to the beginning of the signature, so the difference
1858          * equals the length of the parameters.
1859          */
1860         if (!PACKET_get_sub_packet(&save_param_start, &params,
1861                                    PACKET_remaining(&save_param_start) -
1862                                    PACKET_remaining(&pkt))) {
1863             al = SSL_AD_INTERNAL_ERROR;
1864             SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
1865             goto f_err;
1866         }
1867
1868         if (SSL_USE_SIGALGS(s)) {
1869             unsigned char *sigalgs;
1870             int rv;
1871             if (!PACKET_get_bytes(&pkt, &sigalgs, 2)) {
1872                 SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, SSL_R_LENGTH_TOO_SHORT);
1873                 goto f_err;
1874             }
1875             rv = tls12_check_peer_sigalg(&md, s, sigalgs, pkey);
1876             if (rv == -1)
1877                 goto err;
1878             else if (rv == 0) {
1879                 goto f_err;
1880             }
1881 #ifdef SSL_DEBUG
1882             fprintf(stderr, "USING TLSv1.2 HASH %s\n", EVP_MD_name(md));
1883 #endif
1884         } else {
1885             md = EVP_sha1();
1886         }
1887
1888         if (!PACKET_get_length_prefixed_2(&pkt, &signature)
1889             || PACKET_remaining(&pkt) != 0) {
1890             SSLerr(SSL_F_SSL3_GET_KEY_EXCHANGE, SSL_R_LENGTH_MISMATCH);
1891             goto f_err;
1892         }
1893         j = EVP_PKEY_size(pkey);
1894         if (j < 0) {
1895             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
1896             goto f_err;
1897         }
1898
1899         /*
1900          * Check signature length
1901          */
1902         if (PACKET_remaining(&signature) > (size_t)j) {
1903             /* wrong packet length */
1904             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, SSL_R_WRONG_SIGNATURE_LENGTH);
1905             goto f_err;
1906         }
1907 #ifndef OPENSSL_NO_RSA
1908         if (pkey->type == EVP_PKEY_RSA && !SSL_USE_SIGALGS(s)) {
1909             int num;
1910             unsigned int size;
1911
1912             j = 0;
1913             q = md_buf;
1914             for (num = 2; num > 0; num--) {
1915                 EVP_MD_CTX_set_flags(&md_ctx, EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
1916                 EVP_DigestInit_ex(&md_ctx, (num == 2)
1917                                   ? s->ctx->md5 : s->ctx->sha1, NULL);
1918                 EVP_DigestUpdate(&md_ctx, &(s->s3->client_random[0]),
1919                                  SSL3_RANDOM_SIZE);
1920                 EVP_DigestUpdate(&md_ctx, &(s->s3->server_random[0]),
1921                                  SSL3_RANDOM_SIZE);
1922                 EVP_DigestUpdate(&md_ctx, PACKET_data(&params),
1923                                  PACKET_remaining(&params));
1924                 EVP_DigestFinal_ex(&md_ctx, q, &size);
1925                 q += size;
1926                 j += size;
1927             }
1928             verify_ret =
1929                 RSA_verify(NID_md5_sha1, md_buf, j, PACKET_data(&signature),
1930                            PACKET_remaining(&signature), pkey->pkey.rsa);
1931             if (verify_ret < 0) {
1932                 al = SSL_AD_DECRYPT_ERROR;
1933                 SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, SSL_R_BAD_RSA_DECRYPT);
1934                 goto f_err;
1935             }
1936             if (verify_ret == 0) {
1937                 /* bad signature */
1938                 al = SSL_AD_DECRYPT_ERROR;
1939                 SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, SSL_R_BAD_SIGNATURE);
1940                 goto f_err;
1941             }
1942         } else
1943 #endif
1944         {
1945             EVP_VerifyInit_ex(&md_ctx, md, NULL);
1946             EVP_VerifyUpdate(&md_ctx, &(s->s3->client_random[0]),
1947                              SSL3_RANDOM_SIZE);
1948             EVP_VerifyUpdate(&md_ctx, &(s->s3->server_random[0]),
1949                              SSL3_RANDOM_SIZE);
1950             EVP_VerifyUpdate(&md_ctx, PACKET_data(&params),
1951                              PACKET_remaining(&params));
1952             if (EVP_VerifyFinal(&md_ctx, PACKET_data(&signature),
1953                                 PACKET_remaining(&signature), pkey) <= 0) {
1954                 /* bad signature */
1955                 al = SSL_AD_DECRYPT_ERROR;
1956                 SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, SSL_R_BAD_SIGNATURE);
1957                 goto f_err;
1958             }
1959         }
1960     } else {
1961         /* aNULL, aSRP or PSK do not need public keys */
1962         if (!(alg_a & (SSL_aNULL | SSL_aSRP)) && !(alg_k & SSL_PSK)) {
1963             /* Might be wrong key type, check it */
1964             if (ssl3_check_cert_and_algorithm(s))
1965                 /* Otherwise this shouldn't happen */
1966                 SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
1967             goto err;
1968         }
1969         /* still data left over */
1970         if (PACKET_remaining(&pkt) != 0) {
1971             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, SSL_R_EXTRA_DATA_IN_MESSAGE);
1972             goto f_err;
1973         }
1974     }
1975     EVP_PKEY_free(pkey);
1976     EVP_MD_CTX_cleanup(&md_ctx);
1977     return MSG_PROCESS_CONTINUE_READING;
1978  f_err:
1979     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1980  err:
1981     EVP_PKEY_free(pkey);
1982 #ifndef OPENSSL_NO_RSA
1983     RSA_free(rsa);
1984 #endif
1985 #ifndef OPENSSL_NO_DH
1986     DH_free(dh);
1987 #endif
1988 #ifndef OPENSSL_NO_EC
1989     BN_CTX_free(bn_ctx);
1990     EC_POINT_free(srvr_ecpoint);
1991     EC_KEY_free(ecdh);
1992 #endif
1993     EVP_MD_CTX_cleanup(&md_ctx);
1994     statem_set_error(s);
1995     return MSG_PROCESS_ERROR;
1996 }
1997
1998 int ssl3_get_certificate_request(SSL *s)
1999 {
2000     long n;
2001     int ok;
2002
2003     n = s->method->ssl_get_message(s,
2004                                    SSL3_ST_CR_CERT_REQ_A,
2005                                    SSL3_ST_CR_CERT_REQ_B,
2006                                    -1, s->max_cert_list, &ok);
2007
2008     if (!ok)
2009         return ((int)n);
2010
2011     s->s3->tmp.cert_req = 0;
2012
2013     if (s->s3->tmp.message_type == SSL3_MT_SERVER_DONE) {
2014         s->s3->tmp.reuse_message = 1;
2015         /*
2016          * If we get here we don't need any cached handshake records as we
2017          * wont be doing client auth.
2018          */
2019         if (!ssl3_digest_cached_records(s, 0))
2020             goto err;
2021         return (1);
2022     }
2023
2024     if (s->s3->tmp.message_type != SSL3_MT_CERTIFICATE_REQUEST) {
2025         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_UNEXPECTED_MESSAGE);
2026         SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST, SSL_R_WRONG_MESSAGE_TYPE);
2027         goto err;
2028     }
2029
2030     /* TLS does not like anon-DH with client cert */
2031     if (s->version > SSL3_VERSION) {
2032         if (s->s3->tmp.new_cipher->algorithm_auth & SSL_aNULL) {
2033             ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_UNEXPECTED_MESSAGE);
2034             SSLerr(SSL_F_SSL3_GET_CERTIFICATE_REQUEST,
2035                    SSL_R_TLS_CLIENT_CERT_REQ_WITH_ANON_CIPHER);
2036             goto err;
2037         }
2038     }
2039
2040     return tls_process_certificate_request(s, (unsigned long)n);
2041  err:
2042     s->state = SSL_ST_ERR;
2043     return -1;
2044 }
2045
2046
2047 enum MSG_PROCESS_RETURN tls_process_certificate_request(SSL *s, unsigned long n)
2048 {
2049     int ret = MSG_PROCESS_ERROR;
2050     unsigned int list_len, ctype_num, i, name_len;
2051     X509_NAME *xn = NULL;
2052     unsigned char *data;
2053     unsigned char *namestart, *namebytes;
2054     STACK_OF(X509_NAME) *ca_sk = NULL;
2055     PACKET pkt;
2056
2057     if (!PACKET_buf_init(&pkt, s->init_msg, n)) {
2058         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
2059         SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST, ERR_R_INTERNAL_ERROR);
2060         goto err;
2061     }
2062
2063     if ((ca_sk = sk_X509_NAME_new(ca_dn_cmp)) == NULL) {
2064         SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST, ERR_R_MALLOC_FAILURE);
2065         goto err;
2066     }
2067
2068     /* get the certificate types */
2069     if (!PACKET_get_1(&pkt, &ctype_num)
2070             || !PACKET_get_bytes(&pkt, &data, ctype_num)) {
2071         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
2072         SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST, SSL_R_LENGTH_MISMATCH);
2073         goto err;
2074     }
2075     OPENSSL_free(s->cert->ctypes);
2076     s->cert->ctypes = NULL;
2077     if (ctype_num > SSL3_CT_NUMBER) {
2078         /* If we exceed static buffer copy all to cert structure */
2079         s->cert->ctypes = OPENSSL_malloc(ctype_num);
2080         if (s->cert->ctypes == NULL) {
2081             SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST, ERR_R_MALLOC_FAILURE);
2082             goto err;
2083         }
2084         memcpy(s->cert->ctypes, data, ctype_num);
2085         s->cert->ctype_num = (size_t)ctype_num;
2086         ctype_num = SSL3_CT_NUMBER;
2087     }
2088     for (i = 0; i < ctype_num; i++)
2089         s->s3->tmp.ctype[i] = data[i];
2090
2091     if (SSL_USE_SIGALGS(s)) {
2092         if (!PACKET_get_net_2(&pkt, &list_len)
2093                 || !PACKET_get_bytes(&pkt, &data, list_len)) {
2094             ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
2095             SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST,
2096                    SSL_R_LENGTH_MISMATCH);
2097             goto err;
2098         }
2099
2100         /* Clear certificate digests and validity flags */
2101         for (i = 0; i < SSL_PKEY_NUM; i++) {
2102             s->s3->tmp.md[i] = NULL;
2103             s->s3->tmp.valid_flags[i] = 0;
2104         }
2105         if ((list_len & 1) || !tls1_save_sigalgs(s, data, list_len)) {
2106             ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
2107             SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST,
2108                    SSL_R_SIGNATURE_ALGORITHMS_ERROR);
2109             goto err;
2110         }
2111         if (!tls1_process_sigalgs(s)) {
2112             ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
2113             SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST, ERR_R_MALLOC_FAILURE);
2114             goto err;
2115         }
2116     }
2117
2118     /* get the CA RDNs */
2119     if (!PACKET_get_net_2(&pkt, &list_len)
2120             || PACKET_remaining(&pkt) != list_len) {
2121         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
2122         SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST, SSL_R_LENGTH_MISMATCH);
2123         goto err;
2124     }
2125
2126     while (PACKET_remaining(&pkt)) {
2127         if (!PACKET_get_net_2(&pkt, &name_len)
2128                 || !PACKET_get_bytes(&pkt, &namebytes, name_len)) {
2129             ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
2130             SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST,
2131                    SSL_R_LENGTH_MISMATCH);
2132             goto err;
2133         }
2134
2135         namestart = namebytes;
2136
2137         if ((xn = d2i_X509_NAME(NULL, (const unsigned char **)&namebytes,
2138                                 name_len)) == NULL) {
2139             ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
2140             SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST, ERR_R_ASN1_LIB);
2141             goto err;
2142         }
2143
2144         if (namebytes != (namestart + name_len)) {
2145             ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
2146             SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST,
2147                    SSL_R_CA_DN_LENGTH_MISMATCH);
2148             goto err;
2149         }
2150         if (!sk_X509_NAME_push(ca_sk, xn)) {
2151             SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST, ERR_R_MALLOC_FAILURE);
2152             goto err;
2153         }
2154     }
2155
2156     /* we should setup a certificate to return.... */
2157     s->s3->tmp.cert_req = 1;
2158     s->s3->tmp.ctype_num = ctype_num;
2159     sk_X509_NAME_pop_free(s->s3->tmp.ca_names, X509_NAME_free);
2160     s->s3->tmp.ca_names = ca_sk;
2161     ca_sk = NULL;
2162
2163     ret = MSG_PROCESS_CONTINUE_READING;
2164     goto done;
2165  err:
2166     statem_set_error(s);
2167  done:
2168     sk_X509_NAME_pop_free(ca_sk, X509_NAME_free);
2169     return ret;
2170 }
2171
2172 static int ca_dn_cmp(const X509_NAME *const *a, const X509_NAME *const *b)
2173 {
2174     return (X509_NAME_cmp(*a, *b));
2175 }
2176
2177 int ssl3_get_new_session_ticket(SSL *s)
2178 {
2179     long n;
2180     int ok;
2181
2182     n = s->method->ssl_get_message(s,
2183                                    SSL3_ST_CR_SESSION_TICKET_A,
2184                                    SSL3_ST_CR_SESSION_TICKET_B,
2185                                    SSL3_MT_NEWSESSION_TICKET, 16384, &ok);
2186
2187     if (!ok)
2188         return ((int)n);
2189
2190     return tls_process_new_session_ticket(s, (unsigned long)n);
2191 }
2192
2193 enum MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL *s, unsigned long n)
2194 {
2195     int al;
2196     unsigned int ticklen;
2197     unsigned long ticket_lifetime_hint;
2198     PACKET pkt;
2199
2200     if (!PACKET_buf_init(&pkt, s->init_msg, n)) {
2201         al = SSL_AD_INTERNAL_ERROR;
2202         SSLerr(SSL_F_TLS_PROCESS_NEW_SESSION_TICKET, ERR_R_INTERNAL_ERROR);
2203         goto f_err;
2204     }
2205
2206     if (!PACKET_get_net_4(&pkt, &ticket_lifetime_hint)
2207             || !PACKET_get_net_2(&pkt, &ticklen)
2208             || PACKET_remaining(&pkt) != ticklen) {
2209         al = SSL_AD_DECODE_ERROR;
2210         SSLerr(SSL_F_SSL3_GET_NEW_SESSION_TICKET, SSL_R_LENGTH_MISMATCH);
2211         goto f_err;
2212     }
2213
2214     /* Server is allowed to change its mind and send an empty ticket. */
2215     if (ticklen == 0)
2216         return 1;
2217
2218     if (s->session->session_id_length > 0) {
2219         int i = s->session_ctx->session_cache_mode;
2220         SSL_SESSION *new_sess;
2221         /*
2222          * We reused an existing session, so we need to replace it with a new
2223          * one
2224          */
2225         if (i & SSL_SESS_CACHE_CLIENT) {
2226             /*
2227              * Remove the old session from the cache
2228              */
2229             if (i & SSL_SESS_CACHE_NO_INTERNAL_STORE) {
2230                 if (s->session_ctx->remove_session_cb != NULL)
2231                     s->session_ctx->remove_session_cb(s->session_ctx,
2232                                                       s->session);
2233             } else {
2234                 /* We carry on if this fails */
2235                 SSL_CTX_remove_session(s->session_ctx, s->session);
2236             }
2237         }
2238
2239         if ((new_sess = ssl_session_dup(s->session, 0)) == 0) {
2240             al = SSL_AD_INTERNAL_ERROR;
2241             SSLerr(SSL_F_TLS_PROCESS_NEW_SESSION_TICKET, ERR_R_MALLOC_FAILURE);
2242             goto f_err;
2243         }
2244
2245         SSL_SESSION_free(s->session);
2246         s->session = new_sess;
2247     }
2248
2249     OPENSSL_free(s->session->tlsext_tick);
2250     s->session->tlsext_ticklen = 0;
2251
2252     s->session->tlsext_tick = OPENSSL_malloc(ticklen);
2253     if (!s->session->tlsext_tick) {
2254         SSLerr(SSL_F_TLS_PROCESS_NEW_SESSION_TICKET, ERR_R_MALLOC_FAILURE);
2255         goto err;
2256     }
2257     if (!PACKET_copy_bytes(&pkt, s->session->tlsext_tick, ticklen)) {
2258         al = SSL_AD_DECODE_ERROR;
2259         SSLerr(SSL_F_TLS_PROCESS_NEW_SESSION_TICKET, SSL_R_LENGTH_MISMATCH);
2260         goto f_err;
2261     }
2262
2263     s->session->tlsext_tick_lifetime_hint = ticket_lifetime_hint;
2264     s->session->tlsext_ticklen = ticklen;
2265     /*
2266      * There are two ways to detect a resumed ticket session. One is to set
2267      * an appropriate session ID and then the server must return a match in
2268      * ServerHello. This allows the normal client session ID matching to work
2269      * and we know much earlier that the ticket has been accepted. The
2270      * other way is to set zero length session ID when the ticket is
2271      * presented and rely on the handshake to determine session resumption.
2272      * We choose the former approach because this fits in with assumptions
2273      * elsewhere in OpenSSL. The session ID is set to the SHA256 (or SHA1 is
2274      * SHA256 is disabled) hash of the ticket.
2275      */
2276     EVP_Digest(s->session->tlsext_tick, ticklen,
2277                s->session->session_id, &s->session->session_id_length,
2278                EVP_sha256(), NULL);
2279     return MSG_PROCESS_CONTINUE_READING;
2280  f_err:
2281     ssl3_send_alert(s, SSL3_AL_FATAL, al);
2282  err:
2283     statem_set_error(s);
2284     return MSG_PROCESS_ERROR;
2285 }
2286
2287 int ssl3_get_cert_status(SSL *s)
2288 {
2289     long n;
2290     int ok;
2291
2292     n = s->method->ssl_get_message(s,
2293                                    SSL3_ST_CR_CERT_STATUS_A,
2294                                    SSL3_ST_CR_CERT_STATUS_B,
2295                                    SSL3_MT_CERTIFICATE_STATUS, 16384, &ok);
2296
2297     if (!ok)
2298         return ((int)n);
2299
2300     return tls_process_cert_status(s, (unsigned long)n);
2301 }
2302
2303 enum MSG_PROCESS_RETURN tls_process_cert_status(SSL *s, unsigned long n)
2304 {
2305     int al;
2306     unsigned long resplen;
2307     unsigned int type;
2308     PACKET pkt;
2309
2310     if (!PACKET_buf_init(&pkt, s->init_msg, n)) {
2311         al = SSL_AD_INTERNAL_ERROR;
2312         SSLerr(SSL_F_TLS_PROCESS_CERT_STATUS, ERR_R_INTERNAL_ERROR);
2313         goto f_err;
2314     }
2315     if (!PACKET_get_1(&pkt, &type)
2316             || type != TLSEXT_STATUSTYPE_ocsp) {
2317         al = SSL_AD_DECODE_ERROR;
2318         SSLerr(SSL_F_TLS_PROCESS_CERT_STATUS, SSL_R_UNSUPPORTED_STATUS_TYPE);
2319         goto f_err;
2320     }
2321     if (!PACKET_get_net_3(&pkt, &resplen)
2322             || PACKET_remaining(&pkt) != resplen) {
2323         al = SSL_AD_DECODE_ERROR;
2324         SSLerr(SSL_F_TLS_PROCESS_CERT_STATUS, SSL_R_LENGTH_MISMATCH);
2325         goto f_err;
2326     }
2327     OPENSSL_free(s->tlsext_ocsp_resp);
2328     s->tlsext_ocsp_resp = OPENSSL_malloc(resplen);
2329     if (!s->tlsext_ocsp_resp) {
2330         al = SSL_AD_INTERNAL_ERROR;
2331         SSLerr(SSL_F_TLS_PROCESS_CERT_STATUS, ERR_R_MALLOC_FAILURE);
2332         goto f_err;
2333     }
2334     if (!PACKET_copy_bytes(&pkt, s->tlsext_ocsp_resp, resplen)) {
2335         al = SSL_AD_DECODE_ERROR;
2336         SSLerr(SSL_F_TLS_PROCESS_CERT_STATUS, SSL_R_LENGTH_MISMATCH);
2337         goto f_err;
2338     }
2339     s->tlsext_ocsp_resplen = resplen;
2340     if (s->ctx->tlsext_status_cb) {
2341         int ret;
2342         ret = s->ctx->tlsext_status_cb(s, s->ctx->tlsext_status_arg);
2343         if (ret == 0) {
2344             al = SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE;
2345             SSLerr(SSL_F_TLS_PROCESS_CERT_STATUS, SSL_R_INVALID_STATUS_RESPONSE);
2346             goto f_err;
2347         }
2348         if (ret < 0) {
2349             al = SSL_AD_INTERNAL_ERROR;
2350             SSLerr(SSL_F_TLS_PROCESS_CERT_STATUS, ERR_R_MALLOC_FAILURE);
2351             goto f_err;
2352         }
2353     }
2354     return MSG_PROCESS_CONTINUE_READING;
2355  f_err:
2356     ssl3_send_alert(s, SSL3_AL_FATAL, al);
2357     statem_set_error(s);
2358     return MSG_PROCESS_ERROR;
2359 }
2360
2361 int ssl3_get_server_done(SSL *s)
2362 {
2363     long n;
2364     int ok;
2365
2366     /* Second to last param should be very small, like 0 :-) */
2367     n = s->method->ssl_get_message(s,
2368                                    SSL3_ST_CR_SRVR_DONE_A,
2369                                    SSL3_ST_CR_SRVR_DONE_B,
2370                                    SSL3_MT_SERVER_DONE, 30, &ok);
2371
2372     if (!ok)
2373         return ((int)n);
2374
2375     return tls_process_server_done(s, (unsigned long)n);
2376 }
2377
2378 enum MSG_PROCESS_RETURN tls_process_server_done(SSL *s, unsigned long n)
2379 {
2380     if (n > 0) {
2381         /* should contain no data */
2382         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
2383         SSLerr(SSL_F_TLS_PROCESS_SERVER_DONE, SSL_R_LENGTH_MISMATCH);
2384         statem_set_error(s);
2385         return MSG_PROCESS_ERROR;
2386     }
2387
2388 #ifndef OPENSSL_NO_SRP
2389     if (s->s3->tmp.new_cipher->algorithm_mkey & SSL_kSRP) {
2390         if (SRP_Calc_A_param(s) <= 0) {
2391             SSLerr(SSL_F_TLS_PROCESS_SERVER_DONE, SSL_R_SRP_A_CALC);
2392             ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
2393             statem_set_error(s);
2394             return MSG_PROCESS_ERROR;
2395         }
2396     }
2397 #endif
2398
2399     return MSG_PROCESS_FINISHED_READING;
2400 }
2401
2402 int ssl3_send_client_key_exchange(SSL *s)
2403 {
2404     int n;
2405
2406     if (s->state == SSL3_ST_CW_KEY_EXCH_A) {
2407         if(tls_construct_client_key_exchange(s) == 0)
2408             goto err;
2409
2410         s->state = SSL3_ST_CW_KEY_EXCH_B;
2411     }
2412
2413     /* SSL3_ST_CW_KEY_EXCH_B */
2414     n = ssl_do_write(s);
2415
2416     if (n > 0) {
2417         if (tls_client_key_exchange_post_work(s) == 0)
2418             goto err;
2419         }
2420
2421     return n;
2422  err:
2423     s->state = SSL_ST_ERR;
2424     return -1;
2425
2426 }
2427
2428 int tls_construct_client_key_exchange(SSL *s)
2429 {
2430     unsigned char *p;
2431     int n;
2432 #ifndef OPENSSL_NO_PSK
2433     size_t pskhdrlen = 0;
2434 #endif
2435     unsigned long alg_k;
2436 #ifndef OPENSSL_NO_RSA
2437     unsigned char *q;
2438     EVP_PKEY *pkey = NULL;
2439 #endif
2440 #ifndef OPENSSL_NO_EC
2441     EC_KEY *clnt_ecdh = NULL;
2442     const EC_POINT *srvr_ecpoint = NULL;
2443     EVP_PKEY *srvr_pub_pkey = NULL;
2444     unsigned char *encodedPoint = NULL;
2445     int encoded_pt_len = 0;
2446     BN_CTX *bn_ctx = NULL;
2447 #endif
2448     unsigned char *pms = NULL;
2449     size_t pmslen = 0;
2450     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
2451
2452     p = ssl_handshake_start(s);
2453
2454
2455 #ifndef OPENSSL_NO_PSK
2456     if (alg_k & SSL_PSK) {
2457         int psk_err = 1;
2458         /*
2459          * The callback needs PSK_MAX_IDENTITY_LEN + 1 bytes to return a
2460          * \0-terminated identity. The last byte is for us for simulating
2461          * strnlen.
2462          */
2463         char identity[PSK_MAX_IDENTITY_LEN + 1];
2464         size_t identitylen;
2465         unsigned char psk[PSK_MAX_PSK_LEN];
2466         size_t psklen;
2467
2468         if (s->psk_client_callback == NULL) {
2469             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE,
2470                    SSL_R_PSK_NO_CLIENT_CB);
2471             goto err;
2472         }
2473
2474         memset(identity, 0, sizeof(identity));
2475
2476         psklen = s->psk_client_callback(s, s->session->psk_identity_hint,
2477                                         identity, sizeof(identity) - 1,
2478                                         psk, sizeof(psk));
2479
2480         if (psklen > PSK_MAX_PSK_LEN) {
2481             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE,
2482                    ERR_R_INTERNAL_ERROR);
2483             goto psk_err;
2484         } else if (psklen == 0) {
2485             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE,
2486                    SSL_R_PSK_IDENTITY_NOT_FOUND);
2487             goto psk_err;
2488         }
2489
2490         OPENSSL_free(s->s3->tmp.psk);
2491         s->s3->tmp.psk = BUF_memdup(psk, psklen);
2492         OPENSSL_cleanse(psk, psklen);
2493
2494         if (s->s3->tmp.psk == NULL) {
2495             OPENSSL_cleanse(identity, sizeof(identity));
2496             goto memerr;
2497         }
2498
2499         s->s3->tmp.psklen = psklen;
2500
2501         identitylen = strlen(identity);
2502         if (identitylen > PSK_MAX_IDENTITY_LEN) {
2503             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE,
2504                    ERR_R_INTERNAL_ERROR);
2505             goto psk_err;
2506         }
2507         OPENSSL_free(s->session->psk_identity);
2508         s->session->psk_identity = BUF_strdup(identity);
2509         if (s->session->psk_identity == NULL) {
2510             OPENSSL_cleanse(identity, sizeof(identity));
2511             goto memerr;
2512         }
2513
2514         s2n(identitylen, p);
2515         memcpy(p, identity, identitylen);
2516         pskhdrlen = 2 + identitylen;
2517         p += identitylen;
2518         psk_err = 0;
2519 psk_err:
2520         OPENSSL_cleanse(identity, sizeof(identity));
2521         if (psk_err != 0) {
2522             ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_HANDSHAKE_FAILURE);
2523             goto err;
2524         }
2525     }
2526     if (alg_k & SSL_kPSK) {
2527         n = 0;
2528     } else
2529 #endif
2530
2531     /* Fool emacs indentation */
2532     if (0) {
2533     }
2534 #ifndef OPENSSL_NO_RSA
2535     else if (alg_k & (SSL_kRSA | SSL_kRSAPSK)) {
2536         RSA *rsa;
2537         pmslen = SSL_MAX_MASTER_KEY_LENGTH;
2538         pms = OPENSSL_malloc(pmslen);
2539         if (!pms)
2540             goto memerr;
2541
2542         if (s->session->peer == NULL) {
2543             /*
2544              * We should always have a server certificate with SSL_kRSA.
2545              */
2546             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE,
2547                    ERR_R_INTERNAL_ERROR);
2548             goto err;
2549         }
2550
2551         if (s->s3->peer_rsa_tmp != NULL)
2552             rsa = s->s3->peer_rsa_tmp;
2553         else {
2554             pkey = X509_get_pubkey(s->session->peer);
2555             if ((pkey == NULL) || (pkey->type != EVP_PKEY_RSA)
2556                 || (pkey->pkey.rsa == NULL)) {
2557                 SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE,
2558                        ERR_R_INTERNAL_ERROR);
2559                 EVP_PKEY_free(pkey);
2560                 goto err;
2561             }
2562             rsa = pkey->pkey.rsa;
2563             EVP_PKEY_free(pkey);
2564         }
2565
2566         pms[0] = s->client_version >> 8;
2567         pms[1] = s->client_version & 0xff;
2568         if (RAND_bytes(pms + 2, pmslen - 2) <= 0)
2569             goto err;
2570
2571         q = p;
2572         /* Fix buf for TLS and beyond */
2573         if (s->version > SSL3_VERSION)
2574             p += 2;
2575         n = RSA_public_encrypt(pmslen, pms, p, rsa, RSA_PKCS1_PADDING);
2576 # ifdef PKCS1_CHECK
2577         if (s->options & SSL_OP_PKCS1_CHECK_1)
2578             p[1]++;
2579         if (s->options & SSL_OP_PKCS1_CHECK_2)
2580             tmp_buf[0] = 0x70;
2581 # endif
2582         if (n <= 0) {
2583             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE,
2584                    SSL_R_BAD_RSA_ENCRYPT);
2585             goto err;
2586         }
2587
2588         /* Fix buf for TLS and beyond */
2589         if (s->version > SSL3_VERSION) {
2590             s2n(n, q);
2591             n += 2;
2592         }
2593     }
2594 #endif
2595 #ifndef OPENSSL_NO_DH
2596     else if (alg_k & (SSL_kDHE | SSL_kDHr | SSL_kDHd | SSL_kDHEPSK)) {
2597         DH *dh_srvr, *dh_clnt;
2598         if (s->s3->peer_dh_tmp != NULL)
2599             dh_srvr = s->s3->peer_dh_tmp;
2600         else {
2601             /* we get them from the cert */
2602             EVP_PKEY *spkey = NULL;
2603             dh_srvr = NULL;
2604             spkey = X509_get_pubkey(s->session->peer);
2605             if (spkey) {
2606                 dh_srvr = EVP_PKEY_get1_DH(spkey);
2607                 EVP_PKEY_free(spkey);
2608             }
2609             if (dh_srvr == NULL) {
2610                 SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE,
2611                        ERR_R_INTERNAL_ERROR);
2612                 goto err;
2613             }
2614         }
2615         if (s->s3->flags & TLS1_FLAGS_SKIP_CERT_VERIFY) {
2616             /* Use client certificate key */
2617             EVP_PKEY *clkey = s->cert->key->privatekey;
2618             dh_clnt = NULL;
2619             if (clkey)
2620                 dh_clnt = EVP_PKEY_get1_DH(clkey);
2621             if (dh_clnt == NULL) {
2622                 SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE,
2623                        ERR_R_INTERNAL_ERROR);
2624                 goto err;
2625             }
2626         } else {
2627             /* generate a new random key */
2628             if ((dh_clnt = DHparams_dup(dh_srvr)) == NULL) {
2629                 SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE, ERR_R_DH_LIB);
2630                 goto err;
2631             }
2632             if (!DH_generate_key(dh_clnt)) {
2633                 SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE, ERR_R_DH_LIB);
2634                 DH_free(dh_clnt);
2635                 goto err;
2636             }
2637         }
2638
2639         pmslen = DH_size(dh_clnt);
2640         pms = OPENSSL_malloc(pmslen);
2641         if (!pms)
2642             goto memerr;
2643
2644         /*
2645          * use the 'p' output buffer for the DH key, but make sure to
2646          * clear it out afterwards
2647          */
2648
2649         n = DH_compute_key(pms, dh_srvr->pub_key, dh_clnt);
2650         if (s->s3->peer_dh_tmp == NULL)
2651             DH_free(dh_srvr);
2652
2653         if (n <= 0) {
2654             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE, ERR_R_DH_LIB);
2655             DH_free(dh_clnt);
2656             goto err;
2657         }
2658         pmslen = n;
2659
2660         if (s->s3->flags & TLS1_FLAGS_SKIP_CERT_VERIFY)
2661             n = 0;
2662         else {
2663             /* send off the data */
2664             n = BN_num_bytes(dh_clnt->pub_key);
2665             s2n(n, p);
2666             BN_bn2bin(dh_clnt->pub_key, p);
2667             n += 2;
2668         }
2669
2670         DH_free(dh_clnt);
2671     }
2672 #endif
2673
2674 #ifndef OPENSSL_NO_EC
2675     else if (alg_k & (SSL_kECDHE | SSL_kECDHr | SSL_kECDHe | SSL_kECDHEPSK)) {
2676         const EC_GROUP *srvr_group = NULL;
2677         EC_KEY *tkey;
2678         int ecdh_clnt_cert = 0;
2679         int field_size = 0;
2680         /*
2681          * Did we send out the client's ECDH share for use in premaster
2682          * computation as part of client certificate? If so, set
2683          * ecdh_clnt_cert to 1.
2684          */
2685         if ((alg_k & (SSL_kECDHr | SSL_kECDHe)) && (s->cert != NULL)) {
2686             /*-
2687              * XXX: For now, we do not support client
2688              * authentication using ECDH certificates.
2689              * To add such support, one needs to add
2690              * code that checks for appropriate
2691              * conditions and sets ecdh_clnt_cert to 1.
2692              * For example, the cert have an ECC
2693              * key on the same curve as the server's
2694              * and the key should be authorized for
2695              * key agreement.
2696              *
2697              * One also needs to add code in ssl3_connect
2698              * to skip sending the certificate verify
2699              * message.
2700              *
2701              * if ((s->cert->key->privatekey != NULL) &&
2702              *     (s->cert->key->privatekey->type ==
2703              *      EVP_PKEY_EC) && ...)
2704              * ecdh_clnt_cert = 1;
2705              */
2706         }
2707
2708         if (s->s3->peer_ecdh_tmp != NULL) {
2709             tkey = s->s3->peer_ecdh_tmp;
2710         } else {
2711             /* Get the Server Public Key from Cert */
2712             srvr_pub_pkey = X509_get_pubkey(s->session->peer);
2713             if ((srvr_pub_pkey == NULL)
2714                 || (srvr_pub_pkey->type != EVP_PKEY_EC)
2715                 || (srvr_pub_pkey->pkey.ec == NULL)) {
2716                 SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE,
2717                        ERR_R_INTERNAL_ERROR);
2718                 goto err;
2719             }
2720
2721             tkey = srvr_pub_pkey->pkey.ec;
2722         }
2723
2724         srvr_group = EC_KEY_get0_group(tkey);
2725         srvr_ecpoint = EC_KEY_get0_public_key(tkey);
2726
2727         if ((srvr_group == NULL) || (srvr_ecpoint == NULL)) {
2728             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE,
2729                    ERR_R_INTERNAL_ERROR);
2730             goto err;
2731         }
2732
2733         if ((clnt_ecdh = EC_KEY_new()) == NULL) {
2734             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE,
2735                    ERR_R_MALLOC_FAILURE);
2736             goto err;
2737         }
2738
2739         if (!EC_KEY_set_group(clnt_ecdh, srvr_group)) {
2740             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE, ERR_R_EC_LIB);
2741             goto err;
2742         }
2743         if (ecdh_clnt_cert) {
2744             /*
2745              * Reuse key info from our certificate We only need our
2746              * private key to perform the ECDH computation.
2747              */
2748             const BIGNUM *priv_key;
2749             tkey = s->cert->key->privatekey->pkey.ec;
2750             priv_key = EC_KEY_get0_private_key(tkey);
2751             if (priv_key == NULL) {
2752                 SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE,
2753                        ERR_R_MALLOC_FAILURE);
2754                 goto err;
2755             }
2756             if (!EC_KEY_set_private_key(clnt_ecdh, priv_key)) {
2757                 SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE, ERR_R_EC_LIB);
2758                 goto err;
2759             }
2760         } else {
2761             /* Generate a new ECDH key pair */
2762             if (!(EC_KEY_generate_key(clnt_ecdh))) {
2763                 SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE,
2764                        ERR_R_ECDH_LIB);
2765                 goto err;
2766             }
2767         }
2768
2769         /*
2770          * use the 'p' output buffer for the ECDH key, but make sure to
2771          * clear it out afterwards
2772          */
2773
2774         field_size = EC_GROUP_get_degree(srvr_group);
2775         if (field_size <= 0) {
2776             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE, ERR_R_ECDH_LIB);
2777             goto err;
2778         }
2779         pmslen = (field_size + 7) / 8;
2780         pms = OPENSSL_malloc(pmslen);
2781         if (!pms)
2782             goto memerr;
2783         n = ECDH_compute_key(pms, pmslen, srvr_ecpoint, clnt_ecdh, NULL);
2784         if (n <= 0 || pmslen != (size_t)n) {
2785             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE, ERR_R_ECDH_LIB);
2786             goto err;
2787         }
2788
2789         if (ecdh_clnt_cert) {
2790             /* Send empty client key exch message */
2791             n = 0;
2792         } else {
2793             /*
2794              * First check the size of encoding and allocate memory
2795              * accordingly.
2796              */
2797             encoded_pt_len =
2798                 EC_POINT_point2oct(srvr_group,
2799                                    EC_KEY_get0_public_key(clnt_ecdh),
2800                                    POINT_CONVERSION_UNCOMPRESSED,
2801                                    NULL, 0, NULL);
2802
2803             encodedPoint = (unsigned char *)
2804                 OPENSSL_malloc(encoded_pt_len * sizeof(unsigned char));
2805             bn_ctx = BN_CTX_new();
2806             if ((encodedPoint == NULL) || (bn_ctx == NULL)) {
2807                 SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE,
2808                        ERR_R_MALLOC_FAILURE);
2809                 goto err;
2810             }
2811
2812             /* Encode the public key */
2813             n = EC_POINT_point2oct(srvr_group,
2814                                    EC_KEY_get0_public_key(clnt_ecdh),
2815                                    POINT_CONVERSION_UNCOMPRESSED,
2816                                    encodedPoint, encoded_pt_len, bn_ctx);
2817
2818             *p = n;         /* length of encoded point */
2819             /* Encoded point will be copied here */
2820             p += 1;
2821             /* copy the point */
2822             memcpy(p, encodedPoint, n);
2823             /* increment n to account for length field */
2824             n += 1;
2825         }
2826
2827         /* Free allocated memory */
2828         BN_CTX_free(bn_ctx);
2829         OPENSSL_free(encodedPoint);
2830         EC_KEY_free(clnt_ecdh);
2831         EVP_PKEY_free(srvr_pub_pkey);
2832     }
2833 #endif                          /* !OPENSSL_NO_EC */
2834     else if (alg_k & SSL_kGOST) {
2835         /* GOST key exchange message creation */
2836         EVP_PKEY_CTX *pkey_ctx;
2837         X509 *peer_cert;
2838         size_t msglen;
2839         unsigned int md_len;
2840         unsigned char shared_ukm[32], tmp[256];
2841         EVP_MD_CTX *ukm_hash;
2842         EVP_PKEY *pub_key;
2843
2844         pmslen = 32;
2845         pms = OPENSSL_malloc(pmslen);
2846         if (!pms)
2847             goto memerr;
2848
2849         /*
2850          * Get server sertificate PKEY and create ctx from it
2851          */
2852         peer_cert = s->session->peer;
2853         if (!peer_cert) {
2854             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE,
2855                    SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER);
2856             goto err;
2857         }
2858
2859         pkey_ctx = EVP_PKEY_CTX_new(pub_key =
2860                                     X509_get_pubkey(peer_cert), NULL);
2861         /*
2862          * If we have send a certificate, and certificate key
2863          *
2864          * * parameters match those of server certificate, use
2865          * certificate key for key exchange
2866          */
2867
2868         /* Otherwise, generate ephemeral key pair */
2869
2870         EVP_PKEY_encrypt_init(pkey_ctx);
2871         /* Generate session key */
2872         if (RAND_bytes(pms, pmslen) <= 0) {
2873             EVP_PKEY_CTX_free(pkey_ctx);
2874             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE,
2875                    ERR_R_INTERNAL_ERROR);
2876             goto err;
2877         };
2878         /*
2879          * If we have client certificate, use its secret as peer key
2880          */
2881         if (s->s3->tmp.cert_req && s->cert->key->privatekey) {
2882             if (EVP_PKEY_derive_set_peer
2883                 (pkey_ctx, s->cert->key->privatekey) <= 0) {
2884                 /*
2885                  * If there was an error - just ignore it. Ephemeral key
2886                  * * would be used
2887                  */
2888                 ERR_clear_error();
2889             }
2890         }
2891         /*
2892          * Compute shared IV and store it in algorithm-specific context
2893          * data
2894          */
2895         ukm_hash = EVP_MD_CTX_create();
2896         EVP_DigestInit(ukm_hash,
2897                        EVP_get_digestbynid(NID_id_GostR3411_94));
2898         EVP_DigestUpdate(ukm_hash, s->s3->client_random,
2899                          SSL3_RANDOM_SIZE);
2900         EVP_DigestUpdate(ukm_hash, s->s3->server_random,
2901                          SSL3_RANDOM_SIZE);
2902         EVP_DigestFinal_ex(ukm_hash, shared_ukm, &md_len);
2903         EVP_MD_CTX_destroy(ukm_hash);
2904         if (EVP_PKEY_CTX_ctrl
2905             (pkey_ctx, -1, EVP_PKEY_OP_ENCRYPT, EVP_PKEY_CTRL_SET_IV, 8,
2906              shared_ukm) < 0) {
2907             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE,
2908                    SSL_R_LIBRARY_BUG);
2909             goto err;
2910         }
2911         /* Make GOST keytransport blob message */
2912         /*
2913          * Encapsulate it into sequence
2914          */
2915         *(p++) = V_ASN1_SEQUENCE | V_ASN1_CONSTRUCTED;
2916         msglen = 255;
2917         if (EVP_PKEY_encrypt(pkey_ctx, tmp, &msglen, pms, pmslen) < 0) {
2918             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE,
2919                    SSL_R_LIBRARY_BUG);
2920             goto err;
2921         }
2922         if (msglen >= 0x80) {
2923             *(p++) = 0x81;
2924             *(p++) = msglen & 0xff;
2925             n = msglen + 3;
2926         } else {
2927             *(p++) = msglen & 0xff;
2928             n = msglen + 2;
2929         }
2930         memcpy(p, tmp, msglen);
2931         /* Check if pubkey from client certificate was used */
2932         if (EVP_PKEY_CTX_ctrl
2933             (pkey_ctx, -1, -1, EVP_PKEY_CTRL_PEER_KEY, 2, NULL) > 0) {
2934             /* Set flag "skip certificate verify" */
2935             s->s3->flags |= TLS1_FLAGS_SKIP_CERT_VERIFY;
2936         }
2937         EVP_PKEY_CTX_free(pkey_ctx);
2938         EVP_PKEY_free(pub_key);
2939
2940     }
2941 #ifndef OPENSSL_NO_SRP
2942     else if (alg_k & SSL_kSRP) {
2943         if (s->srp_ctx.A != NULL) {
2944             /* send off the data */
2945             n = BN_num_bytes(s->srp_ctx.A);
2946             s2n(n, p);
2947             BN_bn2bin(s->srp_ctx.A, p);
2948             n += 2;
2949         } else {
2950             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE,
2951                    ERR_R_INTERNAL_ERROR);
2952             goto err;
2953         }
2954         OPENSSL_free(s->session->srp_username);
2955         s->session->srp_username = BUF_strdup(s->srp_ctx.login);
2956         if (s->session->srp_username == NULL) {
2957             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE,
2958                    ERR_R_MALLOC_FAILURE);
2959             goto err;
2960         }
2961     }
2962 #endif
2963     else {
2964         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_HANDSHAKE_FAILURE);
2965         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2966         goto err;
2967     }
2968
2969 #ifndef OPENSSL_NO_PSK
2970     n += pskhdrlen;
2971 #endif
2972
2973     if (!ssl_set_handshake_header(s, SSL3_MT_CLIENT_KEY_EXCHANGE, n)) {
2974         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_HANDSHAKE_FAILURE);
2975         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2976         goto err;
2977     }
2978
2979     s->s3->tmp.pms = pms;
2980     s->s3->tmp.pmslen = pmslen;
2981
2982     return 1;
2983  memerr:
2984     ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
2985     SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
2986  err:
2987     OPENSSL_clear_free(pms, pmslen);
2988     s->s3->tmp.pms = NULL;
2989 #ifndef OPENSSL_NO_EC
2990     BN_CTX_free(bn_ctx);
2991     OPENSSL_free(encodedPoint);
2992     EC_KEY_free(clnt_ecdh);
2993     EVP_PKEY_free(srvr_pub_pkey);
2994 #endif
2995 #ifndef OPENSSL_NO_PSK
2996     OPENSSL_clear_free(s->s3->tmp.psk, s->s3->tmp.psklen);
2997     s->s3->tmp.psk = NULL;
2998 #endif
2999     statem_set_error(s);
3000     return 0;
3001 }
3002
3003 int tls_client_key_exchange_post_work(SSL *s)
3004 {
3005     unsigned char *pms = NULL;
3006     size_t pmslen = 0;
3007
3008 #ifndef OPENSSL_NO_SRP
3009     /* Check for SRP */
3010     if (s->s3->tmp.new_cipher->algorithm_mkey & SSL_kSRP) {
3011         if (!srp_generate_client_master_secret(s)) {
3012             SSLerr(SSL_F_TLS_CLIENT_KEY_EXCHANGE_POST_WORK,
3013                    ERR_R_INTERNAL_ERROR);
3014             goto err;
3015         }
3016         return 1;
3017     }
3018 #endif
3019     pms = s->s3->tmp.pms;
3020     pmslen = s->s3->tmp.pmslen;
3021
3022     if (pms == NULL && !(s->s3->tmp.new_cipher->algorithm_mkey & SSL_kPSK)) {
3023         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
3024         SSLerr(SSL_F_TLS_CLIENT_KEY_EXCHANGE_POST_WORK, ERR_R_MALLOC_FAILURE);
3025         goto err;
3026     }
3027     if (!ssl_generate_master_secret(s, pms, pmslen, 1)) {
3028         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
3029         SSLerr(SSL_F_TLS_CLIENT_KEY_EXCHANGE_POST_WORK, ERR_R_INTERNAL_ERROR);
3030         goto err;
3031     }
3032     return 1;
3033  err:
3034     OPENSSL_clear_free(pms, pmslen);
3035     s->s3->tmp.pms = NULL;
3036     return 0;
3037 }
3038
3039 int ssl3_send_client_verify(SSL *s)
3040 {
3041     if (s->state == SSL3_ST_CW_CERT_VRFY_A) {
3042         if(tls_construct_client_verify(s) == 0)
3043             goto err;
3044
3045         s->state = SSL3_ST_CW_CERT_VRFY_B;
3046     }
3047
3048     /* SSL3_ST_CW_CERT_VRFY_B */
3049     return ssl_do_write(s);
3050  err:
3051     s->state = SSL_ST_ERR;
3052     return -1;
3053
3054 }
3055
3056 int tls_construct_client_verify(SSL *s)
3057 {
3058     unsigned char *p;
3059     unsigned char data[MD5_DIGEST_LENGTH + SHA_DIGEST_LENGTH];
3060     EVP_PKEY *pkey;
3061     EVP_PKEY_CTX *pctx = NULL;
3062     EVP_MD_CTX mctx;
3063     unsigned u = 0;
3064     unsigned long n;
3065     int j;
3066
3067     EVP_MD_CTX_init(&mctx);
3068
3069     p = ssl_handshake_start(s);
3070     pkey = s->cert->key->privatekey;
3071 /* Create context from key and test if sha1 is allowed as digest */
3072     pctx = EVP_PKEY_CTX_new(pkey, NULL);
3073     EVP_PKEY_sign_init(pctx);
3074     if (EVP_PKEY_CTX_set_signature_md(pctx, EVP_sha1()) > 0) {
3075         if (!SSL_USE_SIGALGS(s))
3076             s->method->ssl3_enc->cert_verify_mac(s,
3077                                                  NID_sha1,
3078                                                  &(data
3079                                                    [MD5_DIGEST_LENGTH]));
3080     } else {
3081         ERR_clear_error();
3082     }
3083     /*
3084      * For TLS v1.2 send signature algorithm and signature using agreed
3085      * digest and cached handshake records.
3086      */
3087     if (SSL_USE_SIGALGS(s)) {
3088         long hdatalen = 0;
3089         void *hdata;
3090         const EVP_MD *md = s->s3->tmp.md[s->cert->key - s->cert->pkeys];
3091         hdatalen = BIO_get_mem_data(s->s3->handshake_buffer, &hdata);
3092         if (hdatalen <= 0 || !tls12_get_sigandhash(p, pkey, md)) {
3093             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_VERIFY, ERR_R_INTERNAL_ERROR);
3094             goto err;
3095         }
3096         p += 2;
3097 #ifdef SSL_DEBUG
3098         fprintf(stderr, "Using TLS 1.2 with client alg %s\n",
3099                 EVP_MD_name(md));
3100 #endif
3101         if (!EVP_SignInit_ex(&mctx, md, NULL)
3102             || !EVP_SignUpdate(&mctx, hdata, hdatalen)
3103             || !EVP_SignFinal(&mctx, p + 2, &u, pkey)) {
3104             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_VERIFY, ERR_R_EVP_LIB);
3105             goto err;
3106         }
3107         s2n(u, p);
3108         n = u + 4;
3109         /* Digest cached records and discard handshake buffer */
3110         if (!ssl3_digest_cached_records(s, 0))
3111             goto err;
3112     } else
3113 #ifndef OPENSSL_NO_RSA
3114     if (pkey->type == EVP_PKEY_RSA) {
3115         s->method->ssl3_enc->cert_verify_mac(s, NID_md5, &(data[0]));
3116         if (RSA_sign(NID_md5_sha1, data,
3117                      MD5_DIGEST_LENGTH + SHA_DIGEST_LENGTH,
3118                      &(p[2]), &u, pkey->pkey.rsa) <= 0) {
3119             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_VERIFY, ERR_R_RSA_LIB);
3120             goto err;
3121         }
3122         s2n(u, p);
3123         n = u + 2;
3124     } else
3125 #endif
3126 #ifndef OPENSSL_NO_DSA
3127     if (pkey->type == EVP_PKEY_DSA) {
3128         if (!DSA_sign(pkey->save_type,
3129                       &(data[MD5_DIGEST_LENGTH]),
3130                       SHA_DIGEST_LENGTH, &(p[2]),
3131                       (unsigned int *)&j, pkey->pkey.dsa)) {
3132             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_VERIFY, ERR_R_DSA_LIB);
3133             goto err;
3134         }
3135         s2n(j, p);
3136         n = j + 2;
3137     } else
3138 #endif
3139 #ifndef OPENSSL_NO_EC
3140     if (pkey->type == EVP_PKEY_EC) {
3141         if (!ECDSA_sign(pkey->save_type,
3142                         &(data[MD5_DIGEST_LENGTH]),
3143                         SHA_DIGEST_LENGTH, &(p[2]),
3144                         (unsigned int *)&j, pkey->pkey.ec)) {
3145             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_VERIFY, ERR_R_ECDSA_LIB);
3146             goto err;
3147         }
3148         s2n(j, p);
3149         n = j + 2;
3150     } else
3151 #endif
3152     if (pkey->type == NID_id_GostR3410_2001) {
3153         unsigned char signbuf[64];
3154         int i;
3155         size_t sigsize = 64;
3156         s->method->ssl3_enc->cert_verify_mac(s,
3157                                              NID_id_GostR3411_94, data);
3158         if (EVP_PKEY_sign(pctx, signbuf, &sigsize, data, 32) <= 0) {
3159             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_VERIFY, ERR_R_INTERNAL_ERROR);
3160             goto err;
3161         }
3162         for (i = 63, j = 0; i >= 0; j++, i--) {
3163             p[2 + j] = signbuf[i];
3164         }
3165         s2n(j, p);
3166         n = j + 2;
3167     } else {
3168         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_VERIFY, ERR_R_INTERNAL_ERROR);
3169         goto err;
3170     }
3171     if (!ssl_set_handshake_header(s, SSL3_MT_CERTIFICATE_VERIFY, n)) {
3172         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_VERIFY, ERR_R_INTERNAL_ERROR);
3173         goto err;
3174     }
3175
3176     EVP_MD_CTX_cleanup(&mctx);
3177     EVP_PKEY_CTX_free(pctx);
3178     return 1;
3179  err:
3180     EVP_MD_CTX_cleanup(&mctx);
3181     EVP_PKEY_CTX_free(pctx);
3182     return 0;
3183 }
3184
3185 /*
3186  * Check a certificate can be used for client authentication. Currently check
3187  * cert exists, if we have a suitable digest for TLS 1.2 if static DH client
3188  * certificates can be used and optionally checks suitability for Suite B.
3189  */
3190 static int ssl3_check_client_certificate(SSL *s)
3191 {
3192     unsigned long alg_k;
3193     if (!s->cert || !s->cert->key->x509 || !s->cert->key->privatekey)
3194         return 0;
3195     /* If no suitable signature algorithm can't use certificate */
3196     if (SSL_USE_SIGALGS(s) && !s->s3->tmp.md[s->cert->key - s->cert->pkeys])
3197         return 0;
3198     /*
3199      * If strict mode check suitability of chain before using it. This also
3200      * adjusts suite B digest if necessary.
3201      */
3202     if (s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT &&
3203         !tls1_check_chain(s, NULL, NULL, NULL, -2))
3204         return 0;
3205     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
3206     /* See if we can use client certificate for fixed DH */
3207     if (alg_k & (SSL_kDHr | SSL_kDHd)) {
3208         int i = s->session->peer_type;
3209         EVP_PKEY *clkey = NULL, *spkey = NULL;
3210         clkey = s->cert->key->privatekey;
3211         /* If client key not DH assume it can be used */
3212         if (EVP_PKEY_id(clkey) != EVP_PKEY_DH)
3213             return 1;
3214         if (i >= 0)
3215             spkey = X509_get_pubkey(s->session->peer);
3216         if (spkey) {
3217             /* Compare server and client parameters */
3218             i = EVP_PKEY_cmp_parameters(clkey, spkey);
3219             EVP_PKEY_free(spkey);
3220             if (i != 1)
3221                 return 0;
3222         }
3223         s->s3->flags |= TLS1_FLAGS_SKIP_CERT_VERIFY;
3224     }
3225     return 1;
3226 }
3227
3228
3229 int ssl3_send_client_certificate(SSL *s)
3230 {
3231     enum WORK_STATE wst;
3232
3233     if (s->state == SSL3_ST_CW_CERT_A || s->state == SSL3_ST_CW_CERT_B) {
3234         if (s->state == SSL3_ST_CW_CERT_A)
3235             wst = tls_prepare_client_certificate(s, WORK_MORE_A);
3236         else
3237             wst = tls_prepare_client_certificate(s, WORK_MORE_B);
3238         if (wst == WORK_ERROR)
3239             goto err;
3240         if (wst == WORK_MORE_A)
3241             return -1;
3242         if (wst == WORK_MORE_B) {
3243             s->state = SSL3_ST_CW_CERT_B;
3244             return -1;
3245         }
3246
3247         s->state = SSL3_ST_CW_CERT_C;
3248     }
3249
3250     if (s->state == SSL3_ST_CW_CERT_B) {
3251         wst = tls_prepare_client_certificate(s, WORK_MORE_B);
3252         if (wst == WORK_ERROR)
3253             goto err;
3254         if (wst == WORK_MORE_A)
3255             return -1;
3256
3257         /* Skip state C...it was entirely temporary in the original code */
3258         s->state = SSL3_ST_CW_CERT_D;
3259     }
3260
3261     if (tls_construct_client_certificate(s) == 0)
3262         goto err;
3263
3264     return ssl_do_write(s);
3265  err:
3266     s->state = SSL_ST_ERR;
3267     return -1;
3268
3269 }
3270
3271 enum WORK_STATE tls_prepare_client_certificate(SSL *s, enum WORK_STATE wst)
3272 {
3273     X509 *x509 = NULL;
3274     EVP_PKEY *pkey = NULL;
3275     int i;
3276
3277     if (wst == WORK_MORE_A) {
3278         /* Let cert callback update client certificates if required */
3279         if (s->cert->cert_cb) {
3280             i = s->cert->cert_cb(s, s->cert->cert_cb_arg);
3281             if (i < 0) {
3282                 s->rwstate = SSL_X509_LOOKUP;
3283                 return WORK_MORE_A;
3284             }
3285             if (i == 0) {
3286                 ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
3287                 statem_set_error(s);
3288                 return 0;
3289             }
3290             s->rwstate = SSL_NOTHING;
3291         }
3292         if (ssl3_check_client_certificate(s))
3293             return WORK_FINISHED_CONTINUE;
3294
3295         /* Fall through to WORK_MORE_B */
3296         wst = WORK_MORE_B;
3297     }
3298
3299     /* We need to get a client cert */
3300     if (wst == WORK_MORE_B) {
3301         /*
3302          * If we get an error, we need to ssl->rwstate=SSL_X509_LOOKUP;
3303          * return(-1); We then get retied later
3304          */
3305         i = ssl_do_client_cert_cb(s, &x509, &pkey);
3306         if (i < 0) {
3307             s->rwstate = SSL_X509_LOOKUP;
3308             return WORK_MORE_B;
3309         }
3310         s->rwstate = SSL_NOTHING;
3311         if ((i == 1) && (pkey != NULL) && (x509 != NULL)) {
3312             if (!SSL_use_certificate(s, x509) || !SSL_use_PrivateKey(s, pkey))
3313                 i = 0;
3314         } else if (i == 1) {
3315             i = 0;
3316             SSLerr(SSL_F_TLS_PREPARE_CLIENT_CERTIFICATE,
3317                    SSL_R_BAD_DATA_RETURNED_BY_CALLBACK);
3318         }
3319
3320         X509_free(x509);
3321         EVP_PKEY_free(pkey);
3322         if (i && !ssl3_check_client_certificate(s))
3323             i = 0;
3324         if (i == 0) {
3325             if (s->version == SSL3_VERSION) {
3326                 s->s3->tmp.cert_req = 0;
3327                 ssl3_send_alert(s, SSL3_AL_WARNING, SSL_AD_NO_CERTIFICATE);
3328                 return WORK_FINISHED_CONTINUE;
3329             } else {
3330                 s->s3->tmp.cert_req = 2;
3331                 if (!ssl3_digest_cached_records(s, 0)) {
3332                     ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
3333                     statem_set_error(s);
3334                     return 0;
3335                 }
3336             }
3337         }
3338
3339         return WORK_FINISHED_CONTINUE;
3340     }
3341
3342     /* Shouldn't ever get here */
3343     return WORK_ERROR;
3344 }
3345
3346 int tls_construct_client_certificate(SSL *s)
3347 {
3348     if (!ssl3_output_cert_chain(s,
3349                                 (s->s3->tmp.cert_req ==
3350                                  2) ? NULL : s->cert->key)) {
3351         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_CERTIFICATE, ERR_R_INTERNAL_ERROR);
3352         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
3353         statem_set_error(s);
3354         return 0;
3355     }
3356
3357     return 1;
3358 }
3359
3360 #define has_bits(i,m)   (((i)&(m)) == (m))
3361
3362 int ssl3_check_cert_and_algorithm(SSL *s)
3363 {
3364     int i, idx;
3365     long alg_k, alg_a;
3366     EVP_PKEY *pkey = NULL;
3367     int pkey_bits;
3368 #ifndef OPENSSL_NO_RSA
3369     RSA *rsa;
3370 #endif
3371 #ifndef OPENSSL_NO_DH
3372     DH *dh;
3373 #endif
3374     int al = SSL_AD_HANDSHAKE_FAILURE;
3375
3376     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
3377     alg_a = s->s3->tmp.new_cipher->algorithm_auth;
3378
3379     /* we don't have a certificate */
3380     if ((alg_a & SSL_aNULL) || (alg_k & SSL_kPSK))
3381         return (1);
3382 #ifndef OPENSSL_NO_RSA
3383     rsa = s->s3->peer_rsa_tmp;
3384 #endif
3385 #ifndef OPENSSL_NO_DH
3386     dh = s->s3->peer_dh_tmp;
3387 #endif
3388
3389     /* This is the passed certificate */
3390
3391     idx = s->session->peer_type;
3392 #ifndef OPENSSL_NO_EC
3393     if (idx == SSL_PKEY_ECC) {
3394         if (ssl_check_srvr_ecc_cert_and_alg(s->session->peer, s) == 0) {
3395             /* check failed */
3396             SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM, SSL_R_BAD_ECC_CERT);
3397             goto f_err;
3398         } else {
3399             return 1;
3400         }
3401     } else if (alg_a & SSL_aECDSA) {
3402         SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3403                SSL_R_MISSING_ECDSA_SIGNING_CERT);
3404         goto f_err;
3405     } else if (alg_k & (SSL_kECDHr | SSL_kECDHe)) {
3406         SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM, SSL_R_MISSING_ECDH_CERT);
3407         goto f_err;
3408     }
3409 #endif
3410     pkey = X509_get_pubkey(s->session->peer);
3411     pkey_bits = EVP_PKEY_bits(pkey);
3412     i = X509_certificate_type(s->session->peer, pkey);
3413     EVP_PKEY_free(pkey);
3414
3415     /* Check that we have a certificate if we require one */
3416     if ((alg_a & SSL_aRSA) && !has_bits(i, EVP_PK_RSA | EVP_PKT_SIGN)) {
3417         SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3418                SSL_R_MISSING_RSA_SIGNING_CERT);
3419         goto f_err;
3420     }
3421 #ifndef OPENSSL_NO_DSA
3422     else if ((alg_a & SSL_aDSS) && !has_bits(i, EVP_PK_DSA | EVP_PKT_SIGN)) {
3423         SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3424                SSL_R_MISSING_DSA_SIGNING_CERT);
3425         goto f_err;
3426     }
3427 #endif
3428 #ifndef OPENSSL_NO_RSA
3429     if (alg_k & (SSL_kRSA | SSL_kRSAPSK)) {
3430         if (!SSL_C_IS_EXPORT(s->s3->tmp.new_cipher) &&
3431             !has_bits(i, EVP_PK_RSA | EVP_PKT_ENC)) {
3432             SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3433                    SSL_R_MISSING_RSA_ENCRYPTING_CERT);
3434             goto f_err;
3435         } else if (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher)) {
3436             if (pkey_bits <= SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher)) {
3437                 if (!has_bits(i, EVP_PK_RSA | EVP_PKT_ENC)) {
3438                     SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3439                            SSL_R_MISSING_RSA_ENCRYPTING_CERT);
3440                     goto f_err;
3441                 }
3442                 if (rsa != NULL) {
3443                     /* server key exchange is not allowed. */
3444                     al = SSL_AD_INTERNAL_ERROR;
3445                     SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM, ERR_R_INTERNAL_ERROR);
3446                     goto f_err;
3447                 }
3448             }
3449         }
3450     }
3451 #endif
3452 #ifndef OPENSSL_NO_DH
3453     if ((alg_k & SSL_kDHE) && (dh == NULL)) {
3454         al = SSL_AD_INTERNAL_ERROR;
3455         SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM, ERR_R_INTERNAL_ERROR);
3456         goto f_err;
3457     } else if ((alg_k & SSL_kDHr) && !SSL_USE_SIGALGS(s) &&
3458                !has_bits(i, EVP_PK_DH | EVP_PKS_RSA)) {
3459         SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3460                SSL_R_MISSING_DH_RSA_CERT);
3461         goto f_err;
3462     }
3463 # ifndef OPENSSL_NO_DSA
3464     else if ((alg_k & SSL_kDHd) && !SSL_USE_SIGALGS(s) &&
3465              !has_bits(i, EVP_PK_DH | EVP_PKS_DSA)) {
3466         SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3467                SSL_R_MISSING_DH_DSA_CERT);
3468         goto f_err;
3469     }
3470 # endif
3471 #endif
3472
3473     if (SSL_C_IS_EXPORT(s->s3->tmp.new_cipher) &&
3474         pkey_bits > SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher)) {
3475 #ifndef OPENSSL_NO_RSA
3476         if (alg_k & SSL_kRSA) {
3477             if (rsa == NULL) {
3478                 SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3479                        SSL_R_MISSING_EXPORT_TMP_RSA_KEY);
3480                 goto f_err;
3481             } else if (RSA_bits(rsa) >
3482                 SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher)) {
3483                 /* We have a temporary RSA key but it's too large. */
3484                 al = SSL_AD_EXPORT_RESTRICTION;
3485                 SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3486                        SSL_R_MISSING_EXPORT_TMP_RSA_KEY);
3487                 goto f_err;
3488             }
3489         } else
3490 #endif
3491 #ifndef OPENSSL_NO_DH
3492         if (alg_k & SSL_kDHE) {
3493             if (DH_bits(dh) >
3494                 SSL_C_EXPORT_PKEYLENGTH(s->s3->tmp.new_cipher)) {
3495                 /* We have a temporary DH key but it's too large. */
3496                 al = SSL_AD_EXPORT_RESTRICTION;
3497                 SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3498                        SSL_R_MISSING_EXPORT_TMP_DH_KEY);
3499                 goto f_err;
3500             }
3501         } else if (alg_k & (SSL_kDHr | SSL_kDHd)) {
3502             /* The cert should have had an export DH key. */
3503             al = SSL_AD_EXPORT_RESTRICTION;
3504             SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3505                    SSL_R_MISSING_EXPORT_TMP_DH_KEY);
3506                 goto f_err;
3507         } else
3508 #endif
3509         {
3510             SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3511                    SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE);
3512             goto f_err;
3513         }
3514     }
3515     return (1);
3516  f_err:
3517     ssl3_send_alert(s, SSL3_AL_FATAL, al);
3518     return (0);
3519 }
3520
3521 /*
3522  * Normally, we can tell if the server is resuming the session from
3523  * the session ID. EAP-FAST (RFC 4851), however, relies on the next server
3524  * message after the ServerHello to determine if the server is resuming.
3525  * Therefore, we allow EAP-FAST to peek ahead.
3526  * ssl3_check_change returns 1 if we are resuming from an external
3527  * pre-shared secret, we have a "ticket" and the next server message
3528  * is CCS; and 0 otherwise. It returns -1 upon an error.
3529  */
3530  #if 0
3531  /*
3532   * TODO: No longer required. Temporarily kept during state machine development
3533   * To be deleted by later commits
3534   */
3535 static int ssl3_check_change(SSL *s)
3536 {
3537     int ok = 0;
3538
3539     if (s->version < TLS1_VERSION || !s->tls_session_secret_cb ||
3540         !s->session->tlsext_tick)
3541         return 0;
3542
3543     /*
3544      * This function is called when we might get a Certificate message instead,
3545      * so permit appropriate message length.
3546      * We ignore the return value as we're only interested in the message type
3547      * and not its length.
3548      */
3549     s->method->ssl_get_message(s,
3550                                SSL3_ST_CR_CERT_A,
3551                                SSL3_ST_CR_CERT_B,
3552                                -1, s->max_cert_list, &ok);
3553
3554     if (!ok)
3555         return -1;
3556
3557     s->s3->tmp.reuse_message = 1;
3558
3559     if (s->s3->tmp.message_type == SSL3_MT_CHANGE_CIPHER_SPEC)
3560         return 1;
3561
3562     return 0;
3563 }
3564 #endif
3565
3566 #ifndef OPENSSL_NO_NEXTPROTONEG
3567 int ssl3_send_next_proto(SSL *s)
3568 {
3569     if (s->state == SSL3_ST_CW_NEXT_PROTO_A) {
3570         if (tls_construct_next_proto(s) == 0) {
3571             s->state = SSL_ST_ERR;
3572             return -1;
3573         }
3574         s->state = SSL3_ST_CW_NEXT_PROTO_B;
3575     }
3576
3577     return ssl3_do_write(s, SSL3_RT_HANDSHAKE);
3578 }
3579
3580 int tls_construct_next_proto(SSL *s)
3581 {
3582     unsigned int len, padding_len;
3583     unsigned char *d;
3584
3585     len = s->next_proto_negotiated_len;
3586     padding_len = 32 - ((len + 2) % 32);
3587     d = (unsigned char *)s->init_buf->data;
3588     d[4] = len;
3589     memcpy(d + 5, s->next_proto_negotiated, len);
3590     d[5 + len] = padding_len;
3591     memset(d + 6 + len, 0, padding_len);
3592     *(d++) = SSL3_MT_NEXT_PROTO;
3593     l2n3(2 + len + padding_len, d);
3594     s->init_num = 4 + 2 + len + padding_len;
3595     s->init_off = 0;
3596
3597     return 1;
3598 }
3599 #endif
3600
3601 int ssl_do_client_cert_cb(SSL *s, X509 **px509, EVP_PKEY **ppkey)
3602 {
3603     int i = 0;
3604 #ifndef OPENSSL_NO_ENGINE
3605     if (s->ctx->client_cert_engine) {
3606         i = ENGINE_load_ssl_client_cert(s->ctx->client_cert_engine, s,
3607                                         SSL_get_client_CA_list(s),
3608                                         px509, ppkey, NULL, NULL, NULL);
3609         if (i != 0)
3610             return i;
3611     }
3612 #endif
3613     if (s->ctx->client_cert_cb)
3614         i = s->ctx->client_cert_cb(s, px509, ppkey);
3615     return i;
3616 }
3617
3618 int ssl_cipher_list_to_bytes(SSL *s, STACK_OF(SSL_CIPHER) *sk,
3619                              unsigned char *p)
3620 {
3621     int i, j = 0;
3622     SSL_CIPHER *c;
3623     unsigned char *q;
3624     int empty_reneg_info_scsv = !s->renegotiate;
3625     /* Set disabled masks for this session */
3626     ssl_set_client_disabled(s);
3627
3628     if (sk == NULL)
3629         return (0);
3630     q = p;
3631
3632     for (i = 0; i < sk_SSL_CIPHER_num(sk); i++) {
3633         c = sk_SSL_CIPHER_value(sk, i);
3634         /* Skip disabled ciphers */
3635         if (ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_SUPPORTED))
3636             continue;
3637 #ifdef OPENSSL_SSL_DEBUG_BROKEN_PROTOCOL
3638         if (c->id == SSL3_CK_SCSV) {
3639             if (!empty_reneg_info_scsv)
3640                 continue;
3641             else
3642                 empty_reneg_info_scsv = 0;
3643         }
3644 #endif
3645         j = s->method->put_cipher_by_char(c, p);
3646         p += j;
3647     }
3648     /*
3649      * If p == q, no ciphers; caller indicates an error. Otherwise, add
3650      * applicable SCSVs.
3651      */
3652     if (p != q) {
3653         if (empty_reneg_info_scsv) {
3654             static SSL_CIPHER scsv = {
3655                 0, NULL, SSL3_CK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0
3656             };
3657             j = s->method->put_cipher_by_char(&scsv, p);
3658             p += j;
3659 #ifdef OPENSSL_RI_DEBUG
3660             fprintf(stderr,
3661                     "TLS_EMPTY_RENEGOTIATION_INFO_SCSV sent by client\n");
3662 #endif
3663         }
3664         if (s->mode & SSL_MODE_SEND_FALLBACK_SCSV) {
3665             static SSL_CIPHER scsv = {
3666                 0, NULL, SSL3_CK_FALLBACK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0
3667             };
3668             j = s->method->put_cipher_by_char(&scsv, p);
3669             p += j;
3670         }
3671     }
3672
3673     return (p - q);
3674 }