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