ssl/statem/statem_srvr.c

   1 /*
   2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 /* ====================================================================
  11  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
  12  *
  13  * Portions of the attached software ("Contribution") are developed by
  14  * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
  15  *
  16  * The Contribution is licensed pursuant to the OpenSSL open source
  17  * license provided above.
  18  *
  19  * ECC cipher suite support in OpenSSL originally written by
  20  * Vipul Gupta and Sumit Gupta of Sun Microsystems Laboratories.
  21  *
  22  */
  23 /* ====================================================================
  24  * Copyright 2005 Nokia. All rights reserved.
  25  *
  26  * The portions of the attached software ("Contribution") is developed by
  27  * Nokia Corporation and is licensed pursuant to the OpenSSL open source
  28  * license.
  29  *
  30  * The Contribution, originally written by Mika Kousa and Pasi Eronen of
  31  * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
  32  * support (see RFC 4279) to OpenSSL.
  33  *
  34  * No patent licenses or other rights except those expressly stated in
  35  * the OpenSSL open source license shall be deemed granted or received
  36  * expressly, by implication, estoppel, or otherwise.
  37  *
  38  * No assurances are provided by Nokia that the Contribution does not
  39  * infringe the patent or other intellectual property rights of any third
  40  * party or that the license provides you with all the necessary rights
  41  * to make use of the Contribution.
  42  *
  43  * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
  44  * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
  45  * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
  46  * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
  47  * OTHERWISE.
  48  */
  49
  50 #include <stdio.h>
  51 #include "../ssl_locl.h"
  52 #include "statem_locl.h"
  53 #include "internal/constant_time_locl.h"
  54 #include <openssl/buffer.h>
  55 #include <openssl/rand.h>
  56 #include <openssl/objects.h>
  57 #include <openssl/evp.h>
  58 #include <openssl/hmac.h>
  59 #include <openssl/x509.h>
  60 #include <openssl/dh.h>
  61 #include <openssl/bn.h>
  62 #include <openssl/md5.h>
  63
  64 static STACK_OF(SSL_CIPHER) *ssl_bytes_to_cipher_list(SSL *s,
  65                                                       PACKET *cipher_suites,
  66                                                       STACK_OF(SSL_CIPHER)
  67                                                       **skp, int sslv2format,
  68                                                       int *al);
  69
  70 /*
  71  * server_read_transition() encapsulates the logic for the allowed handshake
  72  * state transitions when the server is reading messages from the client. The
  73  * message type that the client has sent is provided in |mt|. The current state
  74  * is in |s->statem.hand_state|.
  75  *
  76  *  Valid return values are:
  77  *  1: Success (transition allowed)
  78  *  0: Error (transition not allowed)
  79  */
  80 int ossl_statem_server_read_transition(SSL *s, int mt)
  81 {
  82     OSSL_STATEM *st = &s->statem;
  83
  84     switch (st->hand_state) {
  85     default:
  86         break;
  87
  88     case TLS_ST_BEFORE:
  89     case DTLS_ST_SW_HELLO_VERIFY_REQUEST:
  90         if (mt == SSL3_MT_CLIENT_HELLO) {
  91             st->hand_state = TLS_ST_SR_CLNT_HELLO;
  92             return 1;
  93         }
  94         break;
  95
  96     case TLS_ST_SW_SRVR_DONE:
  97         /*
  98          * If we get a CKE message after a ServerDone then either
  99          * 1) We didn't request a Certificate
 100          * OR
 101          * 2) If we did request one then
 102          *      a) We allow no Certificate to be returned
 103          *      AND
 104          *      b) We are running SSL3 (in TLS1.0+ the client must return a 0
 105          *         list if we requested a certificate)
 106          */
 107         if (mt == SSL3_MT_CLIENT_KEY_EXCHANGE) {
 108             if (s->s3->tmp.cert_request) {
 109                 if (s->version == SSL3_VERSION) {
 110                     if ((s->verify_mode & SSL_VERIFY_PEER)
 111                         && (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) {
 112                         /*
 113                          * This isn't an unexpected message as such - we're just
 114                          * not going to accept it because we require a client
 115                          * cert.
 116                          */
 117                         ssl3_send_alert(s, SSL3_AL_FATAL,
 118                                         SSL3_AD_HANDSHAKE_FAILURE);
 119                         SSLerr(SSL_F_OSSL_STATEM_SERVER_READ_TRANSITION,
 120                                SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
 121                         return 0;
 122                     }
 123                     st->hand_state = TLS_ST_SR_KEY_EXCH;
 124                     return 1;
 125                 }
 126             } else {
 127                 st->hand_state = TLS_ST_SR_KEY_EXCH;
 128                 return 1;
 129             }
 130         } else if (s->s3->tmp.cert_request) {
 131             if (mt == SSL3_MT_CERTIFICATE) {
 132                 st->hand_state = TLS_ST_SR_CERT;
 133                 return 1;
 134             }
 135         }
 136         break;
 137
 138     case TLS_ST_SR_CERT:
 139         if (mt == SSL3_MT_CLIENT_KEY_EXCHANGE) {
 140             st->hand_state = TLS_ST_SR_KEY_EXCH;
 141             return 1;
 142         }
 143         break;
 144
 145     case TLS_ST_SR_KEY_EXCH:
 146         /*
 147          * We should only process a CertificateVerify message if we have
 148          * received a Certificate from the client. If so then |s->session->peer|
 149          * will be non NULL. In some instances a CertificateVerify message is
 150          * not required even if the peer has sent a Certificate (e.g. such as in
 151          * the case of static DH). In that case |st->no_cert_verify| should be
 152          * set.
 153          */
 154         if (s->session->peer == NULL || st->no_cert_verify) {
 155             if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
 156                 /*
 157                  * For the ECDH ciphersuites when the client sends its ECDH
 158                  * pub key in a certificate, the CertificateVerify message is
 159                  * not sent. Also for GOST ciphersuites when the client uses
 160                  * its key from the certificate for key exchange.
 161                  */
 162                 st->hand_state = TLS_ST_SR_CHANGE;
 163                 return 1;
 164             }
 165         } else {
 166             if (mt == SSL3_MT_CERTIFICATE_VERIFY) {
 167                 st->hand_state = TLS_ST_SR_CERT_VRFY;
 168                 return 1;
 169             }
 170         }
 171         break;
 172
 173     case TLS_ST_SR_CERT_VRFY:
 174         if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
 175             st->hand_state = TLS_ST_SR_CHANGE;
 176             return 1;
 177         }
 178         break;
 179
 180     case TLS_ST_SR_CHANGE:
 181 #ifndef OPENSSL_NO_NEXTPROTONEG
 182         if (s->s3->next_proto_neg_seen) {
 183             if (mt == SSL3_MT_NEXT_PROTO) {
 184                 st->hand_state = TLS_ST_SR_NEXT_PROTO;
 185                 return 1;
 186             }
 187         } else {
 188 #endif
 189             if (mt == SSL3_MT_FINISHED) {
 190                 st->hand_state = TLS_ST_SR_FINISHED;
 191                 return 1;
 192             }
 193 #ifndef OPENSSL_NO_NEXTPROTONEG
 194         }
 195 #endif
 196         break;
 197
 198 #ifndef OPENSSL_NO_NEXTPROTONEG
 199     case TLS_ST_SR_NEXT_PROTO:
 200         if (mt == SSL3_MT_FINISHED) {
 201             st->hand_state = TLS_ST_SR_FINISHED;
 202             return 1;
 203         }
 204         break;
 205 #endif
 206
 207     case TLS_ST_SW_FINISHED:
 208         if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
 209             st->hand_state = TLS_ST_SR_CHANGE;
 210             return 1;
 211         }
 212         break;
 213     }
 214
 215     /* No valid transition found */
 216     ssl3_send_alert(s, SSL3_AL_FATAL, SSL3_AD_UNEXPECTED_MESSAGE);
 217     SSLerr(SSL_F_OSSL_STATEM_SERVER_READ_TRANSITION, SSL_R_UNEXPECTED_MESSAGE);
 218     return 0;
 219 }
 220
 221 /*
 222  * Should we send a ServerKeyExchange message?
 223  *
 224  * Valid return values are:
 225  *   1: Yes
 226  *   0: No
 227  */
 228 static int send_server_key_exchange(SSL *s)
 229 {
 230     unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
 231
 232     /*
 233      * only send a ServerKeyExchange if DH or fortezza but we have a
 234      * sign only certificate PSK: may send PSK identity hints For
 235      * ECC ciphersuites, we send a serverKeyExchange message only if
 236      * the cipher suite is either ECDH-anon or ECDHE. In other cases,
 237      * the server certificate contains the server's public key for
 238      * key exchange.
 239      */
 240     if (alg_k & (SSL_kDHE | SSL_kECDHE)
 241         /*
 242          * PSK: send ServerKeyExchange if PSK identity hint if
 243          * provided
 244          */
 245 #ifndef OPENSSL_NO_PSK
 246         /* Only send SKE if we have identity hint for plain PSK */
 247         || ((alg_k & (SSL_kPSK | SSL_kRSAPSK))
 248             && s->cert->psk_identity_hint)
 249         /* For other PSK always send SKE */
 250         || (alg_k & (SSL_PSK & (SSL_kDHEPSK | SSL_kECDHEPSK)))
 251 #endif
 252 #ifndef OPENSSL_NO_SRP
 253         /* SRP: send ServerKeyExchange */
 254         || (alg_k & SSL_kSRP)
 255 #endif
 256         ) {
 257         return 1;
 258     }
 259
 260     return 0;
 261 }
 262
 263 /*
 264  * Should we send a CertificateRequest message?
 265  *
 266  * Valid return values are:
 267  *   1: Yes
 268  *   0: No
 269  */
 270 static int send_certificate_request(SSL *s)
 271 {
 272     if (
 273            /* don't request cert unless asked for it: */
 274            s->verify_mode & SSL_VERIFY_PEER
 275            /*
 276             * if SSL_VERIFY_CLIENT_ONCE is set, don't request cert
 277             * during re-negotiation:
 278             */
 279            && ((s->session->peer == NULL) ||
 280                !(s->verify_mode & SSL_VERIFY_CLIENT_ONCE))
 281            /*
 282             * never request cert in anonymous ciphersuites (see
 283             * section "Certificate request" in SSL 3 drafts and in
 284             * RFC 2246):
 285             */
 286            && (!(s->s3->tmp.new_cipher->algorithm_auth & SSL_aNULL)
 287                /*
 288                 * ... except when the application insists on
 289                 * verification (against the specs, but statem_clnt.c accepts
 290                 * this for SSL 3)
 291                 */
 292                || (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT))
 293            /* don't request certificate for SRP auth */
 294            && !(s->s3->tmp.new_cipher->algorithm_auth & SSL_aSRP)
 295            /*
 296             * With normal PSK Certificates and Certificate Requests
 297             * are omitted
 298             */
 299            && !(s->s3->tmp.new_cipher->algorithm_auth & SSL_aPSK)) {
 300         return 1;
 301     }
 302
 303     return 0;
 304 }
 305
 306 /*
 307  * server_write_transition() works out what handshake state to move to next
 308  * when the server is writing messages to be sent to the client.
 309  */
 310 WRITE_TRAN ossl_statem_server_write_transition(SSL *s)
 311 {
 312     OSSL_STATEM *st = &s->statem;
 313
 314     switch (st->hand_state) {
 315     default:
 316         /* Shouldn't happen */
 317         return WRITE_TRAN_ERROR;
 318
 319     case TLS_ST_BEFORE:
 320         /* Just go straight to trying to read from the client */
 321         return WRITE_TRAN_FINISHED;
 322
 323     case TLS_ST_OK:
 324         /* We must be trying to renegotiate */
 325         st->hand_state = TLS_ST_SW_HELLO_REQ;
 326         return WRITE_TRAN_CONTINUE;
 327
 328     case TLS_ST_SW_HELLO_REQ:
 329         st->hand_state = TLS_ST_OK;
 330         ossl_statem_set_in_init(s, 0);
 331         return WRITE_TRAN_CONTINUE;
 332
 333     case TLS_ST_SR_CLNT_HELLO:
 334         if (SSL_IS_DTLS(s) && !s->d1->cookie_verified
 335             && (SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE))
 336             st->hand_state = DTLS_ST_SW_HELLO_VERIFY_REQUEST;
 337         else
 338             st->hand_state = TLS_ST_SW_SRVR_HELLO;
 339         return WRITE_TRAN_CONTINUE;
 340
 341     case DTLS_ST_SW_HELLO_VERIFY_REQUEST:
 342         return WRITE_TRAN_FINISHED;
 343
 344     case TLS_ST_SW_SRVR_HELLO:
 345         if (s->hit) {
 346             if (s->tlsext_ticket_expected)
 347                 st->hand_state = TLS_ST_SW_SESSION_TICKET;
 348             else
 349                 st->hand_state = TLS_ST_SW_CHANGE;
 350         } else {
 351             /* Check if it is anon DH or anon ECDH, */
 352             /* normal PSK or SRP */
 353             if (!(s->s3->tmp.new_cipher->algorithm_auth &
 354                   (SSL_aNULL | SSL_aSRP | SSL_aPSK))) {
 355                 st->hand_state = TLS_ST_SW_CERT;
 356             } else if (send_server_key_exchange(s)) {
 357                 st->hand_state = TLS_ST_SW_KEY_EXCH;
 358             } else if (send_certificate_request(s)) {
 359                 st->hand_state = TLS_ST_SW_CERT_REQ;
 360             } else {
 361                 st->hand_state = TLS_ST_SW_SRVR_DONE;
 362             }
 363         }
 364         return WRITE_TRAN_CONTINUE;
 365
 366     case TLS_ST_SW_CERT:
 367         if (s->tlsext_status_expected) {
 368             st->hand_state = TLS_ST_SW_CERT_STATUS;
 369             return WRITE_TRAN_CONTINUE;
 370         }
 371         /* Fall through */
 372
 373     case TLS_ST_SW_CERT_STATUS:
 374         if (send_server_key_exchange(s)) {
 375             st->hand_state = TLS_ST_SW_KEY_EXCH;
 376             return WRITE_TRAN_CONTINUE;
 377         }
 378         /* Fall through */
 379
 380     case TLS_ST_SW_KEY_EXCH:
 381         if (send_certificate_request(s)) {
 382             st->hand_state = TLS_ST_SW_CERT_REQ;
 383             return WRITE_TRAN_CONTINUE;
 384         }
 385         /* Fall through */
 386
 387     case TLS_ST_SW_CERT_REQ:
 388         st->hand_state = TLS_ST_SW_SRVR_DONE;
 389         return WRITE_TRAN_CONTINUE;
 390
 391     case TLS_ST_SW_SRVR_DONE:
 392         return WRITE_TRAN_FINISHED;
 393
 394     case TLS_ST_SR_FINISHED:
 395         if (s->hit) {
 396             st->hand_state = TLS_ST_OK;
 397             ossl_statem_set_in_init(s, 0);
 398             return WRITE_TRAN_CONTINUE;
 399         } else if (s->tlsext_ticket_expected) {
 400             st->hand_state = TLS_ST_SW_SESSION_TICKET;
 401         } else {
 402             st->hand_state = TLS_ST_SW_CHANGE;
 403         }
 404         return WRITE_TRAN_CONTINUE;
 405
 406     case TLS_ST_SW_SESSION_TICKET:
 407         st->hand_state = TLS_ST_SW_CHANGE;
 408         return WRITE_TRAN_CONTINUE;
 409
 410     case TLS_ST_SW_CHANGE:
 411         st->hand_state = TLS_ST_SW_FINISHED;
 412         return WRITE_TRAN_CONTINUE;
 413
 414     case TLS_ST_SW_FINISHED:
 415         if (s->hit) {
 416             return WRITE_TRAN_FINISHED;
 417         }
 418         st->hand_state = TLS_ST_OK;
 419         ossl_statem_set_in_init(s, 0);
 420         return WRITE_TRAN_CONTINUE;
 421     }
 422 }
 423
 424 /*
 425  * Perform any pre work that needs to be done prior to sending a message from
 426  * the server to the client.
 427  */
 428 WORK_STATE ossl_statem_server_pre_work(SSL *s, WORK_STATE wst)
 429 {
 430     OSSL_STATEM *st = &s->statem;
 431
 432     switch (st->hand_state) {
 433     default:
 434         /* No pre work to be done */
 435         break;
 436
 437     case TLS_ST_SW_HELLO_REQ:
 438         s->shutdown = 0;
 439         if (SSL_IS_DTLS(s))
 440             dtls1_clear_sent_buffer(s);
 441         break;
 442
 443     case DTLS_ST_SW_HELLO_VERIFY_REQUEST:
 444         s->shutdown = 0;
 445         if (SSL_IS_DTLS(s)) {
 446             dtls1_clear_sent_buffer(s);
 447             /* We don't buffer this message so don't use the timer */
 448             st->use_timer = 0;
 449         }
 450         break;
 451
 452     case TLS_ST_SW_SRVR_HELLO:
 453         if (SSL_IS_DTLS(s)) {
 454             /*
 455              * Messages we write from now on should be bufferred and
 456              * retransmitted if necessary, so we need to use the timer now
 457              */
 458             st->use_timer = 1;
 459         }
 460         break;
 461
 462     case TLS_ST_SW_SRVR_DONE:
 463 #ifndef OPENSSL_NO_SCTP
 464         if (SSL_IS_DTLS(s) && BIO_dgram_is_sctp(SSL_get_wbio(s)))
 465             return dtls_wait_for_dry(s);
 466 #endif
 467         return WORK_FINISHED_CONTINUE;
 468
 469     case TLS_ST_SW_SESSION_TICKET:
 470         if (SSL_IS_DTLS(s)) {
 471             /*
 472              * We're into the last flight. We don't retransmit the last flight
 473              * unless we need to, so we don't use the timer
 474              */
 475             st->use_timer = 0;
 476         }
 477         break;
 478
 479     case TLS_ST_SW_CHANGE:
 480         s->session->cipher = s->s3->tmp.new_cipher;
 481         if (!s->method->ssl3_enc->setup_key_block(s)) {
 482             ossl_statem_set_error(s);
 483             return WORK_ERROR;
 484         }
 485         if (SSL_IS_DTLS(s)) {
 486             /*
 487              * We're into the last flight. We don't retransmit the last flight
 488              * unless we need to, so we don't use the timer. This might have
 489              * already been set to 0 if we sent a NewSessionTicket message,
 490              * but we'll set it again here in case we didn't.
 491              */
 492             st->use_timer = 0;
 493         }
 494         return WORK_FINISHED_CONTINUE;
 495
 496     case TLS_ST_OK:
 497         return tls_finish_handshake(s, wst);
 498     }
 499
 500     return WORK_FINISHED_CONTINUE;
 501 }
 502
 503 /*
 504  * Perform any work that needs to be done after sending a message from the
 505  * server to the client.
 506  */
 507 WORK_STATE ossl_statem_server_post_work(SSL *s, WORK_STATE wst)
 508 {
 509     OSSL_STATEM *st = &s->statem;
 510
 511     s->init_num = 0;
 512
 513     switch (st->hand_state) {
 514     default:
 515         /* No post work to be done */
 516         break;
 517
 518     case TLS_ST_SW_HELLO_REQ:
 519         if (statem_flush(s) != 1)
 520             return WORK_MORE_A;
 521         if (!ssl3_init_finished_mac(s)) {
 522             ossl_statem_set_error(s);
 523             return WORK_ERROR;
 524         }
 525         break;
 526
 527     case DTLS_ST_SW_HELLO_VERIFY_REQUEST:
 528         if (statem_flush(s) != 1)
 529             return WORK_MORE_A;
 530         /* HelloVerifyRequest resets Finished MAC */
 531         if (s->version != DTLS1_BAD_VER && !ssl3_init_finished_mac(s)) {
 532             ossl_statem_set_error(s);
 533             return WORK_ERROR;
 534         }
 535         /*
 536          * The next message should be another ClientHello which we need to
 537          * treat like it was the first packet
 538          */
 539         s->first_packet = 1;
 540         break;
 541
 542     case TLS_ST_SW_SRVR_HELLO:
 543 #ifndef OPENSSL_NO_SCTP
 544         if (SSL_IS_DTLS(s) && s->hit) {
 545             unsigned char sctpauthkey[64];
 546             char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)];
 547
 548             /*
 549              * Add new shared key for SCTP-Auth, will be ignored if no
 550              * SCTP used.
 551              */
 552             memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL,
 553                    sizeof(DTLS1_SCTP_AUTH_LABEL));
 554
 555             if (SSL_export_keying_material(s, sctpauthkey,
 556                                            sizeof(sctpauthkey), labelbuffer,
 557                                            sizeof(labelbuffer), NULL, 0,
 558                                            0) <= 0) {
 559                 ossl_statem_set_error(s);
 560                 return WORK_ERROR;
 561             }
 562
 563             BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
 564                      sizeof(sctpauthkey), sctpauthkey);
 565         }
 566 #endif
 567         break;
 568
 569     case TLS_ST_SW_CHANGE:
 570 #ifndef OPENSSL_NO_SCTP
 571         if (SSL_IS_DTLS(s) && !s->hit) {
 572             /*
 573              * Change to new shared key of SCTP-Auth, will be ignored if
 574              * no SCTP used.
 575              */
 576             BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY,
 577                      0, NULL);
 578         }
 579 #endif
 580         if (!s->method->ssl3_enc->change_cipher_state(s,
 581                                                       SSL3_CHANGE_CIPHER_SERVER_WRITE))
 582         {
 583             ossl_statem_set_error(s);
 584             return WORK_ERROR;
 585         }
 586
 587         if (SSL_IS_DTLS(s))
 588             dtls1_reset_seq_numbers(s, SSL3_CC_WRITE);
 589         break;
 590
 591     case TLS_ST_SW_SRVR_DONE:
 592         if (statem_flush(s) != 1)
 593             return WORK_MORE_A;
 594         break;
 595
 596     case TLS_ST_SW_FINISHED:
 597         if (statem_flush(s) != 1)
 598             return WORK_MORE_A;
 599 #ifndef OPENSSL_NO_SCTP
 600         if (SSL_IS_DTLS(s) && s->hit) {
 601             /*
 602              * Change to new shared key of SCTP-Auth, will be ignored if
 603              * no SCTP used.
 604              */
 605             BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY,
 606                      0, NULL);
 607         }
 608 #endif
 609         break;
 610     }
 611
 612     return WORK_FINISHED_CONTINUE;
 613 }
 614
 615 /*
 616  * Get the message construction function and message type for sending from the
 617  * server
 618  *
 619  * Valid return values are:
 620  *   1: Success
 621  *   0: Error
 622  */
 623 int ossl_statem_server_construct_message(SSL *s, WPACKET *pkt,
 624                                          confunc_f *confunc, int *mt)
 625 {
 626     OSSL_STATEM *st = &s->statem;
 627
 628     switch (st->hand_state) {
 629     default:
 630         /* Shouldn't happen */
 631         return 0;
 632
 633     case TLS_ST_SW_CHANGE:
 634         if (SSL_IS_DTLS(s))
 635             *confunc = dtls_construct_change_cipher_spec;
 636         else
 637             *confunc = tls_construct_change_cipher_spec;
 638         *mt = SSL3_MT_CHANGE_CIPHER_SPEC;
 639         break;
 640
 641     case DTLS_ST_SW_HELLO_VERIFY_REQUEST:
 642         *confunc = dtls_construct_hello_verify_request;
 643         *mt = DTLS1_MT_HELLO_VERIFY_REQUEST;
 644         break;
 645
 646     case TLS_ST_SW_HELLO_REQ:
 647         /* No construction function needed */
 648         *confunc = NULL;
 649         *mt = SSL3_MT_HELLO_REQUEST;
 650         break;
 651
 652     case TLS_ST_SW_SRVR_HELLO:
 653         *confunc = tls_construct_server_hello;
 654         *mt = SSL3_MT_SERVER_HELLO;
 655         break;
 656
 657     case TLS_ST_SW_CERT:
 658         *confunc = tls_construct_server_certificate;
 659         *mt = SSL3_MT_CERTIFICATE;
 660         break;
 661
 662     case TLS_ST_SW_KEY_EXCH:
 663         *confunc = tls_construct_server_key_exchange;
 664         *mt = SSL3_MT_SERVER_KEY_EXCHANGE;
 665         break;
 666
 667     case TLS_ST_SW_CERT_REQ:
 668         *confunc = tls_construct_certificate_request;
 669         *mt = SSL3_MT_CERTIFICATE_REQUEST;
 670         break;
 671
 672     case TLS_ST_SW_SRVR_DONE:
 673         *confunc = tls_construct_server_done;
 674         *mt = SSL3_MT_SERVER_DONE;
 675         break;
 676
 677     case TLS_ST_SW_SESSION_TICKET:
 678         *confunc = tls_construct_new_session_ticket;
 679         *mt = SSL3_MT_NEWSESSION_TICKET;
 680         break;
 681
 682     case TLS_ST_SW_CERT_STATUS:
 683         *confunc = tls_construct_cert_status;
 684         *mt = SSL3_MT_CERTIFICATE_STATUS;
 685         break;
 686
 687     case TLS_ST_SW_FINISHED:
 688         *confunc = tls_construct_finished;
 689         *mt = SSL3_MT_FINISHED;
 690         break;
 691     }
 692
 693     return 1;
 694 }
 695
 696 /*
 697  * Maximum size (excluding the Handshake header) of a ClientHello message,
 698  * calculated as follows:
 699  *
 700  *  2 + # client_version
 701  *  32 + # only valid length for random
 702  *  1 + # length of session_id
 703  *  32 + # maximum size for session_id
 704  *  2 + # length of cipher suites
 705  *  2^16-2 + # maximum length of cipher suites array
 706  *  1 + # length of compression_methods
 707  *  2^8-1 + # maximum length of compression methods
 708  *  2 + # length of extensions
 709  *  2^16-1 # maximum length of extensions
 710  */
 711 #define CLIENT_HELLO_MAX_LENGTH         131396
 712
 713 #define CLIENT_KEY_EXCH_MAX_LENGTH      2048
 714 #define NEXT_PROTO_MAX_LENGTH           514
 715
 716 /*
 717  * Returns the maximum allowed length for the current message that we are
 718  * reading. Excludes the message header.
 719  */
 720 size_t ossl_statem_server_max_message_size(SSL *s)
 721 {
 722     OSSL_STATEM *st = &s->statem;
 723
 724     switch (st->hand_state) {
 725     default:
 726         /* Shouldn't happen */
 727         return 0;
 728
 729     case TLS_ST_SR_CLNT_HELLO:
 730         return CLIENT_HELLO_MAX_LENGTH;
 731
 732     case TLS_ST_SR_CERT:
 733         return s->max_cert_list;
 734
 735     case TLS_ST_SR_KEY_EXCH:
 736         return CLIENT_KEY_EXCH_MAX_LENGTH;
 737
 738     case TLS_ST_SR_CERT_VRFY:
 739         return SSL3_RT_MAX_PLAIN_LENGTH;
 740
 741 #ifndef OPENSSL_NO_NEXTPROTONEG
 742     case TLS_ST_SR_NEXT_PROTO:
 743         return NEXT_PROTO_MAX_LENGTH;
 744 #endif
 745
 746     case TLS_ST_SR_CHANGE:
 747         return CCS_MAX_LENGTH;
 748
 749     case TLS_ST_SR_FINISHED:
 750         return FINISHED_MAX_LENGTH;
 751     }
 752 }
 753
 754 /*
 755  * Process a message that the server has received from the client.
 756  */
 757 MSG_PROCESS_RETURN ossl_statem_server_process_message(SSL *s, PACKET *pkt)
 758 {
 759     OSSL_STATEM *st = &s->statem;
 760
 761     switch (st->hand_state) {
 762     default:
 763         /* Shouldn't happen */
 764         return MSG_PROCESS_ERROR;
 765
 766     case TLS_ST_SR_CLNT_HELLO:
 767         return tls_process_client_hello(s, pkt);
 768
 769     case TLS_ST_SR_CERT:
 770         return tls_process_client_certificate(s, pkt);
 771
 772     case TLS_ST_SR_KEY_EXCH:
 773         return tls_process_client_key_exchange(s, pkt);
 774
 775     case TLS_ST_SR_CERT_VRFY:
 776         return tls_process_cert_verify(s, pkt);
 777
 778 #ifndef OPENSSL_NO_NEXTPROTONEG
 779     case TLS_ST_SR_NEXT_PROTO:
 780         return tls_process_next_proto(s, pkt);
 781 #endif
 782
 783     case TLS_ST_SR_CHANGE:
 784         return tls_process_change_cipher_spec(s, pkt);
 785
 786     case TLS_ST_SR_FINISHED:
 787         return tls_process_finished(s, pkt);
 788     }
 789 }
 790
 791 /*
 792  * Perform any further processing required following the receipt of a message
 793  * from the client
 794  */
 795 WORK_STATE ossl_statem_server_post_process_message(SSL *s, WORK_STATE wst)
 796 {
 797     OSSL_STATEM *st = &s->statem;
 798
 799     switch (st->hand_state) {
 800     default:
 801         /* Shouldn't happen */
 802         return WORK_ERROR;
 803
 804     case TLS_ST_SR_CLNT_HELLO:
 805         return tls_post_process_client_hello(s, wst);
 806
 807     case TLS_ST_SR_KEY_EXCH:
 808         return tls_post_process_client_key_exchange(s, wst);
 809
 810     case TLS_ST_SR_CERT_VRFY:
 811 #ifndef OPENSSL_NO_SCTP
 812         if (                    /* Is this SCTP? */
 813                BIO_dgram_is_sctp(SSL_get_wbio(s))
 814                /* Are we renegotiating? */
 815                && s->renegotiate && BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s))) {
 816             s->s3->in_read_app_data = 2;
 817             s->rwstate = SSL_READING;
 818             BIO_clear_retry_flags(SSL_get_rbio(s));
 819             BIO_set_retry_read(SSL_get_rbio(s));
 820             ossl_statem_set_sctp_read_sock(s, 1);
 821             return WORK_MORE_A;
 822         } else {
 823             ossl_statem_set_sctp_read_sock(s, 0);
 824         }
 825 #endif
 826         return WORK_FINISHED_CONTINUE;
 827     }
 828
 829 }
 830
 831 #ifndef OPENSSL_NO_SRP
 832 static int ssl_check_srp_ext_ClientHello(SSL *s, int *al)
 833 {
 834     int ret = SSL_ERROR_NONE;
 835
 836     *al = SSL_AD_UNRECOGNIZED_NAME;
 837
 838     if ((s->s3->tmp.new_cipher->algorithm_mkey & SSL_kSRP) &&
 839         (s->srp_ctx.TLS_ext_srp_username_callback != NULL)) {
 840         if (s->srp_ctx.login == NULL) {
 841             /*
 842              * RFC 5054 says SHOULD reject, we do so if There is no srp
 843              * login name
 844              */
 845             ret = SSL3_AL_FATAL;
 846             *al = SSL_AD_UNKNOWN_PSK_IDENTITY;
 847         } else {
 848             ret = SSL_srp_server_param_with_username(s, al);
 849         }
 850     }
 851     return ret;
 852 }
 853 #endif
 854
 855 int dtls_raw_hello_verify_request(WPACKET *pkt, unsigned char *cookie,
 856                                   size_t cookie_len)
 857 {
 858     /* Always use DTLS 1.0 version: see RFC 6347 */
 859     if (!WPACKET_put_bytes_u16(pkt, DTLS1_VERSION)
 860             || !WPACKET_sub_memcpy_u8(pkt, cookie, cookie_len))
 861         return 0;
 862
 863     return 1;
 864 }
 865
 866 int dtls_construct_hello_verify_request(SSL *s, WPACKET *pkt)
 867 {
 868     unsigned int cookie_leni;
 869     if (s->ctx->app_gen_cookie_cb == NULL ||
 870         s->ctx->app_gen_cookie_cb(s, s->d1->cookie,
 871                                   &cookie_leni) == 0 ||
 872         cookie_leni > 255) {
 873         SSLerr(SSL_F_DTLS_CONSTRUCT_HELLO_VERIFY_REQUEST,
 874                SSL_R_COOKIE_GEN_CALLBACK_FAILURE);
 875         return 0;
 876     }
 877     s->d1->cookie_len = cookie_leni;
 878
 879     if (!dtls_raw_hello_verify_request(pkt, s->d1->cookie,
 880                                               s->d1->cookie_len)) {
 881         SSLerr(SSL_F_DTLS_CONSTRUCT_HELLO_VERIFY_REQUEST, ERR_R_INTERNAL_ERROR);
 882         return 0;
 883     }
 884
 885     return 1;
 886 }
 887
 888 MSG_PROCESS_RETURN tls_process_client_hello(SSL *s, PACKET *pkt)
 889 {
 890     int i, al = SSL_AD_INTERNAL_ERROR;
 891     unsigned int j;
 892     size_t loop;
 893     unsigned long id;
 894     const SSL_CIPHER *c;
 895 #ifndef OPENSSL_NO_COMP
 896     SSL_COMP *comp = NULL;
 897 #endif
 898     STACK_OF(SSL_CIPHER) *ciphers = NULL;
 899     int protverr;
 900     /* |cookie| will only be initialized for DTLS. */
 901     PACKET session_id, compression, extensions, cookie;
 902     static const unsigned char null_compression = 0;
 903     CLIENTHELLO_MSG clienthello;
 904
 905     /*
 906      * First, parse the raw ClientHello data into the CLIENTHELLO_MSG structure.
 907      */
 908     memset(&clienthello, 0, sizeof(clienthello));
 909     clienthello.isv2 = RECORD_LAYER_is_sslv2_record(&s->rlayer);
 910     PACKET_null_init(&cookie);
 911
 912     if (clienthello.isv2) {
 913         unsigned int mt;
 914
 915         /*-
 916          * An SSLv3/TLSv1 backwards-compatible CLIENT-HELLO in an SSLv2
 917          * header is sent directly on the wire, not wrapped as a TLS
 918          * record. Our record layer just processes the message length and passes
 919          * the rest right through. Its format is:
 920          * Byte  Content
 921          * 0-1   msg_length - decoded by the record layer
 922          * 2     msg_type - s->init_msg points here
 923          * 3-4   version
 924          * 5-6   cipher_spec_length
 925          * 7-8   session_id_length
 926          * 9-10  challenge_length
 927          * ...   ...
 928          */
 929
 930         if (!PACKET_get_1(pkt, &mt)
 931             || mt != SSL2_MT_CLIENT_HELLO) {
 932             /*
 933              * Should never happen. We should have tested this in the record
 934              * layer in order to have determined that this is a SSLv2 record
 935              * in the first place
 936              */
 937             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
 938             goto err;
 939         }
 940     }
 941
 942     if (!PACKET_get_net_2(pkt, &clienthello.legacy_version)) {
 943         al = SSL_AD_DECODE_ERROR;
 944         SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_LENGTH_TOO_SHORT);
 945         goto err;
 946     }
 947
 948     /* Parse the message and load client random. */
 949     if (clienthello.isv2) {
 950         /*
 951          * Handle an SSLv2 backwards compatible ClientHello
 952          * Note, this is only for SSLv3+ using the backward compatible format.
 953          * Real SSLv2 is not supported, and is rejected below.
 954          */
 955         unsigned int ciphersuite_len, session_id_len, challenge_len;
 956         PACKET challenge;
 957
 958         if (!PACKET_get_net_2(pkt, &ciphersuite_len)
 959             || !PACKET_get_net_2(pkt, &session_id_len)
 960             || !PACKET_get_net_2(pkt, &challenge_len)) {
 961             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO,
 962                    SSL_R_RECORD_LENGTH_MISMATCH);
 963             al = SSL_AD_DECODE_ERROR;
 964             goto f_err;
 965         }
 966         clienthello.session_id_len = session_id_len;
 967
 968         if (session_id_len > SSL_MAX_SSL_SESSION_ID_LENGTH) {
 969             al = SSL_AD_DECODE_ERROR;
 970             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_LENGTH_MISMATCH);
 971             goto f_err;
 972         }
 973
 974         if (!PACKET_get_sub_packet(pkt, &clienthello.ciphersuites,
 975                                    ciphersuite_len)
 976             || !PACKET_copy_bytes(pkt, clienthello.session_id,
 977                                       clienthello.session_id_len)
 978             || !PACKET_get_sub_packet(pkt, &challenge, challenge_len)
 979             /* No extensions. */
 980             || PACKET_remaining(pkt) != 0) {
 981             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO,
 982                    SSL_R_RECORD_LENGTH_MISMATCH);
 983             al = SSL_AD_DECODE_ERROR;
 984             goto f_err;
 985         }
 986
 987         /* Load the client random and compression list. */
 988         challenge_len = challenge_len > sizeof(clienthello.random)
 989                         ? sizeof(clienthello.random) : challenge_len;
 990         memset(clienthello.random, 0, sizeof(clienthello.random));
 991         if (!PACKET_copy_bytes(&challenge,
 992                                clienthello.random + sizeof(clienthello.random) -
 993                                challenge_len, challenge_len)
 994             /* Advertise only null compression. */
 995             || !PACKET_buf_init(&compression, &null_compression, 1)) {
 996             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
 997             al = SSL_AD_INTERNAL_ERROR;
 998             goto f_err;
 999         }
