ssl/statem/statem_srvr.c

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