1000
1001         PACKET_null_init(&clienthello.extensions);
1002     } else {
1003         /* Regular ClientHello. */
1004         if (!PACKET_copy_bytes(pkt, clienthello.random, SSL3_RANDOM_SIZE)
1005             || !PACKET_get_length_prefixed_1(pkt, &session_id)
1006             || !PACKET_copy_all(&session_id, clienthello.session_id,
1007                     SSL_MAX_SSL_SESSION_ID_LENGTH,
1008                     &clienthello.session_id_len)) {
1009             al = SSL_AD_DECODE_ERROR;
1010             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_LENGTH_MISMATCH);
1011             goto f_err;
1012         }
1013
1014         if (SSL_IS_DTLS(s)) {
1015             if (!PACKET_get_length_prefixed_1(pkt, &cookie)) {
1016                 al = SSL_AD_DECODE_ERROR;
1017                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_LENGTH_MISMATCH);
1018                 goto f_err;
1019             }
1020             if (!PACKET_copy_all(&cookie, clienthello.dtls_cookie,
1021                                  DTLS1_COOKIE_LENGTH,
1022                                  &clienthello.dtls_cookie_len)) {
1023                 al = SSL_AD_DECODE_ERROR;
1024                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_LENGTH_MISMATCH);
1025                 goto f_err;
1026             }
1027             /*
1028              * If we require cookies and this ClientHello doesn't contain one,
1029              * just return since we do not want to allocate any memory yet.
1030              * So check cookie length...
1031              */
1032             if (SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE) {
1033                 if (clienthello.dtls_cookie_len == 0)
1034                     return 1;
1035             }
1036         }
1037
1038         if (!PACKET_get_length_prefixed_2(pkt, &clienthello.ciphersuites)) {
1039             al = SSL_AD_DECODE_ERROR;
1040             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_LENGTH_MISMATCH);
1041             goto f_err;
1042         }
1043
1044         if (!PACKET_get_length_prefixed_1(pkt, &compression)) {
1045             al = SSL_AD_DECODE_ERROR;
1046             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_LENGTH_MISMATCH);
1047             goto f_err;
1048         }
1049
1050         /* Could be empty. */
1051         if (PACKET_remaining(pkt) == 0) {
1052             PACKET_null_init(&clienthello.extensions);
1053         } else {
1054             if (!PACKET_get_length_prefixed_2(pkt, &clienthello.extensions)) {
1055                 al = SSL_AD_DECODE_ERROR;
1056                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_LENGTH_MISMATCH);
1057                 goto f_err;
1058             }
1059         }
1060     }
1061
1062     if (!PACKET_copy_all(&compression, clienthello.compressions,
1063                          MAX_COMPRESSIONS_SIZE,
1064                          &clienthello.compressions_len)) {
1065         al = SSL_AD_DECODE_ERROR;
1066         SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_LENGTH_MISMATCH);
1067         goto f_err;
1068     }
1069
1070     /* Preserve the raw extensions PACKET for later use */
1071     extensions = clienthello.extensions;
1072     if (!tls_collect_extensions(&extensions, &clienthello.pre_proc_exts,
1073                                   &clienthello.num_extensions, &al)) {
1074         /* SSLerr already been called */
1075         goto f_err;
1076     }
1077
1078     /* Finished parsing the ClientHello, now we can start processing it */
1079
1080     /* Set up the client_random */
1081     memcpy(s->s3->client_random, clienthello.random, SSL3_RANDOM_SIZE);
1082
1083     /* Choose the version */
1084
1085     if (clienthello.isv2) {
1086         if (clienthello.legacy_version == SSL2_VERSION
1087                 || (clienthello.legacy_version & 0xff00)
1088                    != (SSL3_VERSION_MAJOR << 8)) {
1089             /*
1090              * This is real SSLv2 or something complete unknown. We don't
1091              * support it.
1092              */
1093             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_UNKNOWN_PROTOCOL);
1094             goto err;
1095         }
1096         /* SSLv3/TLS */
1097         s->client_version = clienthello.legacy_version;
1098     }
1099     /*
1100      * Do SSL/TLS version negotiation if applicable. For DTLS we just check
1101      * versions are potentially compatible. Version negotiation comes later.
1102      */
1103     if (!SSL_IS_DTLS(s)) {
1104         protverr = ssl_choose_server_version(s, &clienthello);
1105     } else if (s->method->version != DTLS_ANY_VERSION &&
1106                DTLS_VERSION_LT((int)clienthello.legacy_version, s->version)) {
1107         protverr = SSL_R_VERSION_TOO_LOW;
1108     } else {
1109         protverr = 0;
1110     }
1111
1112     if (protverr) {
1113         SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, protverr);
1114         if ((!s->enc_write_ctx && !s->write_hash)) {
1115             /* like ssl3_get_record, send alert using remote version number */
1116             s->version = s->client_version = clienthello.legacy_version;
1117         }
1118         al = SSL_AD_PROTOCOL_VERSION;
1119         goto f_err;
1120     }
1121
1122     if (SSL_IS_DTLS(s)) {
1123         /* Empty cookie was already handled above by returning early. */
1124         if (SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE) {
1125             if (s->ctx->app_verify_cookie_cb != NULL) {
1126                 if (s->ctx->app_verify_cookie_cb(s, clienthello.dtls_cookie,
1127                         clienthello.dtls_cookie_len) == 0) {
1128                     al = SSL_AD_HANDSHAKE_FAILURE;
1129                     SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO,
1130                            SSL_R_COOKIE_MISMATCH);
1131                     goto f_err;
1132                     /* else cookie verification succeeded */
1133                 }
1134                 /* default verification */
1135             } else if (s->d1->cookie_len != clienthello.dtls_cookie_len
1136                     || memcmp(clienthello.dtls_cookie, s->d1->cookie,
1137                               s->d1->cookie_len) != 0) {
1138                 al = SSL_AD_HANDSHAKE_FAILURE;
1139                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_COOKIE_MISMATCH);
1140                 goto f_err;
1141             }
1142             s->d1->cookie_verified = 1;
1143         }
1144         if (s->method->version == DTLS_ANY_VERSION) {
1145             protverr = ssl_choose_server_version(s, &clienthello);
1146             if (protverr != 0) {
1147                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, protverr);
1148                 s->version = s->client_version;
1149                 al = SSL_AD_PROTOCOL_VERSION;
1150                 goto f_err;
1151             }
1152         }
1153     }
1154
1155     s->hit = 0;
1156
1157     /* We need to do this before getting the session */
1158     if (!tls_check_client_ems_support(s, &clienthello)) {
1159         /* Only fails if the extension is malformed */
1160         al = SSL_AD_DECODE_ERROR;
1161         SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_CLIENTHELLO_TLSEXT);
1162         goto f_err;
1163     }
1164
1165     /*
1166      * We don't allow resumption in a backwards compatible ClientHello.
1167      * TODO(openssl-team): in TLS1.1+, session_id MUST be empty.
1168      *
1169      * Versions before 0.9.7 always allow clients to resume sessions in
1170      * renegotiation. 0.9.7 and later allow this by default, but optionally
1171      * ignore resumption requests with flag
1172      * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION (it's a new flag rather
1173      * than a change to default behavior so that applications relying on
1174      * this for security won't even compile against older library versions).
1175      * 1.0.1 and later also have a function SSL_renegotiate_abbreviated() to
1176      * request renegotiation but not a new session (s->new_session remains
1177      * unset): for servers, this essentially just means that the
1178      * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION setting will be
1179      * ignored.
1180      */
1181     if (clienthello.isv2 ||
1182         (s->new_session &&
1183          (s->options & SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION))) {
1184         if (!ssl_get_new_session(s, 1))
1185             goto err;
1186     } else {
1187         i = ssl_get_prev_session(s, &clienthello);
1188         /*
1189          * Only resume if the session's version matches the negotiated
1190          * version.
1191          * RFC 5246 does not provide much useful advice on resumption
1192          * with a different protocol version. It doesn't forbid it but
1193          * the sanity of such behaviour would be questionable.
1194          * In practice, clients do not accept a version mismatch and
1195          * will abort the handshake with an error.
1196          */
1197         if (i == 1 && s->version == s->session->ssl_version) {
1198             /* previous session */
1199             s->hit = 1;
1200         } else if (i == -1) {
1201             goto err;
1202         } else {
1203             /* i == 0 */
1204             if (!ssl_get_new_session(s, 1))
1205                 goto err;
1206         }
1207     }
1208
1209     if (ssl_bytes_to_cipher_list(s, &clienthello.ciphersuites, &ciphers,
1210                                  clienthello.isv2, &al) == NULL) {
1211         goto f_err;
1212     }
1213
1214     /* If it is a hit, check that the cipher is in the list */
1215     if (s->hit) {
1216         j = 0;
1217         id = s->session->cipher->id;
1218
1219 #ifdef CIPHER_DEBUG
1220         fprintf(stderr, "client sent %d ciphers\n", sk_SSL_CIPHER_num(ciphers));
1221 #endif
1222         for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
1223             c = sk_SSL_CIPHER_value(ciphers, i);
1224 #ifdef CIPHER_DEBUG
1225             fprintf(stderr, "client [%2d of %2d]:%s\n",
1226                     i, sk_SSL_CIPHER_num(ciphers), SSL_CIPHER_get_name(c));
1227 #endif
1228             if (c->id == id) {
1229                 j = 1;
1230                 break;
1231             }
1232         }
1233         if (j == 0) {
1234             /*
1235              * we need to have the cipher in the cipher list if we are asked
1236              * to reuse it
1237              */
1238             al = SSL_AD_ILLEGAL_PARAMETER;
1239             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO,
1240                    SSL_R_REQUIRED_CIPHER_MISSING);
1241             goto f_err;
1242         }
1243     }
1244
1245     for (loop = 0; loop < clienthello.compressions_len; loop++) {
1246         if (clienthello.compressions[loop] == 0)
1247             break;
1248     }
1249
1250     if (loop >= clienthello.compressions_len) {
1251         /* no compress */
1252         al = SSL_AD_DECODE_ERROR;
1253         SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_NO_COMPRESSION_SPECIFIED);
1254         goto f_err;
1255     }
1256
1257     /* TLS extensions */
1258     if (!ssl_parse_clienthello_tlsext(s, &clienthello)) {
1259         SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_PARSE_TLSEXT);
1260         goto err;
1261     }
1262
1263     /*
1264      * Check if we want to use external pre-shared secret for this handshake
1265      * for not reused session only. We need to generate server_random before
1266      * calling tls_session_secret_cb in order to allow SessionTicket
1267      * processing to use it in key derivation.
1268      */
1269     {
1270         unsigned char *pos;
1271         pos = s->s3->server_random;
1272         if (ssl_fill_hello_random(s, 1, pos, SSL3_RANDOM_SIZE) <= 0) {
1273             goto f_err;
1274         }
1275     }
1276
1277     if (!s->hit && s->version >= TLS1_VERSION && s->tls_session_secret_cb) {
1278         const SSL_CIPHER *pref_cipher = NULL;
1279         /*
1280          * s->session->master_key_length is a size_t, but this is an int for
1281          * backwards compat reasons
1282          */
1283         int master_key_length;
1284
1285         master_key_length = sizeof(s->session->master_key);
1286         if (s->tls_session_secret_cb(s, s->session->master_key,
1287                                      &master_key_length, ciphers,
1288                                      &pref_cipher,
1289                                      s->tls_session_secret_cb_arg)
1290                 && master_key_length > 0) {
1291             s->session->master_key_length = master_key_length;
1292             s->hit = 1;
1293             s->session->ciphers = ciphers;
1294             s->session->verify_result = X509_V_OK;
1295
1296             ciphers = NULL;
1297
1298             /* check if some cipher was preferred by call back */
1299             pref_cipher =
1300                 pref_cipher ? pref_cipher : ssl3_choose_cipher(s,
1301                                                                s->
1302                                                                session->ciphers,
1303                                                                SSL_get_ciphers
1304                                                                (s));
1305             if (pref_cipher == NULL) {
1306                 al = SSL_AD_HANDSHAKE_FAILURE;
1307                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_NO_SHARED_CIPHER);
1308                 goto f_err;
1309             }
1310
1311             s->session->cipher = pref_cipher;
1312             sk_SSL_CIPHER_free(s->cipher_list);
1313             s->cipher_list = sk_SSL_CIPHER_dup(s->session->ciphers);
1314             sk_SSL_CIPHER_free(s->cipher_list_by_id);
1315             s->cipher_list_by_id = sk_SSL_CIPHER_dup(s->session->ciphers);
1316         }
1317     }
1318
1319     /*
1320      * Worst case, we will use the NULL compression, but if we have other
1321      * options, we will now look for them.  We have complen-1 compression
1322      * algorithms from the client, starting at q.
1323      */
1324     s->s3->tmp.new_compression = NULL;
1325 #ifndef OPENSSL_NO_COMP
1326     /* This only happens if we have a cache hit */
1327     if (s->session->compress_meth != 0) {
1328         int m, comp_id = s->session->compress_meth;
1329         unsigned int k;
1330         /* Perform sanity checks on resumed compression algorithm */
1331         /* Can't disable compression */
1332         if (!ssl_allow_compression(s)) {
1333             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO,
1334                    SSL_R_INCONSISTENT_COMPRESSION);
1335             goto f_err;
1336         }
1337         /* Look for resumed compression method */
1338         for (m = 0; m < sk_SSL_COMP_num(s->ctx->comp_methods); m++) {
1339             comp = sk_SSL_COMP_value(s->ctx->comp_methods, m);
1340             if (comp_id == comp->id) {
1341                 s->s3->tmp.new_compression = comp;
1342                 break;
1343             }
1344         }
1345         if (s->s3->tmp.new_compression == NULL) {
1346             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO,
1347                    SSL_R_INVALID_COMPRESSION_ALGORITHM);
1348             goto f_err;
1349         }
1350         /* Look for resumed method in compression list */
1351         for (k = 0; k < clienthello.compressions_len; k++) {
1352             if (clienthello.compressions[k] == comp_id)
1353                 break;
1354         }
1355         if (k >= clienthello.compressions_len) {
1356             al = SSL_AD_ILLEGAL_PARAMETER;
1357             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO,
1358                    SSL_R_REQUIRED_COMPRESSION_ALGORITHM_MISSING);
1359             goto f_err;
1360         }
1361     } else if (s->hit)
1362         comp = NULL;
1363     else if (ssl_allow_compression(s) && s->ctx->comp_methods) {
1364         /* See if we have a match */
1365         int m, nn, v, done = 0;
1366         unsigned int o;
1367
1368         nn = sk_SSL_COMP_num(s->ctx->comp_methods);
1369         for (m = 0; m < nn; m++) {
1370             comp = sk_SSL_COMP_value(s->ctx->comp_methods, m);
1371             v = comp->id;
1372             for (o = 0; o < clienthello.compressions_len; o++) {
1373                 if (v == clienthello.compressions[o]) {
1374                     done = 1;
1375                     break;
1376                 }
1377             }
1378             if (done)
1379                 break;
1380         }
1381         if (done)
1382             s->s3->tmp.new_compression = comp;
1383         else
1384             comp = NULL;
1385     }
1386 #else
1387     /*
1388      * If compression is disabled we'd better not try to resume a session
1389      * using compression.
1390      */
1391     if (s->session->compress_meth != 0) {
1392         SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_INCONSISTENT_COMPRESSION);
1393         goto f_err;
1394     }
1395 #endif
1396
1397     /*
1398      * Given s->session->ciphers and SSL_get_ciphers, we must pick a cipher
1399      */
1400
1401     if (!s->hit) {
1402 #ifdef OPENSSL_NO_COMP
1403         s->session->compress_meth = 0;
1404 #else
1405         s->session->compress_meth = (comp == NULL) ? 0 : comp->id;
1406 #endif
1407         sk_SSL_CIPHER_free(s->session->ciphers);
1408         s->session->ciphers = ciphers;
1409         if (ciphers == NULL) {
1410             al = SSL_AD_INTERNAL_ERROR;
1411             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1412             goto f_err;
1413         }
1414         ciphers = NULL;
1415         if (!tls1_set_server_sigalgs(s)) {
1416             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_CLIENTHELLO_TLSEXT);
1417             goto err;
1418         }
1419     }
1420
1421     sk_SSL_CIPHER_free(ciphers);
1422     OPENSSL_free(clienthello.pre_proc_exts);
1423     return MSG_PROCESS_CONTINUE_PROCESSING;
1424  f_err:
1425     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1426  err:
1427     ossl_statem_set_error(s);
1428
1429     sk_SSL_CIPHER_free(ciphers);
1430     OPENSSL_free(clienthello.pre_proc_exts);
1431
1432     return MSG_PROCESS_ERROR;
1433 }
1434
1435 WORK_STATE tls_post_process_client_hello(SSL *s, WORK_STATE wst)
1436 {
1437     int al = SSL_AD_HANDSHAKE_FAILURE;
1438     const SSL_CIPHER *cipher;
1439
1440     if (wst == WORK_MORE_A) {
1441         if (!s->hit) {
1442             /* Let cert callback update server certificates if required */
1443             if (s->cert->cert_cb) {
1444                 int rv = s->cert->cert_cb(s, s->cert->cert_cb_arg);
1445                 if (rv == 0) {
1446                     al = SSL_AD_INTERNAL_ERROR;
1447                     SSLerr(SSL_F_TLS_POST_PROCESS_CLIENT_HELLO,
1448                            SSL_R_CERT_CB_ERROR);
1449                     goto f_err;
1450                 }
1451                 if (rv < 0) {
1452                     s->rwstate = SSL_X509_LOOKUP;
1453                     return WORK_MORE_A;
1454                 }
1455                 s->rwstate = SSL_NOTHING;
1456             }
1457             cipher =
1458                 ssl3_choose_cipher(s, s->session->ciphers, SSL_get_ciphers(s));
1459
1460             if (cipher == NULL) {
1461                 SSLerr(SSL_F_TLS_POST_PROCESS_CLIENT_HELLO,
1462                        SSL_R_NO_SHARED_CIPHER);
1463                 goto f_err;
1464             }
1465             s->s3->tmp.new_cipher = cipher;
1466             /* check whether we should disable session resumption */
1467             if (s->not_resumable_session_cb != NULL)
1468                 s->session->not_resumable = s->not_resumable_session_cb(s,
1469                                                                         ((cipher->algorithm_mkey & (SSL_kDHE | SSL_kECDHE)) != 0));
1470             if (s->session->not_resumable)
1471                 /* do not send a session ticket */
1472                 s->tlsext_ticket_expected = 0;
1473         } else {
1474             /* Session-id reuse */
1475             s->s3->tmp.new_cipher = s->session->cipher;
1476         }
1477
1478         if (!(s->verify_mode & SSL_VERIFY_PEER)) {
1479             if (!ssl3_digest_cached_records(s, 0)) {
1480                 al = SSL_AD_INTERNAL_ERROR;
1481                 goto f_err;
1482             }
1483         }
1484
1485         /*-
1486          * we now have the following setup.
1487          * client_random
1488          * cipher_list          - our preferred list of ciphers
1489          * ciphers              - the clients preferred list of ciphers
1490          * compression          - basically ignored right now
1491          * ssl version is set   - sslv3
1492          * s->session           - The ssl session has been setup.
1493          * s->hit               - session reuse flag
1494          * s->s3->tmp.new_cipher- the new cipher to use.
1495          */
1496
1497         /* Handles TLS extensions that we couldn't check earlier */
1498         if (s->version >= SSL3_VERSION) {
1499             if (!ssl_check_clienthello_tlsext_late(s, &al)) {
1500                 SSLerr(SSL_F_TLS_POST_PROCESS_CLIENT_HELLO,
1501                        SSL_R_CLIENTHELLO_TLSEXT);
1502                 goto f_err;
1503             }
1504         }
1505
1506         wst = WORK_MORE_B;
1507     }
1508 #ifndef OPENSSL_NO_SRP
1509     if (wst == WORK_MORE_B) {
1510         int ret;
1511         if ((ret = ssl_check_srp_ext_ClientHello(s, &al)) < 0) {
1512             /*
1513              * callback indicates further work to be done
1514              */
1515             s->rwstate = SSL_X509_LOOKUP;
1516             return WORK_MORE_B;
1517         }
1518         if (ret != SSL_ERROR_NONE) {
1519             /*
1520              * This is not really an error but the only means to for
1521              * a client to detect whether srp is supported.
1522              */
1523             if (al != TLS1_AD_UNKNOWN_PSK_IDENTITY)
1524                 SSLerr(SSL_F_TLS_POST_PROCESS_CLIENT_HELLO,
1525                        SSL_R_CLIENTHELLO_TLSEXT);
1526             goto f_err;
1527         }
1528     }
1529 #endif
1530     s->renegotiate = 2;
1531
1532     return WORK_FINISHED_STOP;
1533  f_err:
1534     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1535     ossl_statem_set_error(s);
1536     return WORK_ERROR;
1537 }
1538
1539 int tls_construct_server_hello(SSL *s, WPACKET *pkt)
1540 {
1541     int compm, al = SSL_AD_INTERNAL_ERROR;
1542     size_t sl, len;
1543
1544     if (!WPACKET_put_bytes_u16(pkt, s->version)
1545                /*
1546                 * Random stuff. Filling of the server_random takes place in
1547                 * tls_process_client_hello()
1548                 */
1549             || !WPACKET_memcpy(pkt, s->s3->server_random, SSL3_RANDOM_SIZE)) {
1550         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_HELLO, ERR_R_INTERNAL_ERROR);
1551         goto err;
1552     }
1553
1554     /*-
1555      * There are several cases for the session ID to send
1556      * back in the server hello:
1557      * - For session reuse from the session cache,
1558      *   we send back the old session ID.
1559      * - If stateless session reuse (using a session ticket)
1560      *   is successful, we send back the client's "session ID"
1561      *   (which doesn't actually identify the session).
1562      * - If it is a new session, we send back the new
1563      *   session ID.
1564      * - However, if we want the new session to be single-use,
1565      *   we send back a 0-length session ID.
1566      * s->hit is non-zero in either case of session reuse,
1567      * so the following won't overwrite an ID that we're supposed
1568      * to send back.
1569      */
1570     if (s->session->not_resumable ||
1571         (!(s->ctx->session_cache_mode & SSL_SESS_CACHE_SERVER)
1572          && !s->hit))
1573         s->session->session_id_length = 0;
1574
1575     sl = s->session->session_id_length;
1576     if (sl > sizeof(s->session->session_id)) {
1577         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_HELLO, ERR_R_INTERNAL_ERROR);
1578         goto err;
1579     }
1580
1581     /* set up the compression method */
1582 #ifdef OPENSSL_NO_COMP
1583     compm = 0;
1584 #else
1585     if (s->s3->tmp.new_compression == NULL)
1586         compm = 0;
1587     else
1588         compm = s->s3->tmp.new_compression->id;
1589 #endif
1590
1591     if (!WPACKET_sub_memcpy_u8(pkt, s->session->session_id, sl)
1592             || !s->method->put_cipher_by_char(s->s3->tmp.new_cipher, pkt, &len)
1593             || !WPACKET_put_bytes_u8(pkt, compm)
1594             || !ssl_prepare_serverhello_tlsext(s)
1595             || !ssl_add_serverhello_tlsext(s, pkt, &al)) {
1596         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_HELLO, ERR_R_INTERNAL_ERROR);
1597         goto err;
1598     }
1599
1600     return 1;
1601  err:
1602     ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
1603     return 0;
1604 }
1605
1606 int tls_construct_server_done(SSL *s, WPACKET *pkt)
1607 {
1608     if (!s->s3->tmp.cert_request) {
1609         if (!ssl3_digest_cached_records(s, 0)) {
1610             ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
1611             return 0;
1612         }
1613     }
1614     return 1;
1615 }
1616
1617 int tls_construct_server_key_exchange(SSL *s, WPACKET *pkt)
1618 {
1619 #ifndef OPENSSL_NO_DH
1620     EVP_PKEY *pkdh = NULL;
1621 #endif
1622 #ifndef OPENSSL_NO_EC
1623     unsigned char *encodedPoint = NULL;
1624     size_t encodedlen = 0;
1625     int curve_id = 0;
1626 #endif
1627     EVP_PKEY *pkey;
1628     const EVP_MD *md = NULL;
1629     int al = SSL_AD_INTERNAL_ERROR, i;
1630     unsigned long type;
1631     const BIGNUM *r[4];
1632     EVP_MD_CTX *md_ctx = EVP_MD_CTX_new();
1633     size_t paramlen, paramoffset;
1634
1635     if (!WPACKET_get_total_written(pkt, &paramoffset)) {
1636         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
1637         goto f_err;
1638     }
1639
1640     if (md_ctx == NULL) {
1641         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
1642         goto f_err;
1643     }
1644
1645     type = s->s3->tmp.new_cipher->algorithm_mkey;
1646
1647     r[0] = r[1] = r[2] = r[3] = NULL;
1648 #ifndef OPENSSL_NO_PSK
1649     /* Plain PSK or RSAPSK nothing to do */
1650     if (type & (SSL_kPSK | SSL_kRSAPSK)) {
1651     } else
1652 #endif                          /* !OPENSSL_NO_PSK */
1653 #ifndef OPENSSL_NO_DH
1654     if (type & (SSL_kDHE | SSL_kDHEPSK)) {
1655         CERT *cert = s->cert;
1656
1657         EVP_PKEY *pkdhp = NULL;
1658         DH *dh;
1659
1660         if (s->cert->dh_tmp_auto) {
1661             DH *dhp = ssl_get_auto_dh(s);
1662             pkdh = EVP_PKEY_new();
1663             if (pkdh == NULL || dhp == NULL) {
1664                 DH_free(dhp);
1665                 SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1666                        ERR_R_INTERNAL_ERROR);
1667                 goto f_err;
1668             }
1669             EVP_PKEY_assign_DH(pkdh, dhp);
1670             pkdhp = pkdh;
1671         } else {
1672             pkdhp = cert->dh_tmp;
1673         }
1674         if ((pkdhp == NULL) && (s->cert->dh_tmp_cb != NULL)) {
1675             DH *dhp = s->cert->dh_tmp_cb(s, 0, 1024);
1676             pkdh = ssl_dh_to_pkey(dhp);
1677             if (pkdh == NULL) {
1678                 SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1679                        ERR_R_INTERNAL_ERROR);
1680                 goto f_err;
1681             }
1682             pkdhp = pkdh;
1683         }
1684         if (pkdhp == NULL) {
1685             al = SSL_AD_HANDSHAKE_FAILURE;
1686             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1687                    SSL_R_MISSING_TMP_DH_KEY);
1688             goto f_err;
1689         }
1690         if (!ssl_security(s, SSL_SECOP_TMP_DH,
1691                           EVP_PKEY_security_bits(pkdhp), 0, pkdhp)) {
1692             al = SSL_AD_HANDSHAKE_FAILURE;
1693             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1694                    SSL_R_DH_KEY_TOO_SMALL);
1695             goto f_err;
1696         }
1697         if (s->s3->tmp.pkey != NULL) {
1698             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1699                    ERR_R_INTERNAL_ERROR);
1700             goto err;
1701         }
1702
1703         s->s3->tmp.pkey = ssl_generate_pkey(pkdhp);
1704
1705         if (s->s3->tmp.pkey == NULL) {
1706             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_EVP_LIB);
1707             goto err;
1708         }
1709
1710         dh = EVP_PKEY_get0_DH(s->s3->tmp.pkey);
1711
1712         EVP_PKEY_free(pkdh);
1713         pkdh = NULL;
1714
1715         DH_get0_pqg(dh, &r[0], NULL, &r[1]);
1716         DH_get0_key(dh, &r[2], NULL);
1717     } else
1718 #endif
1719 #ifndef OPENSSL_NO_EC
1720     if (type & (SSL_kECDHE | SSL_kECDHEPSK)) {
1721         int nid;
1722
1723         if (s->s3->tmp.pkey != NULL) {
1724             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1725                    ERR_R_INTERNAL_ERROR);
1726             goto err;
1727         }
1728
1729         /* Get NID of appropriate shared curve */
1730         nid = tls1_shared_curve(s, -2);
1731         curve_id = tls1_ec_nid2curve_id(nid);
1732         if (curve_id == 0) {
1733             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1734                    SSL_R_UNSUPPORTED_ELLIPTIC_CURVE);
1735             goto err;
1736         }
1737         s->s3->tmp.pkey = ssl_generate_pkey_curve(curve_id);
1738         /* Generate a new key for this curve */
1739         if (s->s3->tmp.pkey == NULL) {
1740             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_EVP_LIB);
1741             goto f_err;
1742         }
1743
1744         /* Encode the public key. */
1745         encodedlen = EVP_PKEY_get1_tls_encodedpoint(s->s3->tmp.pkey,
1746                                                     &encodedPoint);
1747         if (encodedlen == 0) {
1748             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_EC_LIB);
1749             goto err;
1750         }
1751
1752         /*
1753          * We'll generate the serverKeyExchange message explicitly so we
1754          * can set these to NULLs
1755          */
1756         r[0] = NULL;
1757         r[1] = NULL;
1758         r[2] = NULL;
1759         r[3] = NULL;
1760     } else
1761 #endif                          /* !OPENSSL_NO_EC */
1762 #ifndef OPENSSL_NO_SRP
1763     if (type & SSL_kSRP) {
1764         if ((s->srp_ctx.N == NULL) ||
1765             (s->srp_ctx.g == NULL) ||
1766             (s->srp_ctx.s == NULL) || (s->srp_ctx.B == NULL)) {
1767             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1768                    SSL_R_MISSING_SRP_PARAM);
1769             goto err;
1770         }
1771         r[0] = s->srp_ctx.N;
1772         r[1] = s->srp_ctx.g;
1773         r[2] = s->srp_ctx.s;
1774         r[3] = s->srp_ctx.B;
1775     } else
1776 #endif
1777     {
1778         al = SSL_AD_HANDSHAKE_FAILURE;
1779         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1780                SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE);
1781         goto f_err;
1782     }
1783
1784     if (!(s->s3->tmp.new_cipher->algorithm_auth & (SSL_aNULL | SSL_aSRP))
1785         && !(s->s3->tmp.new_cipher->algorithm_mkey & SSL_PSK)) {
1786         if ((pkey = ssl_get_sign_pkey(s, s->s3->tmp.new_cipher, &md))
1787             == NULL) {
1788             al = SSL_AD_DECODE_ERROR;
1789             goto f_err;
1790         }
1791     } else {
1792         pkey = NULL;
1793     }
1794
1795 #ifndef OPENSSL_NO_PSK
1796     if (type & SSL_PSK) {
1797         size_t len = (s->cert->psk_identity_hint == NULL)
1798                         ? 0 : strlen(s->cert->psk_identity_hint);
1799
1800         /*
1801          * It should not happen that len > PSK_MAX_IDENTITY_LEN - we already
1802          * checked this when we set the identity hint - but just in case
1803          */
1804         if (len > PSK_MAX_IDENTITY_LEN
1805                 || !WPACKET_sub_memcpy_u16(pkt, s->cert->psk_identity_hint,
1806                                            len)) {
1807             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1808                    ERR_R_INTERNAL_ERROR);
1809             goto f_err;
1810         }
1811     }
1812 #endif
1813
1814     for (i = 0; i < 4 && r[i] != NULL; i++) {
1815         unsigned char *binval;
1816         int res;
1817
1818 #ifndef OPENSSL_NO_SRP
1819         if ((i == 2) && (type & SSL_kSRP)) {
1820             res = WPACKET_start_sub_packet_u8(pkt);
1821         } else
1822 #endif
1823             res = WPACKET_start_sub_packet_u16(pkt);
1824
1825         if (!res) {
1826             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1827                    ERR_R_INTERNAL_ERROR);
1828             goto f_err;
1829         }
1830
1831 #ifndef OPENSSL_NO_DH
1832         /*-
1833          * for interoperability with some versions of the Microsoft TLS
1834          * stack, we need to zero pad the DHE pub key to the same length
1835          * as the prime
1836          */
1837         if ((i == 2) && (type & (SSL_kDHE | SSL_kDHEPSK))) {
1838             size_t len = BN_num_bytes(r[0]) - BN_num_bytes(r[2]);
1839
1840             if (len > 0) {
1841                 if (!WPACKET_allocate_bytes(pkt, len, &binval)) {
1842                     SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1843                            ERR_R_INTERNAL_ERROR);
1844                     goto f_err;
1845                 }
1846                 memset(binval, 0, len);
1847             }
1848         }
1849 #endif
1850         if (!WPACKET_allocate_bytes(pkt, BN_num_bytes(r[i]), &binval)
1851                 || !WPACKET_close(pkt)) {
1852             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1853                    ERR_R_INTERNAL_ERROR);
1854             goto f_err;
1855         }
1856
1857         BN_bn2bin(r[i], binval);
1858     }
1859
1860 #ifndef OPENSSL_NO_EC
1861     if (type & (SSL_kECDHE | SSL_kECDHEPSK)) {
1862         /*
1863          * We only support named (not generic) curves. In this situation, the
1864          * ServerKeyExchange message has: [1 byte CurveType], [2 byte CurveName]
1865          * [1 byte length of encoded point], followed by the actual encoded
1866          * point itself
1867          */
1868         if (!WPACKET_put_bytes_u8(pkt, NAMED_CURVE_TYPE)
1869                 || !WPACKET_put_bytes_u8(pkt, 0)
1870                 || !WPACKET_put_bytes_u8(pkt, curve_id)
1871                 || !WPACKET_sub_memcpy_u8(pkt, encodedPoint, encodedlen)) {
1872             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1873                    ERR_R_INTERNAL_ERROR);
1874             goto f_err;
1875         }
1876         OPENSSL_free(encodedPoint);
1877         encodedPoint = NULL;
1878     }
1879 #endif
1880
1881     /* not anonymous */
1882     if (pkey != NULL) {
1883         /*
1884          * n is the length of the params, they start at &(d[4]) and p
1885          * points to the space at the end.
1886          */
1887         if (md) {
1888             unsigned char *sigbytes1, *sigbytes2;
1889             unsigned int siglen;
1890
1891             /* Get length of the parameters we have written above */
1892             if (!WPACKET_get_length(pkt, &paramlen)) {
1893                 SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1894                        ERR_R_INTERNAL_ERROR);
1895                 goto f_err;
1896             }
1897             /* send signature algorithm */
1898             if (SSL_USE_SIGALGS(s)) {
1899                 if (!tls12_get_sigandhash(pkt, pkey, md)) {
1900                     /* Should never happen */
1901                     SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1902                            ERR_R_INTERNAL_ERROR);
1903                     goto f_err;
1904                 }
1905             }
1906 #ifdef SSL_DEBUG
1907             fprintf(stderr, "Using hash %s\n", EVP_MD_name(md));
1908 #endif
1909             /*
1910              * Create the signature. We don't know the actual length of the sig
1911              * until after we've created it, so we reserve enough bytes for it
1912              * up front, and then properly allocate them in the WPACKET
1913              * afterwards.
1914              */
1915             if (!WPACKET_sub_reserve_bytes_u16(pkt, EVP_PKEY_size(pkey),
1916                                                &sigbytes1)
1917                     || EVP_SignInit_ex(md_ctx, md, NULL) <= 0
1918                     || EVP_SignUpdate(md_ctx, &(s->s3->client_random[0]),
1919                                       SSL3_RANDOM_SIZE) <= 0
1920                     || EVP_SignUpdate(md_ctx, &(s->s3->server_random[0]),
1921                                       SSL3_RANDOM_SIZE) <= 0
1922                     || EVP_SignUpdate(md_ctx, s->init_buf->data + paramoffset,
1923                                       paramlen) <= 0
1924                     || EVP_SignFinal(md_ctx, sigbytes1, &siglen, pkey) <= 0
1925                     || !WPACKET_sub_allocate_bytes_u16(pkt, siglen, &sigbytes2)
1926                     || sigbytes1 != sigbytes2) {
1927                 SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1928                        ERR_R_INTERNAL_ERROR);
1929                 goto f_err;
1930             }
1931         } else {
1932             /* Is this error check actually needed? */
1933             al = SSL_AD_HANDSHAKE_FAILURE;
1934             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1935                    SSL_R_UNKNOWN_PKEY_TYPE);
1936             goto f_err;
1937         }
1938     }
1939
1940     EVP_MD_CTX_free(md_ctx);
1941     return 1;
1942  f_err:
1943     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1944  err:
1945 #ifndef OPENSSL_NO_DH
1946     EVP_PKEY_free(pkdh);
1947 #endif
1948 #ifndef OPENSSL_NO_EC
1949     OPENSSL_free(encodedPoint);
1950 #endif
1951     EVP_MD_CTX_free(md_ctx);
1952     return 0;
1953 }
1954
1955 int tls_construct_certificate_request(SSL *s, WPACKET *pkt)
1956 {
1957     int i;
1958     STACK_OF(X509_NAME) *sk = NULL;
1959
1960     /* get the list of acceptable cert types */
1961     if (!WPACKET_start_sub_packet_u8(pkt)
1962             || !ssl3_get_req_cert_type(s, pkt)
1963             || !WPACKET_close(pkt)) {
1964         SSLerr(SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST, ERR_R_INTERNAL_ERROR);
1965         goto err;
1966     }
1967
1968     if (SSL_USE_SIGALGS(s)) {
1969         const unsigned char *psigs;
1970         size_t nl = tls12_get_psigalgs(s, &psigs);
1971         if (!WPACKET_start_sub_packet_u16(pkt)
1972                 || !tls12_copy_sigalgs(s, pkt, psigs, nl)
1973                 || !WPACKET_close(pkt)) {
1974             SSLerr(SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST,
1975                    ERR_R_INTERNAL_ERROR);
1976             goto err;
1977         }
1978     }
1979
1980     /* Start sub-packet for client CA list */
1981     if (!WPACKET_start_sub_packet_u16(pkt)) {
1982         SSLerr(SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST, ERR_R_INTERNAL_ERROR);
1983         goto err;
1984     }
1985
1986     sk = SSL_get_client_CA_list(s);
1987     if (sk != NULL) {
1988         for (i = 0; i < sk_X509_NAME_num(sk); i++) {
1989             unsigned char *namebytes;
1990             X509_NAME *name = sk_X509_NAME_value(sk, i);
1991             int namelen;
1992
1993             if (name == NULL
1994                     || (namelen = i2d_X509_NAME(name, NULL)) < 0
1995                     || !WPACKET_sub_allocate_bytes_u16(pkt, namelen,
1996                                                        &namebytes)
1997                     || i2d_X509_NAME(name, &namebytes) != namelen) {
1998                 SSLerr(SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST,
1999                        ERR_R_INTERNAL_ERROR);
2000                 goto err;
2001             }
2002         }
2003     }
2004     /* else no CA names */
2005
2006     if (!WPACKET_close(pkt)) {
2007         SSLerr(SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST, ERR_R_INTERNAL_ERROR);
2008         goto err;
2009     }
2010
2011     s->s3->tmp.cert_request = 1;
2012
2013     return 1;
2014  err:
2015     ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
2016     return 0;
2017 }
2018
2019 static int tls_process_cke_psk_preamble(SSL *s, PACKET *pkt, int *al)
2020 {
2021 #ifndef OPENSSL_NO_PSK
2022     unsigned char psk[PSK_MAX_PSK_LEN];
2023     size_t psklen;
2024     PACKET psk_identity;
2025
2026     if (!PACKET_get_length_prefixed_2(pkt, &psk_identity)) {
2027         *al = SSL_AD_DECODE_ERROR;
2028         SSLerr(SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE, SSL_R_LENGTH_MISMATCH);
2029         return 0;
2030     }
2031     if (PACKET_remaining(&psk_identity) > PSK_MAX_IDENTITY_LEN) {
2032         *al = SSL_AD_DECODE_ERROR;
2033         SSLerr(SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE, SSL_R_DATA_LENGTH_TOO_LONG);
2034         return 0;
2035     }
2036     if (s->psk_server_callback == NULL) {
2037         *al = SSL_AD_INTERNAL_ERROR;
2038         SSLerr(SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE, SSL_R_PSK_NO_SERVER_CB);
2039         return 0;
2040     }
2041
2042     if (!PACKET_strndup(&psk_identity, &s->session->psk_identity)) {
2043         *al = SSL_AD_INTERNAL_ERROR;
2044         SSLerr(SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE, ERR_R_INTERNAL_ERROR);
2045         return 0;
2046     }
2047
2048     psklen = s->psk_server_callback(s, s->session->psk_identity,
2049                                     psk, sizeof(psk));
2050
2051     if (psklen > PSK_MAX_PSK_LEN) {
2052         *al = SSL_AD_INTERNAL_ERROR;
2053         SSLerr(SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE, ERR_R_INTERNAL_ERROR);
2054         return 0;
2055     } else if (psklen == 0) {
2056         /*
2057          * PSK related to the given identity not found
2058          */
2059         *al = SSL_AD_UNKNOWN_PSK_IDENTITY;
2060         SSLerr(SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE,
2061                SSL_R_PSK_IDENTITY_NOT_FOUND);
2062         return 0;
2063     }
2064
2065     OPENSSL_free(s->s3->tmp.psk);
2066     s->s3->tmp.psk = OPENSSL_memdup(psk, psklen);
2067     OPENSSL_cleanse(psk, psklen);
2068
2069     if (s->s3->tmp.psk == NULL) {
2070         *al = SSL_AD_INTERNAL_ERROR;
2071         SSLerr(SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE, ERR_R_MALLOC_FAILURE);
2072         return 0;
2073     }
2074
2075     s->s3->tmp.psklen = psklen;
2076
2077     return 1;
2078 #else
2079     /* Should never happen */
2080     *al = SSL_AD_INTERNAL_ERROR;
2081     SSLerr(SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE, ERR_R_INTERNAL_ERROR);
2082     return 0;
2083 #endif
2084 }
2085
2086 static int tls_process_cke_rsa(SSL *s, PACKET *pkt, int *al)
2087 {
2088 #ifndef OPENSSL_NO_RSA
2089     unsigned char rand_premaster_secret[SSL_MAX_MASTER_KEY_LENGTH];
2090     int decrypt_len;
2091     unsigned char decrypt_good, version_good;
2092     size_t j, padding_len;
2093     PACKET enc_premaster;
2094     RSA *rsa = NULL;
2095     unsigned char *rsa_decrypt = NULL;
2096     int ret = 0;
2097
2098     rsa = EVP_PKEY_get0_RSA(s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey);
2099     if (rsa == NULL) {
2100         *al = SSL_AD_HANDSHAKE_FAILURE;
2101         SSLerr(SSL_F_TLS_PROCESS_CKE_RSA, SSL_R_MISSING_RSA_CERTIFICATE);
2102         return 0;
2103     }
2104
2105     /* SSLv3 and pre-standard DTLS omit the length bytes. */
2106     if (s->version == SSL3_VERSION || s->version == DTLS1_BAD_VER) {
2107         enc_premaster = *pkt;
2108     } else {
2109         if (!PACKET_get_length_prefixed_2(pkt, &enc_premaster)
2110             || PACKET_remaining(pkt) != 0) {
2111             *al = SSL_AD_DECODE_ERROR;
2112             SSLerr(SSL_F_TLS_PROCESS_CKE_RSA, SSL_R_LENGTH_MISMATCH);
2113             return 0;
2114         }
2115     }
2116
2117     /*
2118      * We want to be sure that the plaintext buffer size makes it safe to
2119      * iterate over the entire size of a premaster secret
2120      * (SSL_MAX_MASTER_KEY_LENGTH). Reject overly short RSA keys because
2121      * their ciphertext cannot accommodate a premaster secret anyway.
2122      */
2123     if (RSA_size(rsa) < SSL_MAX_MASTER_KEY_LENGTH) {
2124         *al = SSL_AD_INTERNAL_ERROR;
2125         SSLerr(SSL_F_TLS_PROCESS_CKE_RSA, RSA_R_KEY_SIZE_TOO_SMALL);
2126         return 0;
2127     }
2128
2129     rsa_decrypt = OPENSSL_malloc(RSA_size(rsa));
2130     if (rsa_decrypt == NULL) {
2131         *al = SSL_AD_INTERNAL_ERROR;
2132         SSLerr(SSL_F_TLS_PROCESS_CKE_RSA, ERR_R_MALLOC_FAILURE);
2133         return 0;
2134     }
2135
2136     /*
2137      * We must not leak whether a decryption failure occurs because of
2138      * Bleichenbacher's attack on PKCS #1 v1.5 RSA padding (see RFC 2246,
2139      * section 7.4.7.1). The code follows that advice of the TLS RFC and
2140      * generates a random premaster secret for the case that the decrypt
2141      * fails. See https://tools.ietf.org/html/rfc5246#section-7.4.7.1
2142      */
2143
2144     if (RAND_bytes(rand_premaster_secret, sizeof(rand_premaster_secret)) <= 0)
2145         goto err;
2146
2147     /*
2148      * Decrypt with no padding. PKCS#1 padding will be removed as part of
2149      * the timing-sensitive code below.
2150      */
2151      /* TODO(size_t): Convert this function */
2152     decrypt_len = (int)RSA_private_decrypt((int)PACKET_remaining(&enc_premaster),
2153                                            PACKET_data(&enc_premaster),
2154                                            rsa_decrypt, rsa, RSA_NO_PADDING);
2155     if (decrypt_len < 0)
2156         goto err;
2157
2158     /* Check the padding. See RFC 3447, section 7.2.2. */
2159
2160     /*
2161      * The smallest padded premaster is 11 bytes of overhead. Small keys
2162      * are publicly invalid, so this may return immediately. This ensures
2163      * PS is at least 8 bytes.
2164      */
2165     if (decrypt_len < 11 + SSL_MAX_MASTER_KEY_LENGTH) {
2166         *al = SSL_AD_DECRYPT_ERROR;
2167         SSLerr(SSL_F_TLS_PROCESS_CKE_RSA, SSL_R_DECRYPTION_FAILED);
2168         goto err;
2169     }
2170
2171     padding_len = decrypt_len - SSL_MAX_MASTER_KEY_LENGTH;
2172     decrypt_good = constant_time_eq_int_8(rsa_decrypt[0], 0) &
2173         constant_time_eq_int_8(rsa_decrypt[1], 2);
2174     for (j = 2; j < padding_len - 1; j++) {
2175         decrypt_good &= ~constant_time_is_zero_8(rsa_decrypt[j]);
2176     }
2177     decrypt_good &= constant_time_is_zero_8(rsa_decrypt[padding_len - 1]);
2178
2179     /*
2180      * If the version in the decrypted pre-master secret is correct then
2181      * version_good will be 0xff, otherwise it'll be zero. The
2182      * Klima-Pokorny-Rosa extension of Bleichenbacher's attack
2183      * (http://eprint.iacr.org/2003/052/) exploits the version number
2184      * check as a "bad version oracle". Thus version checks are done in
2185      * constant time and are treated like any other decryption error.
2186      */
2187     version_good =
2188         constant_time_eq_8(rsa_decrypt[padding_len],
2189                            (unsigned)(s->client_version >> 8));
2190     version_good &=
2191         constant_time_eq_8(rsa_decrypt[padding_len + 1],
2192                            (unsigned)(s->client_version & 0xff));
2193
2194     /*
2195      * The premaster secret must contain the same version number as the
2196      * ClientHello to detect version rollback attacks (strangely, the
2197      * protocol does not offer such protection for DH ciphersuites).
2198      * However, buggy clients exist that send the negotiated protocol
2199      * version instead if the server does not support the requested
2200      * protocol version. If SSL_OP_TLS_ROLLBACK_BUG is set, tolerate such
2201      * clients.
2202      */
2203     if (s->options & SSL_OP_TLS_ROLLBACK_BUG) {
2204         unsigned char workaround_good;
2205         workaround_good = constant_time_eq_8(rsa_decrypt[padding_len],
2206                                              (unsigned)(s->version >> 8));
2207         workaround_good &=
2208             constant_time_eq_8(rsa_decrypt[padding_len + 1],
2209                                (unsigned)(s->version & 0xff));
2210         version_good |= workaround_good;
2211     }
2212
2213     /*
2214      * Both decryption and version must be good for decrypt_good to
2215      * remain non-zero (0xff).
2216      */
2217     decrypt_good &= version_good;
2218
2219     /*
2220      * Now copy rand_premaster_secret over from p using
2221      * decrypt_good_mask. If decryption failed, then p does not
2222      * contain valid plaintext, however, a check above guarantees
2223      * it is still sufficiently large to read from.
2224      */
2225     for (j = 0; j < sizeof(rand_premaster_secret); j++) {
2226         rsa_decrypt[padding_len + j] =
2227             constant_time_select_8(decrypt_good,
2228                                    rsa_decrypt[padding_len + j],
2229                                    rand_premaster_secret[j]);
2230     }
2231
2232     if (!ssl_generate_master_secret(s, rsa_decrypt + padding_len,
2233                                     sizeof(rand_premaster_secret), 0)) {
2234         *al = SSL_AD_INTERNAL_ERROR;
2235         SSLerr(SSL_F_TLS_PROCESS_CKE_RSA, ERR_R_INTERNAL_ERROR);
2236         goto err;
2237     }
2238
2239     ret = 1;
2240  err:
2241     OPENSSL_free(rsa_decrypt);
2242     return ret;
2243 #else
2244     /* Should never happen */
2245     *al = SSL_AD_INTERNAL_ERROR;
2246     SSLerr(SSL_F_TLS_PROCESS_CKE_RSA, ERR_R_INTERNAL_ERROR);
2247     return 0;
2248 #endif
2249 }
2250
2251 static int tls_process_cke_dhe(SSL *s, PACKET *pkt, int *al)
2252 {
2253 #ifndef OPENSSL_NO_DH
2254     EVP_PKEY *skey = NULL;
2255     DH *cdh;
2256     unsigned int i;
2257     BIGNUM *pub_key;
2258     const unsigned char *data;
2259     EVP_PKEY *ckey = NULL;
2260     int ret = 0;
2261
2262     if (!PACKET_get_net_2(pkt, &i) || PACKET_remaining(pkt) != i) {
2263         *al = SSL_AD_HANDSHAKE_FAILURE;
2264         SSLerr(SSL_F_TLS_PROCESS_CKE_DHE,
2265                SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG);
2266         goto err;
2267     }
2268     skey = s->s3->tmp.pkey;
2269     if (skey == NULL) {
2270         *al = SSL_AD_HANDSHAKE_FAILURE;
2271         SSLerr(SSL_F_TLS_PROCESS_CKE_DHE, SSL_R_MISSING_TMP_DH_KEY);
2272         goto err;
2273     }
2274
2275     if (PACKET_remaining(pkt) == 0L) {
2276         *al = SSL_AD_HANDSHAKE_FAILURE;
2277         SSLerr(SSL_F_TLS_PROCESS_CKE_DHE, SSL_R_MISSING_TMP_DH_KEY);
2278         goto err;
2279     }
2280     if (!PACKET_get_bytes(pkt, &data, i)) {
2281         /* We already checked we have enough data */
2282         *al = SSL_AD_INTERNAL_ERROR;
2283         SSLerr(SSL_F_TLS_PROCESS_CKE_DHE, ERR_R_INTERNAL_ERROR);
2284         goto err;
2285     }
2286     ckey = EVP_PKEY_new();
2287     if (ckey == NULL || EVP_PKEY_copy_parameters(ckey, skey) == 0) {
2288         SSLerr(SSL_F_TLS_PROCESS_CKE_DHE, SSL_R_BN_LIB);
2289         goto err;
2290     }
2291     cdh = EVP_PKEY_get0_DH(ckey);
2292     pub_key = BN_bin2bn(data, i, NULL);
2293
2294     if (pub_key == NULL || !DH_set0_key(cdh, pub_key, NULL)) {
2295         SSLerr(SSL_F_TLS_PROCESS_CKE_DHE, ERR_R_INTERNAL_ERROR);
2296         if (pub_key != NULL)
2297             BN_free(pub_key);
2298         goto err;
2299     }
2300
2301     if (ssl_derive(s, skey, ckey) == 0) {
2302         *al = SSL_AD_INTERNAL_ERROR;
2303         SSLerr(SSL_F_TLS_PROCESS_CKE_DHE, ERR_R_INTERNAL_ERROR);
2304         goto err;
2305     }
2306
2307     ret = 1;
2308     EVP_PKEY_free(s->s3->tmp.pkey);
2309     s->s3->tmp.pkey = NULL;
2310  err:
2311     EVP_PKEY_free(ckey);
2312     return ret;
2313 #else
2314     /* Should never happen */
2315     *al = SSL_AD_INTERNAL_ERROR;
2316     SSLerr(SSL_F_TLS_PROCESS_CKE_DHE, ERR_R_INTERNAL_ERROR);
2317     return 0;
2318 #endif
2319 }
2320
2321 static int tls_process_cke_ecdhe(SSL *s, PACKET *pkt, int *al)
2322 {
2323 #ifndef OPENSSL_NO_EC
2324     EVP_PKEY *skey = s->s3->tmp.pkey;
2325     EVP_PKEY *ckey = NULL;
2326     int ret = 0;
2327
2328     if (PACKET_remaining(pkt) == 0L) {
2329         /* We don't support ECDH client auth */
2330         *al = SSL_AD_HANDSHAKE_FAILURE;
2331         SSLerr(SSL_F_TLS_PROCESS_CKE_ECDHE, SSL_R_MISSING_TMP_ECDH_KEY);
2332         goto err;
2333     } else {
2334         unsigned int i;
2335         const unsigned char *data;
2336
2337         /*
2338          * Get client's public key from encoded point in the
2339          * ClientKeyExchange message.
2340          */
2341
2342         /* Get encoded point length */
2343         if (!PACKET_get_1(pkt, &i) || !PACKET_get_bytes(pkt, &data, i)
2344             || PACKET_remaining(pkt) != 0) {
2345             *al = SSL_AD_DECODE_ERROR;
2346             SSLerr(SSL_F_TLS_PROCESS_CKE_ECDHE, SSL_R_LENGTH_MISMATCH);
2347             goto err;
2348         }
2349         ckey = EVP_PKEY_new();
2350         if (ckey == NULL || EVP_PKEY_copy_parameters(ckey, skey) <= 0) {
2351             SSLerr(SSL_F_TLS_PROCESS_CKE_ECDHE, ERR_R_EVP_LIB);
2352             goto err;
2353         }
2354         if (EVP_PKEY_set1_tls_encodedpoint(ckey, data, i) == 0) {
2355             *al = SSL_AD_HANDSHAKE_FAILURE;
2356             SSLerr(SSL_F_TLS_PROCESS_CKE_ECDHE, ERR_R_EC_LIB);
2357             goto err;
2358         }
2359     }
2360
2361     if (ssl_derive(s, skey, ckey) == 0) {
2362         *al = SSL_AD_INTERNAL_ERROR;
2363         SSLerr(SSL_F_TLS_PROCESS_CKE_ECDHE, ERR_R_INTERNAL_ERROR);
2364         goto err;
2365     }
2366
2367     ret = 1;
2368     EVP_PKEY_free(s->s3->tmp.pkey);
2369     s->s3->tmp.pkey = NULL;
2370  err:
2371     EVP_PKEY_free(ckey);
2372
2373     return ret;
2374 #else
2375     /* Should never happen */
2376     *al = SSL_AD_INTERNAL_ERROR;
2377     SSLerr(SSL_F_TLS_PROCESS_CKE_ECDHE, ERR_R_INTERNAL_ERROR);
2378     return 0;
2379 #endif
2380 }
2381
2382 static int tls_process_cke_srp(SSL *s, PACKET *pkt, int *al)
2383 {
2384 #ifndef OPENSSL_NO_SRP
2385     unsigned int i;
2386     const unsigned char *data;
2387
2388     if (!PACKET_get_net_2(pkt, &i)
2389         || !PACKET_get_bytes(pkt, &data, i)) {
2390         *al = SSL_AD_DECODE_ERROR;
2391         SSLerr(SSL_F_TLS_PROCESS_CKE_SRP, SSL_R_BAD_SRP_A_LENGTH);
2392         return 0;
2393     }
2394     if ((s->srp_ctx.A = BN_bin2bn(data, i, NULL)) == NULL) {
2395         SSLerr(SSL_F_TLS_PROCESS_CKE_SRP, ERR_R_BN_LIB);
2396         return 0;
2397     }
2398     if (BN_ucmp(s->srp_ctx.A, s->srp_ctx.N) >= 0 || BN_is_zero(s->srp_ctx.A)) {
2399         *al = SSL_AD_ILLEGAL_PARAMETER;
2400         SSLerr(SSL_F_TLS_PROCESS_CKE_SRP, SSL_R_BAD_SRP_PARAMETERS);
2401         return 0;
2402     }
2403     OPENSSL_free(s->session->srp_username);
2404     s->session->srp_username = OPENSSL_strdup(s->srp_ctx.login);
2405     if (s->session->srp_username == NULL) {
2406         SSLerr(SSL_F_TLS_PROCESS_CKE_SRP, ERR_R_MALLOC_FAILURE);
2407         return 0;
2408     }
2409
2410     if (!srp_generate_server_master_secret(s)) {
2411         SSLerr(SSL_F_TLS_PROCESS_CKE_SRP, ERR_R_INTERNAL_ERROR);
2412         return 0;
2413     }
2414
2415     return 1;
2416 #else
2417     /* Should never happen */
2418     *al = SSL_AD_INTERNAL_ERROR;
2419     SSLerr(SSL_F_TLS_PROCESS_CKE_SRP, ERR_R_INTERNAL_ERROR);
2420     return 0;
2421 #endif
2422 }
2423
2424 static int tls_process_cke_gost(SSL *s, PACKET *pkt, int *al)
2425 {
2426 #ifndef OPENSSL_NO_GOST
2427     EVP_PKEY_CTX *pkey_ctx;
2428     EVP_PKEY *client_pub_pkey = NULL, *pk = NULL;
2429     unsigned char premaster_secret[32];
2430     const unsigned char *start;
2431     size_t outlen = 32, inlen;
2432     unsigned long alg_a;
2433     int Ttag, Tclass;
2434     long Tlen;
2435     size_t sess_key_len;
2436     const unsigned char *data;
2437     int ret = 0;
2438
2439     /* Get our certificate private key */
2440     alg_a = s->s3->tmp.new_cipher->algorithm_auth;
2441     if (alg_a & SSL_aGOST12) {
2442         /*
2443          * New GOST ciphersuites have SSL_aGOST01 bit too
2444          */
2445         pk = s->cert->pkeys[SSL_PKEY_GOST12_512].privatekey;
2446         if (pk == NULL) {
2447             pk = s->cert->pkeys[SSL_PKEY_GOST12_256].privatekey;
2448         }
2449         if (pk == NULL) {
2450             pk = s->cert->pkeys[SSL_PKEY_GOST01].privatekey;
2451         }
2452     } else if (alg_a & SSL_aGOST01) {
2453         pk = s->cert->pkeys[SSL_PKEY_GOST01].privatekey;
2454     }
2455
2456     pkey_ctx = EVP_PKEY_CTX_new(pk, NULL);
2457     if (pkey_ctx == NULL) {
2458         *al = SSL_AD_INTERNAL_ERROR;
2459         SSLerr(SSL_F_TLS_PROCESS_CKE_GOST, ERR_R_MALLOC_FAILURE);
2460         return 0;
2461     }
2462     if (EVP_PKEY_decrypt_init(pkey_ctx) <= 0) {
2463         *al = SSL_AD_INTERNAL_ERROR;
2464         SSLerr(SSL_F_TLS_PROCESS_CKE_GOST, ERR_R_INTERNAL_ERROR);
2465         return 0;
2466     }
2467     /*
2468      * If client certificate is present and is of the same type, maybe
2469      * use it for key exchange.  Don't mind errors from
2470      * EVP_PKEY_derive_set_peer, because it is completely valid to use a
2471      * client certificate for authorization only.
2472      */
2473     client_pub_pkey = X509_get0_pubkey(s->session->peer);
2474     if (client_pub_pkey) {
2475         if (EVP_PKEY_derive_set_peer(pkey_ctx, client_pub_pkey) <= 0)
2476             ERR_clear_error();
2477     }
2478     /* Decrypt session key */
2479     sess_key_len = PACKET_remaining(pkt);
2480     if (!PACKET_get_bytes(pkt, &data, sess_key_len)) {
2481         *al = SSL_AD_INTERNAL_ERROR;
2482         SSLerr(SSL_F_TLS_PROCESS_CKE_GOST, ERR_R_INTERNAL_ERROR);
2483         goto err;
2484     }
2485     /* TODO(size_t): Convert this function */
2486     if (ASN1_get_object((const unsigned char **)&data, &Tlen, &Ttag,
2487                         &Tclass, (long)sess_key_len) != V_ASN1_CONSTRUCTED
2488         || Ttag != V_ASN1_SEQUENCE || Tclass != V_ASN1_UNIVERSAL) {
2489         *al = SSL_AD_DECODE_ERROR;
2490         SSLerr(SSL_F_TLS_PROCESS_CKE_GOST, SSL_R_DECRYPTION_FAILED);
2491         goto err;
2492     }
2493     start = data;
2494     inlen = Tlen;
2495     if (EVP_PKEY_decrypt
2496         (pkey_ctx, premaster_secret, &outlen, start, inlen) <= 0) {
2497         *al = SSL_AD_DECODE_ERROR;
2498         SSLerr(SSL_F_TLS_PROCESS_CKE_GOST, SSL_R_DECRYPTION_FAILED);
2499         goto err;
2500     }
2501     /* Generate master secret */
2502     if (!ssl_generate_master_secret(s, premaster_secret,
2503                                     sizeof(premaster_secret), 0)) {
2504         *al = SSL_AD_INTERNAL_ERROR;
2505         SSLerr(SSL_F_TLS_PROCESS_CKE_GOST, ERR_R_INTERNAL_ERROR);
2506         goto err;
2507     }
2508     /* Check if pubkey from client certificate was used */
2509     if (EVP_PKEY_CTX_ctrl
2510         (pkey_ctx, -1, -1, EVP_PKEY_CTRL_PEER_KEY, 2, NULL) > 0)
2511         s->statem.no_cert_verify = 1;
2512
2513     ret = 1;
2514  err:
2515     EVP_PKEY_CTX_free(pkey_ctx);
2516     return ret;
2517 #else
2518     /* Should never happen */
2519     *al = SSL_AD_INTERNAL_ERROR;
2520     SSLerr(SSL_F_TLS_PROCESS_CKE_GOST, ERR_R_INTERNAL_ERROR);
2521     return 0;
2522 #endif
2523 }
2524
2525 MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL *s, PACKET *pkt)
2526 {
2527     int al = -1;
2528     unsigned long alg_k;
2529
2530     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
2531
2532     /* For PSK parse and retrieve identity, obtain PSK key */
2533     if ((alg_k & SSL_PSK) && !tls_process_cke_psk_preamble(s, pkt, &al))
2534         goto err;
2535
2536     if (alg_k & SSL_kPSK) {
2537         /* Identity extracted earlier: should be nothing left */
2538         if (PACKET_remaining(pkt) != 0) {
2539             al = SSL_AD_HANDSHAKE_FAILURE;
2540             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2541                    SSL_R_LENGTH_MISMATCH);
2542             goto err;
2543         }
2544         /* PSK handled by ssl_generate_master_secret */
2545         if (!ssl_generate_master_secret(s, NULL, 0, 0)) {
2546             al = SSL_AD_INTERNAL_ERROR;
2547             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2548             goto err;
2549         }
2550     } else if (alg_k & (SSL_kRSA | SSL_kRSAPSK)) {
2551         if (!tls_process_cke_rsa(s, pkt, &al))
2552             goto err;
2553     } else if (alg_k & (SSL_kDHE | SSL_kDHEPSK)) {
2554         if (!tls_process_cke_dhe(s, pkt, &al))
2555             goto err;
2556     } else if (alg_k & (SSL_kECDHE | SSL_kECDHEPSK)) {
2557         if (!tls_process_cke_ecdhe(s, pkt, &al))
2558             goto err;
2559     } else if (alg_k & SSL_kSRP) {
2560         if (!tls_process_cke_srp(s, pkt, &al))
2561             goto err;
2562     } else if (alg_k & SSL_kGOST) {
2563         if (!tls_process_cke_gost(s, pkt, &al))
2564             goto err;
2565     } else {
2566         al = SSL_AD_HANDSHAKE_FAILURE;
2567         SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2568                SSL_R_UNKNOWN_CIPHER_TYPE);
2569         goto err;
2570     }
2571
2572     return MSG_PROCESS_CONTINUE_PROCESSING;
2573  err:
2574     if (al != -1)
2575         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2576 #ifndef OPENSSL_NO_PSK
2577     OPENSSL_clear_free(s->s3->tmp.psk, s->s3->tmp.psklen);
2578     s->s3->tmp.psk = NULL;
2579 #endif
2580     ossl_statem_set_error(s);
2581     return MSG_PROCESS_ERROR;
2582 }
2583
2584 WORK_STATE tls_post_process_client_key_exchange(SSL *s, WORK_STATE wst)
2585 {
2586 #ifndef OPENSSL_NO_SCTP
2587     if (wst == WORK_MORE_A) {
2588         if (SSL_IS_DTLS(s)) {
2589             unsigned char sctpauthkey[64];
2590             char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)];
2591             /*
2592              * Add new shared key for SCTP-Auth, will be ignored if no SCTP
2593              * used.
2594              */
2595             memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL,
2596                    sizeof(DTLS1_SCTP_AUTH_LABEL));
2597
2598             if (SSL_export_keying_material(s, sctpauthkey,
2599                                            sizeof(sctpauthkey), labelbuffer,
2600                                            sizeof(labelbuffer), NULL, 0,
2601                                            0) <= 0) {
2602                 ossl_statem_set_error(s);
2603                 return WORK_ERROR;;
2604             }
2605
2606             BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
2607                      sizeof(sctpauthkey), sctpauthkey);
2608         }
2609         wst = WORK_MORE_B;
2610     }
2611
2612     if ((wst == WORK_MORE_B)
2613         /* Is this SCTP? */
2614         && BIO_dgram_is_sctp(SSL_get_wbio(s))
2615         /* Are we renegotiating? */
2616         && s->renegotiate
2617         /* Are we going to skip the CertificateVerify? */
2618         && (s->session->peer == NULL || s->statem.no_cert_verify)
2619         && BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s))) {
2620         s->s3->in_read_app_data = 2;
2621         s->rwstate = SSL_READING;
2622         BIO_clear_retry_flags(SSL_get_rbio(s));
2623         BIO_set_retry_read(SSL_get_rbio(s));
2624         ossl_statem_set_sctp_read_sock(s, 1);
2625         return WORK_MORE_B;
2626     } else {
2627         ossl_statem_set_sctp_read_sock(s, 0);
2628     }
2629 #endif
2630
2631     if (s->statem.no_cert_verify || !s->session->peer) {
2632         /*
2633          * No certificate verify or no peer certificate so we no longer need
2634          * the handshake_buffer
2635          */
2636         if (!ssl3_digest_cached_records(s, 0)) {
2637             ossl_statem_set_error(s);
2638             return WORK_ERROR;
2639         }
2640         return WORK_FINISHED_CONTINUE;
2641     } else {
2642         if (!s->s3->handshake_buffer) {
2643             SSLerr(SSL_F_TLS_POST_PROCESS_CLIENT_KEY_EXCHANGE,
2644                    ERR_R_INTERNAL_ERROR);
2645             ossl_statem_set_error(s);
2646             return WORK_ERROR;
2647         }
2648         /*
2649          * For sigalgs freeze the handshake buffer. If we support
2650          * extms we've done this already so this is a no-op
2651          */
2652         if (!ssl3_digest_cached_records(s, 1)) {
2653             ossl_statem_set_error(s);
2654             return WORK_ERROR;
2655         }
2656     }
2657
2658     return WORK_FINISHED_CONTINUE;
2659 }
2660
2661 MSG_PROCESS_RETURN tls_process_cert_verify(SSL *s, PACKET *pkt)
2662 {
2663     EVP_PKEY *pkey = NULL;
2664     const unsigned char *sig, *data;
2665 #ifndef OPENSSL_NO_GOST
2666     unsigned char *gost_data = NULL;
2667 #endif
2668     int al, ret = MSG_PROCESS_ERROR;
2669     int type = 0, j;
2670     unsigned int len;
2671     X509 *peer;
2672     const EVP_MD *md = NULL;
2673     long hdatalen = 0;
2674     void *hdata;
2675
2676     EVP_MD_CTX *mctx = EVP_MD_CTX_new();
2677
2678     if (mctx == NULL) {
2679         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_MALLOC_FAILURE);
2680         al = SSL_AD_INTERNAL_ERROR;
2681         goto f_err;
2682     }
2683
2684     peer = s->session->peer;
2685     pkey = X509_get0_pubkey(peer);
2686     type = X509_certificate_type(peer, pkey);
2687
2688     if (!(type & EVP_PKT_SIGN)) {
2689         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY,
2690                SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE);
2691         al = SSL_AD_ILLEGAL_PARAMETER;
2692         goto f_err;
2693     }
2694
2695     /* Check for broken implementations of GOST ciphersuites */
2696     /*
2697      * If key is GOST and n is exactly 64, it is bare signature without
2698      * length field (CryptoPro implementations at least till CSP 4.0)
2699      */
2700 #ifndef OPENSSL_NO_GOST
2701     if (PACKET_remaining(pkt) == 64
2702         && EVP_PKEY_id(pkey) == NID_id_GostR3410_2001) {
2703         len = 64;
2704     } else
2705 #endif
2706     {
2707         if (SSL_USE_SIGALGS(s)) {
2708             int rv;
2709
2710             if (!PACKET_get_bytes(pkt, &sig, 2)) {
2711                 al = SSL_AD_DECODE_ERROR;
2712                 goto f_err;
2713             }
2714             rv = tls12_check_peer_sigalg(&md, s, sig, pkey);
2715             if (rv == -1) {
2716                 al = SSL_AD_INTERNAL_ERROR;
2717                 goto f_err;
2718             } else if (rv == 0) {
2719                 al = SSL_AD_DECODE_ERROR;
2720                 goto f_err;
2721             }
2722 #ifdef SSL_DEBUG
2723             fprintf(stderr, "USING TLSv1.2 HASH %s\n", EVP_MD_name(md));
2724 #endif
2725         } else {
2726             /* Use default digest for this key type */
2727             int idx = ssl_cert_type(NULL, pkey);
2728             if (idx >= 0)
2729                 md = s->s3->tmp.md[idx];
2730             if (md == NULL) {
2731                 al = SSL_AD_INTERNAL_ERROR;
2732                 goto f_err;
2733             }
2734         }
2735
2736         if (!PACKET_get_net_2(pkt, &len)) {
2737             SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_LENGTH_MISMATCH);
2738             al = SSL_AD_DECODE_ERROR;
2739             goto f_err;
2740         }
2741     }
2742     j = EVP_PKEY_size(pkey);
2743     if (((int)len > j) || ((int)PACKET_remaining(pkt) > j)
2744         || (PACKET_remaining(pkt) == 0)) {
2745         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_WRONG_SIGNATURE_SIZE);
2746         al = SSL_AD_DECODE_ERROR;
2747         goto f_err;
2748     }
2749     if (!PACKET_get_bytes(pkt, &data, len)) {
2750         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_LENGTH_MISMATCH);
2751         al = SSL_AD_DECODE_ERROR;
2752         goto f_err;
2753     }
2754
2755     hdatalen = BIO_get_mem_data(s->s3->handshake_buffer, &hdata);
2756     if (hdatalen <= 0) {
2757         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_INTERNAL_ERROR);
2758         al = SSL_AD_INTERNAL_ERROR;
2759         goto f_err;
2760     }
2761 #ifdef SSL_DEBUG
2762     fprintf(stderr, "Using client verify alg %s\n", EVP_MD_name(md));
2763 #endif
2764     if (!EVP_VerifyInit_ex(mctx, md, NULL)
2765         || !EVP_VerifyUpdate(mctx, hdata, hdatalen)) {
2766         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_EVP_LIB);
2767         al = SSL_AD_INTERNAL_ERROR;
2768         goto f_err;
2769     }
2770 #ifndef OPENSSL_NO_GOST
2771     {
2772         int pktype = EVP_PKEY_id(pkey);
2773         if (pktype == NID_id_GostR3410_2001
2774             || pktype == NID_id_GostR3410_2012_256
2775             || pktype == NID_id_GostR3410_2012_512) {
2776             if ((gost_data = OPENSSL_malloc(len)) == NULL) {
2777                 SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_MALLOC_FAILURE);
2778                 al = SSL_AD_INTERNAL_ERROR;
2779                 goto f_err;
2780             }
2781             BUF_reverse(gost_data, data, len);
2782             data = gost_data;
2783         }
2784     }
2785 #endif
2786
2787     if (s->version == SSL3_VERSION
2788         && !EVP_MD_CTX_ctrl(mctx, EVP_CTRL_SSL3_MASTER_SECRET,
2789                             (int)s->session->master_key_length,
2790                             s->session->master_key)) {
2791         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_EVP_LIB);
2792         al = SSL_AD_INTERNAL_ERROR;
2793         goto f_err;
2794     }
2795
2796     if (EVP_VerifyFinal(mctx, data, len, pkey) <= 0) {
2797         al = SSL_AD_DECRYPT_ERROR;
2798         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_BAD_SIGNATURE);
2799         goto f_err;
2800     }
2801
2802     ret = MSG_PROCESS_CONTINUE_PROCESSING;
2803     if (0) {
2804  f_err:
2805         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2806         ossl_statem_set_error(s);
2807     }
2808     BIO_free(s->s3->handshake_buffer);
2809     s->s3->handshake_buffer = NULL;
2810     EVP_MD_CTX_free(mctx);
2811 #ifndef OPENSSL_NO_GOST
2812     OPENSSL_free(gost_data);
2813 #endif
2814     return ret;
2815 }
2816
2817 MSG_PROCESS_RETURN tls_process_client_certificate(SSL *s, PACKET *pkt)
2818 {
2819     int i, al = SSL_AD_INTERNAL_ERROR, ret = MSG_PROCESS_ERROR;
2820     X509 *x = NULL;
2821     unsigned long l, llen;
2822     const unsigned char *certstart, *certbytes;
2823     STACK_OF(X509) *sk = NULL;
2824     PACKET spkt;
2825
2826     if ((sk = sk_X509_new_null()) == NULL) {
2827         SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, ERR_R_MALLOC_FAILURE);
2828         goto f_err;
2829     }
2830
2831     if (!PACKET_get_net_3(pkt, &llen)
2832         || !PACKET_get_sub_packet(pkt, &spkt, llen)
2833         || PACKET_remaining(pkt) != 0) {
2834         al = SSL_AD_DECODE_ERROR;
2835         SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, SSL_R_LENGTH_MISMATCH);
2836         goto f_err;
2837     }
2838
2839     while (PACKET_remaining(&spkt) > 0) {
2840         if (!PACKET_get_net_3(&spkt, &l)
2841             || !PACKET_get_bytes(&spkt, &certbytes, l)) {
2842             al = SSL_AD_DECODE_ERROR;
2843             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
2844                    SSL_R_CERT_LENGTH_MISMATCH);
2845             goto f_err;
2846         }
2847
2848         certstart = certbytes;
2849         x = d2i_X509(NULL, (const unsigned char **)&certbytes, l);
2850         if (x == NULL) {
2851             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, ERR_R_ASN1_LIB);
2852             goto f_err;
2853         }
2854         if (certbytes != (certstart + l)) {
2855             al = SSL_AD_DECODE_ERROR;
2856             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
2857                    SSL_R_CERT_LENGTH_MISMATCH);
2858             goto f_err;
2859         }
2860         if (!sk_X509_push(sk, x)) {
2861             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, ERR_R_MALLOC_FAILURE);
2862             goto f_err;
2863         }
2864         x = NULL;
2865     }
2866
2867     if (sk_X509_num(sk) <= 0) {
2868         /* TLS does not mind 0 certs returned */
2869         if (s->version == SSL3_VERSION) {
2870             al = SSL_AD_HANDSHAKE_FAILURE;
2871             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
2872                    SSL_R_NO_CERTIFICATES_RETURNED);
2873             goto f_err;
2874         }
2875         /* Fail for TLS only if we required a certificate */
2876         else if ((s->verify_mode & SSL_VERIFY_PEER) &&
2877                  (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) {
2878             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
2879                    SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
2880             al = SSL_AD_HANDSHAKE_FAILURE;
2881             goto f_err;
2882         }
2883         /* No client certificate so digest cached records */
2884         if (s->s3->handshake_buffer && !ssl3_digest_cached_records(s, 0)) {
2885             goto f_err;
2886         }
2887     } else {
2888         EVP_PKEY *pkey;
2889         i = ssl_verify_cert_chain(s, sk);
2890         if (i <= 0) {
2891             al = ssl_verify_alarm_type(s->verify_result);
2892             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
2893                    SSL_R_CERTIFICATE_VERIFY_FAILED);
2894             goto f_err;
2895         }
2896         if (i > 1) {
2897             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, i);
2898             al = SSL_AD_HANDSHAKE_FAILURE;
2899             goto f_err;
2900         }
2901         pkey = X509_get0_pubkey(sk_X509_value(sk, 0));
2902         if (pkey == NULL) {
2903             al = SSL3_AD_HANDSHAKE_FAILURE;
2904             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
2905                    SSL_R_UNKNOWN_CERTIFICATE_TYPE);
2906             goto f_err;
2907         }
2908     }
2909
2910     X509_free(s->session->peer);
2911     s->session->peer = sk_X509_shift(sk);
2912     s->session->verify_result = s->verify_result;
2913
2914     sk_X509_pop_free(s->session->peer_chain, X509_free);
2915     s->session->peer_chain = sk;
2916     /*
2917      * Inconsistency alert: cert_chain does *not* include the peer's own
2918      * certificate, while we do include it in statem_clnt.c
2919      */
2920     sk = NULL;
2921     ret = MSG_PROCESS_CONTINUE_READING;
2922     goto done;
2923
2924  f_err:
2925     ssl3_send_alert(s, SSL3_AL_FATAL, al);
2926     ossl_statem_set_error(s);
2927  done:
2928     X509_free(x);
2929     sk_X509_pop_free(sk, X509_free);
2930     return ret;
2931 }
2932
2933 int tls_construct_server_certificate(SSL *s, WPACKET *pkt)
2934 {
2935     CERT_PKEY *cpk;
2936
2937     cpk = ssl_get_server_send_pkey(s);
2938     if (cpk == NULL) {
2939         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_CERTIFICATE, ERR_R_INTERNAL_ERROR);
2940         return 0;
2941     }
2942
2943     if (!ssl3_output_cert_chain(s, pkt, cpk)) {
2944         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_CERTIFICATE, ERR_R_INTERNAL_ERROR);
2945         return 0;
2946     }
2947
2948     return 1;
2949 }
2950
2951 int tls_construct_new_session_ticket(SSL *s, WPACKET *pkt)
2952 {
2953     unsigned char *senc = NULL;
2954     EVP_CIPHER_CTX *ctx = NULL;
2955     HMAC_CTX *hctx = NULL;
2956     unsigned char *p, *encdata1, *encdata2, *macdata1, *macdata2;
2957     const unsigned char *const_p;
2958     int len, slen_full, slen, lenfinal;
2959     SSL_SESSION *sess;
2960     unsigned int hlen;
2961     SSL_CTX *tctx = s->initial_ctx;
2962     unsigned char iv[EVP_MAX_IV_LENGTH];
2963     unsigned char key_name[TLSEXT_KEYNAME_LENGTH];
2964     int iv_len;
2965     size_t macoffset, macendoffset;
2966
2967     /* get session encoding length */
2968     slen_full = i2d_SSL_SESSION(s->session, NULL);
2969     /*
2970      * Some length values are 16 bits, so forget it if session is too
2971      * long
2972      */
2973     if (slen_full == 0 || slen_full > 0xFF00) {
2974         ossl_statem_set_error(s);
2975         return 0;
2976     }
2977     senc = OPENSSL_malloc(slen_full);
2978     if (senc == NULL) {
2979         ossl_statem_set_error(s);
2980         return 0;
2981     }
2982
2983     ctx = EVP_CIPHER_CTX_new();
2984     hctx = HMAC_CTX_new();
2985     if (ctx == NULL || hctx == NULL) {
2986         SSLerr(SSL_F_TLS_CONSTRUCT_NEW_SESSION_TICKET, ERR_R_MALLOC_FAILURE);
2987         goto err;
2988     }
2989
2990     p = senc;
2991     if (!i2d_SSL_SESSION(s->session, &p))
2992         goto err;
2993
2994     /*
2995      * create a fresh copy (not shared with other threads) to clean up
2996      */
2997     const_p = senc;
2998     sess = d2i_SSL_SESSION(NULL, &const_p, slen_full);
2999     if (sess == NULL)
3000         goto err;
3001     sess->session_id_length = 0; /* ID is irrelevant for the ticket */
3002
3003     slen = i2d_SSL_SESSION(sess, NULL);
3004     if (slen == 0 || slen > slen_full) { /* shouldn't ever happen */
3005         SSL_SESSION_free(sess);
3006         goto err;
3007     }
3008     p = senc;
3009     if (!i2d_SSL_SESSION(sess, &p)) {
3010         SSL_SESSION_free(sess);
3011         goto err;
3012     }
3013     SSL_SESSION_free(sess);
3014
3015     /*
3016      * Initialize HMAC and cipher contexts. If callback present it does
3017      * all the work otherwise use generated values from parent ctx.
3018      */
3019     if (tctx->tlsext_ticket_key_cb) {
3020         /* if 0 is returned, write an empty ticket */
3021         int ret = tctx->tlsext_ticket_key_cb(s, key_name, iv, ctx,
3022                                              hctx, 1);
3023
3024         if (ret == 0) {
3025
3026             /* Put timeout and length */
3027             if (!WPACKET_put_bytes_u32(pkt, 0)
3028                     || !WPACKET_put_bytes_u16(pkt, 0)) {
3029                 SSLerr(SSL_F_TLS_CONSTRUCT_NEW_SESSION_TICKET,
3030                        ERR_R_INTERNAL_ERROR);
3031                 goto err;
3032             }
3033             OPENSSL_free(senc);
3034             EVP_CIPHER_CTX_free(ctx);
3035             HMAC_CTX_free(hctx);
3036             return 1;
3037         }
3038         if (ret < 0)
3039             goto err;
3040         iv_len = EVP_CIPHER_CTX_iv_length(ctx);
3041     } else {
3042         const EVP_CIPHER *cipher = EVP_aes_256_cbc();
3043
3044         iv_len = EVP_CIPHER_iv_length(cipher);
3045         if (RAND_bytes(iv, iv_len) <= 0)
3046             goto err;
3047         if (!EVP_EncryptInit_ex(ctx, cipher, NULL,
3048                                 tctx->tlsext_tick_aes_key, iv))
3049             goto err;
3050         if (!HMAC_Init_ex(hctx, tctx->tlsext_tick_hmac_key,
3051                           sizeof(tctx->tlsext_tick_hmac_key),
3052                           EVP_sha256(), NULL))
3053             goto err;
3054         memcpy(key_name, tctx->tlsext_tick_key_name,
3055                sizeof(tctx->tlsext_tick_key_name));
3056     }
3057
3058     /*
3059      * Ticket lifetime hint (advisory only): We leave this unspecified
3060      * for resumed session (for simplicity), and guess that tickets for
3061      * new sessions will live as long as their sessions.
3062      */
3063     if (!WPACKET_put_bytes_u32(pkt, s->hit ? 0 : s->session->timeout)
3064                /* Now the actual ticket data */
3065             || !WPACKET_start_sub_packet_u16(pkt)
3066             || !WPACKET_get_total_written(pkt, &macoffset)
3067                /* Output key name */
3068             || !WPACKET_memcpy(pkt, key_name, sizeof(key_name))
3069                /* output IV */
3070             || !WPACKET_memcpy(pkt, iv, iv_len)
3071             || !WPACKET_reserve_bytes(pkt, slen + EVP_MAX_BLOCK_LENGTH,
3072                                       &encdata1)
3073                /* Encrypt session data */
3074             || !EVP_EncryptUpdate(ctx, encdata1, &len, senc, slen)
3075             || !WPACKET_allocate_bytes(pkt, len, &encdata2)
3076             || encdata1 != encdata2
3077             || !EVP_EncryptFinal(ctx, encdata1 + len, &lenfinal)
3078             || !WPACKET_allocate_bytes(pkt, lenfinal, &encdata2)
3079             || encdata1 + len != encdata2
3080             || len + lenfinal > slen + EVP_MAX_BLOCK_LENGTH
3081             || !WPACKET_get_total_written(pkt, &macendoffset)
3082             || !HMAC_Update(hctx,
3083                             (unsigned char *)s->init_buf->data + macoffset,
3084                             macendoffset - macoffset)
3085             || !WPACKET_reserve_bytes(pkt, EVP_MAX_MD_SIZE, &macdata1)
3086             || !HMAC_Final(hctx, macdata1, &hlen)
3087             || hlen > EVP_MAX_MD_SIZE
3088             || !WPACKET_allocate_bytes(pkt, hlen, &macdata2)
3089             || macdata1 != macdata2
3090             || !WPACKET_close(pkt)) {
3091         SSLerr(SSL_F_TLS_CONSTRUCT_NEW_SESSION_TICKET, ERR_R_INTERNAL_ERROR);
3092         goto err;
3093     }
3094     EVP_CIPHER_CTX_free(ctx);
3095     HMAC_CTX_free(hctx);
3096     OPENSSL_free(senc);
3097
3098     return 1;
3099  err:
3100     OPENSSL_free(senc);
3101     EVP_CIPHER_CTX_free(ctx);
3102     HMAC_CTX_free(hctx);
3103     ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
3104     return 0;
3105 }
3106
3107 int tls_construct_cert_status(SSL *s, WPACKET *pkt)
3108 {
3109     if (!WPACKET_put_bytes_u8(pkt, s->tlsext_status_type)
3110             || !WPACKET_sub_memcpy_u24(pkt, s->tlsext_ocsp_resp,
3111                                        s->tlsext_ocsp_resplen)) {
3112         SSLerr(SSL_F_TLS_CONSTRUCT_CERT_STATUS, ERR_R_INTERNAL_ERROR);
3113         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
3114         return 0;
3115     }
3116
3117     return 1;
3118 }
3119
3120 #ifndef OPENSSL_NO_NEXTPROTONEG
3121 /*
3122  * tls_process_next_proto reads a Next Protocol Negotiation handshake message.
3123  * It sets the next_proto member in s if found
3124  */
3125 MSG_PROCESS_RETURN tls_process_next_proto(SSL *s, PACKET *pkt)
3126 {
3127     PACKET next_proto, padding;
3128     size_t next_proto_len;
3129
3130     /*-
3131      * The payload looks like:
3132      *   uint8 proto_len;
3133      *   uint8 proto[proto_len];
3134      *   uint8 padding_len;
3135      *   uint8 padding[padding_len];
3136      */
3137     if (!PACKET_get_length_prefixed_1(pkt, &next_proto)
3138         || !PACKET_get_length_prefixed_1(pkt, &padding)
3139         || PACKET_remaining(pkt) > 0) {
3140         SSLerr(SSL_F_TLS_PROCESS_NEXT_PROTO, SSL_R_LENGTH_MISMATCH);
3141         goto err;
3142     }
3143
3144     if (!PACKET_memdup(&next_proto, &s->next_proto_negotiated, &next_proto_len)) {
3145         s->next_proto_negotiated_len = 0;
3146         goto err;
3147     }
3148
3149     s->next_proto_negotiated_len = (unsigned char)next_proto_len;
3150
3151     return MSG_PROCESS_CONTINUE_READING;
3152  err:
3153     ossl_statem_set_error(s);
3154     return MSG_PROCESS_ERROR;
3155 }
3156 #endif
3157
3158 #define SSLV2_CIPHER_LEN    3
3159
3160 STACK_OF(SSL_CIPHER) *ssl_bytes_to_cipher_list(SSL *s,
3161                                                PACKET *cipher_suites,
3162                                                STACK_OF(SSL_CIPHER) **skp,
3163                                                int sslv2format, int *al)
3164 {
3165     const SSL_CIPHER *c;
3166     STACK_OF(SSL_CIPHER) *sk;
3167     int n;
3168     /* 3 = SSLV2_CIPHER_LEN > TLS_CIPHER_LEN = 2. */
3169     unsigned char cipher[SSLV2_CIPHER_LEN];
3170
3171     s->s3->send_connection_binding = 0;
3172
3173     n = sslv2format ? SSLV2_CIPHER_LEN : TLS_CIPHER_LEN;
3174
3175     if (PACKET_remaining(cipher_suites) == 0) {
3176         SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST, SSL_R_NO_CIPHERS_SPECIFIED);
3177         *al = SSL_AD_ILLEGAL_PARAMETER;
3178         return NULL;
3179     }
3180
3181     if (PACKET_remaining(cipher_suites) % n != 0) {
3182         SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST,
3183                SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST);
3184         *al = SSL_AD_DECODE_ERROR;
3185         return NULL;
3186     }
3187
3188     if ((skp == NULL) || (*skp == NULL)) {
3189         sk = sk_SSL_CIPHER_new_null(); /* change perhaps later */
3190         if (sk == NULL) {
3191             SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST, ERR_R_MALLOC_FAILURE);
3192             *al = SSL_AD_INTERNAL_ERROR;
3193             return NULL;
3194         }
3195     } else {
3196         sk = *skp;
3197         sk_SSL_CIPHER_zero(sk);
3198     }
3199
3200     if (!PACKET_memdup(cipher_suites, &s->s3->tmp.ciphers_raw,
3201                        &s->s3->tmp.ciphers_rawlen)) {
3202         *al = SSL_AD_INTERNAL_ERROR;
3203         goto err;
3204     }
3205
3206     while (PACKET_copy_bytes(cipher_suites, cipher, n)) {
3207         /*
3208          * SSLv3 ciphers wrapped in an SSLv2-compatible ClientHello have the
3209          * first byte set to zero, while true SSLv2 ciphers have a non-zero
3210          * first byte. We don't support any true SSLv2 ciphers, so skip them.
3211          */
3212         if (sslv2format && cipher[0] != '\0')
3213             continue;
3214
3215         /* Check for TLS_EMPTY_RENEGOTIATION_INFO_SCSV */
3216         if ((cipher[n - 2] == ((SSL3_CK_SCSV >> 8) & 0xff)) &&
3217             (cipher[n - 1] == (SSL3_CK_SCSV & 0xff))) {
3218             /* SCSV fatal if renegotiating */
3219             if (s->renegotiate) {
3220                 SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST,
3221                        SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING);
3222                 *al = SSL_AD_HANDSHAKE_FAILURE;
3223                 goto err;
3224             }
3225             s->s3->send_connection_binding = 1;
3226             continue;
3227         }
3228
3229         /* Check for TLS_FALLBACK_SCSV */
3230         if ((cipher[n - 2] == ((SSL3_CK_FALLBACK_SCSV >> 8) & 0xff)) &&
3231             (cipher[n - 1] == (SSL3_CK_FALLBACK_SCSV & 0xff))) {
3232             /*
3233              * The SCSV indicates that the client previously tried a higher
3234              * version. Fail if the current version is an unexpected
3235              * downgrade.
3236              */
3237             if (!ssl_check_version_downgrade(s)) {
3238                 SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST,
3239                        SSL_R_INAPPROPRIATE_FALLBACK);
3240                 *al = SSL_AD_INAPPROPRIATE_FALLBACK;
3241                 goto err;
3242             }
3243             continue;
3244         }
3245
3246         /* For SSLv2-compat, ignore leading 0-byte. */
3247         c = ssl_get_cipher_by_char(s, sslv2format ? &cipher[1] : cipher);
3248         if (c != NULL) {
3249             if (!sk_SSL_CIPHER_push(sk, c)) {
3250                 SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST, ERR_R_MALLOC_FAILURE);
3251                 *al = SSL_AD_INTERNAL_ERROR;
3252                 goto err;
3253             }
3254         }
3255     }
3256     if (PACKET_remaining(cipher_suites) > 0) {
3257         *al = SSL_AD_INTERNAL_ERROR;
3258         SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST, ERR_R_INTERNAL_ERROR);
3259         goto err;
3260     }
3261
3262     if (skp != NULL)
3263         *skp = sk;
3264     return (sk);
3265  err:
3266     if ((skp == NULL) || (*skp == NULL))
3267         sk_SSL_CIPHER_free(sk);
3268     return NULL;
3269 }