ssl/statem/statem_clnt.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 <time.h>
  52 #include "../ssl_locl.h"
  53 #include "statem_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/md5.h>
  59 #include <openssl/dh.h>
  60 #include <openssl/bn.h>
  61 #include <openssl/engine.h>
  62
  63 static MSG_PROCESS_RETURN tls_process_hello_retry_request(SSL *s, PACKET *pkt);
  64 static MSG_PROCESS_RETURN tls_process_encrypted_extensions(SSL *s, PACKET *pkt);
  65
  66 static ossl_inline int cert_req_allowed(SSL *s);
  67 static int key_exchange_expected(SSL *s);
  68 static int ssl_cipher_list_to_bytes(SSL *s, STACK_OF(SSL_CIPHER) *sk,
  69                                     WPACKET *pkt);
  70
  71 /*
  72  * Is a CertificateRequest message allowed at the moment or not?
  73  *
  74  *  Return values are:
  75  *  1: Yes
  76  *  0: No
  77  */
  78 static ossl_inline int cert_req_allowed(SSL *s)
  79 {
  80     /* TLS does not like anon-DH with client cert */
  81     if ((s->version > SSL3_VERSION
  82          && (s->s3->tmp.new_cipher->algorithm_auth & SSL_aNULL))
  83         || (s->s3->tmp.new_cipher->algorithm_auth & (SSL_aSRP | SSL_aPSK)))
  84         return 0;
  85
  86     return 1;
  87 }
  88
  89 /*
  90  * Should we expect the ServerKeyExchange message or not?
  91  *
  92  *  Return values are:
  93  *  1: Yes
  94  *  0: No
  95  */
  96 static int key_exchange_expected(SSL *s)
  97 {
  98     long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
  99
 100     /*
 101      * Can't skip server key exchange if this is an ephemeral
 102      * ciphersuite or for SRP
 103      */
 104     if (alg_k & (SSL_kDHE | SSL_kECDHE | SSL_kDHEPSK | SSL_kECDHEPSK
 105                  | SSL_kSRP)) {
 106         return 1;
 107     }
 108
 109     return 0;
 110 }
 111
 112 /*
 113  * ossl_statem_client_read_transition() encapsulates the logic for the allowed
 114  * handshake state transitions when a TLS1.3 client is reading messages from the
 115  * server. The message type that the server has sent is provided in |mt|. The
 116  * current state is in |s->statem.hand_state|.
 117  *
 118  * Return values are 1 for success (transition allowed) and  0 on error
 119  * (transition not allowed)
 120  */
 121 static int ossl_statem_client13_read_transition(SSL *s, int mt)
 122 {
 123     OSSL_STATEM *st = &s->statem;
 124
 125     /*
 126      * Note: There is no case for TLS_ST_CW_CLNT_HELLO, because we haven't
 127      * yet negotiated TLSv1.3 at that point so that is handled by
 128      * ossl_statem_client_read_transition()
 129      */
 130
 131     switch (st->hand_state) {
 132     default:
 133         break;
 134
 135     case TLS_ST_CW_CLNT_HELLO:
 136         /*
 137          * This must a ClientHello following a HelloRetryRequest, so the only
 138          * thing we can get now is a ServerHello.
 139          */
 140         if (mt == SSL3_MT_SERVER_HELLO) {
 141             st->hand_state = TLS_ST_CR_SRVR_HELLO;
 142             return 1;
 143         }
 144         break;
 145
 146     case TLS_ST_CR_SRVR_HELLO:
 147         if (mt == SSL3_MT_ENCRYPTED_EXTENSIONS) {
 148             st->hand_state = TLS_ST_CR_ENCRYPTED_EXTENSIONS;
 149             return 1;
 150         }
 151         break;
 152
 153     case TLS_ST_CR_ENCRYPTED_EXTENSIONS:
 154         if (s->hit) {
 155             if (mt == SSL3_MT_FINISHED) {
 156                 st->hand_state = TLS_ST_CR_FINISHED;
 157                 return 1;
 158             }
 159         } else {
 160             if (mt == SSL3_MT_CERTIFICATE_REQUEST) {
 161                 st->hand_state = TLS_ST_CR_CERT_REQ;
 162                 return 1;
 163             }
 164             if (mt == SSL3_MT_CERTIFICATE) {
 165                 st->hand_state = TLS_ST_CR_CERT;
 166                 return 1;
 167             }
 168         }
 169         break;
 170
 171     case TLS_ST_CR_CERT_REQ:
 172         if (mt == SSL3_MT_CERTIFICATE) {
 173             st->hand_state = TLS_ST_CR_CERT;
 174             return 1;
 175         }
 176         break;
 177
 178     case TLS_ST_CR_CERT:
 179         if (mt == SSL3_MT_CERTIFICATE_VERIFY) {
 180             st->hand_state = TLS_ST_CR_CERT_VRFY;
 181             return 1;
 182         }
 183         break;
 184
 185     case TLS_ST_CR_CERT_VRFY:
 186         if (mt == SSL3_MT_FINISHED) {
 187             st->hand_state = TLS_ST_CR_FINISHED;
 188             return 1;
 189         }
 190         break;
 191
 192     case TLS_ST_OK:
 193         if (mt == SSL3_MT_NEWSESSION_TICKET) {
 194             st->hand_state = TLS_ST_CR_SESSION_TICKET;
 195             return 1;
 196         }
 197         if (mt == SSL3_MT_KEY_UPDATE) {
 198             st->hand_state = TLS_ST_CR_KEY_UPDATE;
 199             return 1;
 200         }
 201         break;
 202     }
 203
 204     /* No valid transition found */
 205     return 0;
 206 }
 207
 208 /*
 209  * ossl_statem_client_read_transition() encapsulates the logic for the allowed
 210  * handshake state transitions when the client is reading messages from the
 211  * server. The message type that the server has sent is provided in |mt|. The
 212  * current state is in |s->statem.hand_state|.
 213  *
 214  * Return values are 1 for success (transition allowed) and  0 on error
 215  * (transition not allowed)
 216  */
 217 int ossl_statem_client_read_transition(SSL *s, int mt)
 218 {
 219     OSSL_STATEM *st = &s->statem;
 220     int ske_expected;
 221
 222     /*
 223      * Note that after writing the first ClientHello we don't know what version
 224      * we are going to negotiate yet, so we don't take this branch until later.
 225      */
 226     if (SSL_IS_TLS13(s)) {
 227         if (!ossl_statem_client13_read_transition(s, mt))
 228             goto err;
 229         return 1;
 230     }
 231
 232     switch (st->hand_state) {
 233     default:
 234         break;
 235
 236     case TLS_ST_CW_CLNT_HELLO:
 237         if (mt == SSL3_MT_SERVER_HELLO) {
 238             st->hand_state = TLS_ST_CR_SRVR_HELLO;
 239             return 1;
 240         }
 241
 242         if (SSL_IS_DTLS(s)) {
 243             if (mt == DTLS1_MT_HELLO_VERIFY_REQUEST) {
 244                 st->hand_state = DTLS_ST_CR_HELLO_VERIFY_REQUEST;
 245                 return 1;
 246             }
 247         } else {
 248             if (mt == SSL3_MT_HELLO_RETRY_REQUEST) {
 249                 st->hand_state = TLS_ST_CR_HELLO_RETRY_REQUEST;
 250                 return 1;
 251             }
 252         }
 253         break;
 254
 255     case TLS_ST_EARLY_DATA:
 256         /*
 257          * We've not actually selected TLSv1.3 yet, but we have sent early
 258          * data. The only thing allowed now is a ServerHello or a
 259          * HelloRetryRequest.
 260          */
 261         if (mt == SSL3_MT_SERVER_HELLO) {
 262             st->hand_state = TLS_ST_CR_SRVR_HELLO;
 263             return 1;
 264         }
 265         if (mt == SSL3_MT_HELLO_RETRY_REQUEST) {
 266             st->hand_state = TLS_ST_CR_HELLO_RETRY_REQUEST;
 267             return 1;
 268         }
 269         break;
 270
 271     case TLS_ST_CR_SRVR_HELLO:
 272         if (s->hit) {
 273             if (s->ext.ticket_expected) {
 274                 if (mt == SSL3_MT_NEWSESSION_TICKET) {
 275                     st->hand_state = TLS_ST_CR_SESSION_TICKET;
 276                     return 1;
 277                 }
 278             } else if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
 279                 st->hand_state = TLS_ST_CR_CHANGE;
 280                 return 1;
 281             }
 282         } else {
 283             if (SSL_IS_DTLS(s) && mt == DTLS1_MT_HELLO_VERIFY_REQUEST) {
 284                 st->hand_state = DTLS_ST_CR_HELLO_VERIFY_REQUEST;
 285                 return 1;
 286             } else if (s->version >= TLS1_VERSION
 287                        && s->ext.session_secret_cb != NULL
 288                        && s->session->ext.tick != NULL
 289                        && mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
 290                 /*
 291                  * Normally, we can tell if the server is resuming the session
 292                  * from the session ID. EAP-FAST (RFC 4851), however, relies on
 293                  * the next server message after the ServerHello to determine if
 294                  * the server is resuming.
 295                  */
 296                 s->hit = 1;
 297                 st->hand_state = TLS_ST_CR_CHANGE;
 298                 return 1;
 299             } else if (!(s->s3->tmp.new_cipher->algorithm_auth
 300                          & (SSL_aNULL | SSL_aSRP | SSL_aPSK))) {
 301                 if (mt == SSL3_MT_CERTIFICATE) {
 302                     st->hand_state = TLS_ST_CR_CERT;
 303                     return 1;
 304                 }
 305             } else {
 306                 ske_expected = key_exchange_expected(s);
 307                 /* SKE is optional for some PSK ciphersuites */
 308                 if (ske_expected
 309                     || ((s->s3->tmp.new_cipher->algorithm_mkey & SSL_PSK)
 310                         && mt == SSL3_MT_SERVER_KEY_EXCHANGE)) {
 311                     if (mt == SSL3_MT_SERVER_KEY_EXCHANGE) {
 312                         st->hand_state = TLS_ST_CR_KEY_EXCH;
 313                         return 1;
 314                     }
 315                 } else if (mt == SSL3_MT_CERTIFICATE_REQUEST
 316                            && cert_req_allowed(s)) {
 317                     st->hand_state = TLS_ST_CR_CERT_REQ;
 318                     return 1;
 319                 } else if (mt == SSL3_MT_SERVER_DONE) {
 320                     st->hand_state = TLS_ST_CR_SRVR_DONE;
 321                     return 1;
 322                 }
 323             }
 324         }
 325         break;
 326
 327     case TLS_ST_CR_CERT:
 328         /*
 329          * The CertificateStatus message is optional even if
 330          * |ext.status_expected| is set
 331          */
 332         if (s->ext.status_expected && mt == SSL3_MT_CERTIFICATE_STATUS) {
 333             st->hand_state = TLS_ST_CR_CERT_STATUS;
 334             return 1;
 335         }
 336         /* Fall through */
 337
 338     case TLS_ST_CR_CERT_STATUS:
 339         ske_expected = key_exchange_expected(s);
 340         /* SKE is optional for some PSK ciphersuites */
 341         if (ske_expected || ((s->s3->tmp.new_cipher->algorithm_mkey & SSL_PSK)
 342                              && mt == SSL3_MT_SERVER_KEY_EXCHANGE)) {
 343             if (mt == SSL3_MT_SERVER_KEY_EXCHANGE) {
 344                 st->hand_state = TLS_ST_CR_KEY_EXCH;
 345                 return 1;
 346             }
 347             goto err;
 348         }
 349         /* Fall through */
 350
 351     case TLS_ST_CR_KEY_EXCH:
 352         if (mt == SSL3_MT_CERTIFICATE_REQUEST) {
 353             if (cert_req_allowed(s)) {
 354                 st->hand_state = TLS_ST_CR_CERT_REQ;
 355                 return 1;
 356             }
 357             goto err;
 358         }
 359         /* Fall through */
 360
 361     case TLS_ST_CR_CERT_REQ:
 362         if (mt == SSL3_MT_SERVER_DONE) {
 363             st->hand_state = TLS_ST_CR_SRVR_DONE;
 364             return 1;
 365         }
 366         break;
 367
 368     case TLS_ST_CW_FINISHED:
 369         if (s->ext.ticket_expected) {
 370             if (mt == SSL3_MT_NEWSESSION_TICKET) {
 371                 st->hand_state = TLS_ST_CR_SESSION_TICKET;
 372                 return 1;
 373             }
 374         } else if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
 375             st->hand_state = TLS_ST_CR_CHANGE;
 376             return 1;
 377         }
 378         break;
 379
 380     case TLS_ST_CR_SESSION_TICKET:
 381         if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
 382             st->hand_state = TLS_ST_CR_CHANGE;
 383             return 1;
 384         }
 385         break;
 386
 387     case TLS_ST_CR_CHANGE:
 388         if (mt == SSL3_MT_FINISHED) {
 389             st->hand_state = TLS_ST_CR_FINISHED;
 390             return 1;
 391         }
 392         break;
 393
 394     case TLS_ST_OK:
 395         if (mt == SSL3_MT_HELLO_REQUEST) {
 396             st->hand_state = TLS_ST_CR_HELLO_REQ;
 397             return 1;
 398         }
 399         break;
 400     }
 401
 402  err:
 403     /* No valid transition found */
 404     ssl3_send_alert(s, SSL3_AL_FATAL, SSL3_AD_UNEXPECTED_MESSAGE);
 405     SSLerr(SSL_F_OSSL_STATEM_CLIENT_READ_TRANSITION, SSL_R_UNEXPECTED_MESSAGE);
 406     return 0;
 407 }
 408
 409 /*
 410  * ossl_statem_client13_write_transition() works out what handshake state to
 411  * move to next when the TLSv1.3 client is writing messages to be sent to the
 412  * server.
 413  */
 414 static WRITE_TRAN ossl_statem_client13_write_transition(SSL *s)
 415 {
 416     OSSL_STATEM *st = &s->statem;
 417
 418     /*
 419      * Note: There are no cases for TLS_ST_BEFORE because we haven't negotiated
 420      * TLSv1.3 yet at that point. They are handled by
 421      * ossl_statem_client_write_transition().
 422      */
 423     switch (st->hand_state) {
 424     default:
 425         /* Shouldn't happen */
 426         return WRITE_TRAN_ERROR;
 427
 428     case TLS_ST_CW_CLNT_HELLO:
 429         /* We only hit this in the case of HelloRetryRequest */
 430         return WRITE_TRAN_FINISHED;
 431
 432     case TLS_ST_CR_HELLO_RETRY_REQUEST:
 433         st->hand_state = TLS_ST_CW_CLNT_HELLO;
 434         return WRITE_TRAN_CONTINUE;
 435
 436     case TLS_ST_CR_FINISHED:
 437         if (s->early_data_state == SSL_EARLY_DATA_WRITE_RETRY
 438                 || s->early_data_state == SSL_EARLY_DATA_FINISHED_WRITING)
 439             st->hand_state = TLS_ST_PENDING_EARLY_DATA_END;
 440         else
 441             st->hand_state = (s->s3->tmp.cert_req != 0) ? TLS_ST_CW_CERT
 442                                                         : TLS_ST_CW_FINISHED;
 443         return WRITE_TRAN_CONTINUE;
 444
 445     case TLS_ST_PENDING_EARLY_DATA_END:
 446         if (s->ext.early_data == SSL_EARLY_DATA_ACCEPTED) {
 447             st->hand_state = TLS_ST_CW_END_OF_EARLY_DATA;
 448             return WRITE_TRAN_CONTINUE;
 449         }
 450         /* Fall through */
 451
 452     case TLS_ST_CW_END_OF_EARLY_DATA:
 453         st->hand_state = (s->s3->tmp.cert_req != 0) ? TLS_ST_CW_CERT
 454                                                     : TLS_ST_CW_FINISHED;
 455         return WRITE_TRAN_CONTINUE;
 456
 457     case TLS_ST_CW_CERT:
 458         /* If a non-empty Certificate we also send CertificateVerify */
 459         st->hand_state = (s->s3->tmp.cert_req == 1) ? TLS_ST_CW_CERT_VRFY
 460                                                     : TLS_ST_CW_FINISHED;
 461         return WRITE_TRAN_CONTINUE;
 462
 463     case TLS_ST_CW_CERT_VRFY:
 464         st->hand_state = TLS_ST_CW_FINISHED;
 465         return WRITE_TRAN_CONTINUE;
 466
 467     case TLS_ST_CR_KEY_UPDATE:
 468         if (s->key_update != SSL_KEY_UPDATE_NONE) {
 469             st->hand_state = TLS_ST_CW_KEY_UPDATE;
 470             return WRITE_TRAN_CONTINUE;
 471         }
 472         /* Fall through */
 473
 474     case TLS_ST_CW_KEY_UPDATE:
 475     case TLS_ST_CR_SESSION_TICKET:
 476     case TLS_ST_CW_FINISHED:
 477         st->hand_state = TLS_ST_OK;
 478         return WRITE_TRAN_CONTINUE;
 479
 480     case TLS_ST_OK:
 481         if (s->key_update != SSL_KEY_UPDATE_NONE) {
 482             st->hand_state = TLS_ST_CW_KEY_UPDATE;
 483             return WRITE_TRAN_CONTINUE;
 484         }
 485
 486         /* Try to read from the server instead */
 487         return WRITE_TRAN_FINISHED;
 488     }
 489 }
 490
 491 /*
 492  * ossl_statem_client_write_transition() works out what handshake state to
 493  * move to next when the client is writing messages to be sent to the server.
 494  */
 495 WRITE_TRAN ossl_statem_client_write_transition(SSL *s)
 496 {
 497     OSSL_STATEM *st = &s->statem;
 498
 499     /*
 500      * Note that immediately before/after a ClientHello we don't know what
 501      * version we are going to negotiate yet, so we don't take this branch until
 502      * later
 503      */
 504     if (SSL_IS_TLS13(s))
 505         return ossl_statem_client13_write_transition(s);
 506
 507     switch (st->hand_state) {
 508     default:
 509         /* Shouldn't happen */
 510         return WRITE_TRAN_ERROR;
 511
 512     case TLS_ST_OK:
 513         if (!s->renegotiate) {
 514             /*
 515              * We haven't requested a renegotiation ourselves so we must have
 516              * received a message from the server. Better read it.
 517              */
 518             return WRITE_TRAN_FINISHED;
 519         }
 520         /* Renegotiation - fall through */
 521     case TLS_ST_BEFORE:
 522         st->hand_state = TLS_ST_CW_CLNT_HELLO;
 523         return WRITE_TRAN_CONTINUE;
 524
 525     case TLS_ST_CW_CLNT_HELLO:
 526         if (s->early_data_state == SSL_EARLY_DATA_CONNECTING) {
 527             /*
 528              * We are assuming this is a TLSv1.3 connection, although we haven't
 529              * actually selected a version yet.
 530              */
 531             st->hand_state = TLS_ST_EARLY_DATA;
 532             return WRITE_TRAN_CONTINUE;
 533         }
 534         /*
 535          * No transition at the end of writing because we don't know what
 536          * we will be sent
 537          */
 538         return WRITE_TRAN_FINISHED;
 539
 540     case TLS_ST_EARLY_DATA:
 541         return WRITE_TRAN_FINISHED;
 542
 543     case DTLS_ST_CR_HELLO_VERIFY_REQUEST:
 544         st->hand_state = TLS_ST_CW_CLNT_HELLO;
 545         return WRITE_TRAN_CONTINUE;
 546
 547     case TLS_ST_CR_SRVR_DONE:
 548         if (s->s3->tmp.cert_req)
 549             st->hand_state = TLS_ST_CW_CERT;
 550         else
 551             st->hand_state = TLS_ST_CW_KEY_EXCH;
 552         return WRITE_TRAN_CONTINUE;
 553
 554     case TLS_ST_CW_CERT:
 555         st->hand_state = TLS_ST_CW_KEY_EXCH;
 556         return WRITE_TRAN_CONTINUE;
 557
 558     case TLS_ST_CW_KEY_EXCH:
 559         /*
 560          * For TLS, cert_req is set to 2, so a cert chain of nothing is
 561          * sent, but no verify packet is sent
 562          */
 563         /*
 564          * XXX: For now, we do not support client authentication in ECDH
 565          * cipher suites with ECDH (rather than ECDSA) certificates. We
 566          * need to skip the certificate verify message when client's
 567          * ECDH public key is sent inside the client certificate.
 568          */
 569         if (s->s3->tmp.cert_req == 1) {
 570             st->hand_state = TLS_ST_CW_CERT_VRFY;
 571         } else {
 572             st->hand_state = TLS_ST_CW_CHANGE;
 573         }
 574         if (s->s3->flags & TLS1_FLAGS_SKIP_CERT_VERIFY) {
 575             st->hand_state = TLS_ST_CW_CHANGE;
 576         }
 577         return WRITE_TRAN_CONTINUE;
 578
 579     case TLS_ST_CW_CERT_VRFY:
 580         st->hand_state = TLS_ST_CW_CHANGE;
 581         return WRITE_TRAN_CONTINUE;
 582
 583     case TLS_ST_CW_CHANGE:
 584 #if defined(OPENSSL_NO_NEXTPROTONEG)
 585         st->
 586         hand_state = TLS_ST_CW_FINISHED;
 587 #else
 588         if (!SSL_IS_DTLS(s) && s->s3->npn_seen)
 589             st->hand_state = TLS_ST_CW_NEXT_PROTO;
 590         else
 591             st->hand_state = TLS_ST_CW_FINISHED;
 592 #endif
 593         return WRITE_TRAN_CONTINUE;
 594
 595 #if !defined(OPENSSL_NO_NEXTPROTONEG)
 596     case TLS_ST_CW_NEXT_PROTO:
 597         st->hand_state = TLS_ST_CW_FINISHED;
 598         return WRITE_TRAN_CONTINUE;
 599 #endif
 600
 601     case TLS_ST_CW_FINISHED:
 602         if (s->hit) {
 603             st->hand_state = TLS_ST_OK;
 604             return WRITE_TRAN_CONTINUE;
 605         } else {
 606             return WRITE_TRAN_FINISHED;
 607         }
 608
 609     case TLS_ST_CR_FINISHED:
 610         if (s->hit) {
 611             st->hand_state = TLS_ST_CW_CHANGE;
 612             return WRITE_TRAN_CONTINUE;
 613         } else {
 614             st->hand_state = TLS_ST_OK;
 615             return WRITE_TRAN_CONTINUE;
 616         }
 617
 618     case TLS_ST_CR_HELLO_REQ:
 619         /*
 620          * If we can renegotiate now then do so, otherwise wait for a more
 621          * convenient time.
 622          */
 623         if (ssl3_renegotiate_check(s, 1)) {
 624             if (!tls_setup_handshake(s)) {
 625                 ossl_statem_set_error(s);
 626                 return WRITE_TRAN_ERROR;
 627             }
 628             st->hand_state = TLS_ST_CW_CLNT_HELLO;
 629             return WRITE_TRAN_CONTINUE;
 630         }
 631         st->hand_state = TLS_ST_OK;
 632         return WRITE_TRAN_CONTINUE;
 633     }
 634 }
 635
 636 /*
 637  * Perform any pre work that needs to be done prior to sending a message from
 638  * the client to the server.
 639  */
 640 WORK_STATE ossl_statem_client_pre_work(SSL *s, WORK_STATE wst)
 641 {
 642     OSSL_STATEM *st = &s->statem;
 643
 644     switch (st->hand_state) {
 645     default:
 646         /* No pre work to be done */
 647         break;
 648
 649     case TLS_ST_CW_CLNT_HELLO:
 650         s->shutdown = 0;
 651         if (SSL_IS_DTLS(s)) {
 652             /* every DTLS ClientHello resets Finished MAC */
 653             if (!ssl3_init_finished_mac(s)) {
 654                 ossl_statem_set_error(s);
 655                 return WORK_ERROR;
 656             }
 657         }
 658         break;
 659
 660     case TLS_ST_CW_CHANGE:
 661         if (SSL_IS_DTLS(s)) {
 662             if (s->hit) {
 663                 /*
 664                  * We're into the last flight so we don't retransmit these
 665                  * messages unless we need to.
 666                  */
 667                 st->use_timer = 0;
 668             }
 669 #ifndef OPENSSL_NO_SCTP
 670             if (BIO_dgram_is_sctp(SSL_get_wbio(s)))
 671                 return dtls_wait_for_dry(s);
 672 #endif
 673         }
 674         break;
 675
 676     case TLS_ST_PENDING_EARLY_DATA_END:
 677         /*
 678          * If we've been called by SSL_do_handshake()/SSL_write(), or we did not
 679          * attempt to write early data before calling SSL_read() then we press
 680          * on with the handshake. Otherwise we pause here.
 681          */
 682         if (s->early_data_state == SSL_EARLY_DATA_FINISHED_WRITING
 683                 || s->early_data_state == SSL_EARLY_DATA_NONE)
 684             return WORK_FINISHED_CONTINUE;
 685         /* Fall through */
 686
 687     case TLS_ST_EARLY_DATA:
 688     case TLS_ST_OK:
 689         return tls_finish_handshake(s, wst, 1);
 690     }
 691
 692     return WORK_FINISHED_CONTINUE;
 693 }
 694
 695 /*
 696  * Perform any work that needs to be done after sending a message from the
 697  * client to the server.
 698  */
 699 WORK_STATE ossl_statem_client_post_work(SSL *s, WORK_STATE wst)
 700 {
 701     OSSL_STATEM *st = &s->statem;
 702
 703     s->init_num = 0;
 704
 705     switch (st->hand_state) {
 706     default:
 707         /* No post work to be done */
 708         break;
 709
 710     case TLS_ST_CW_CLNT_HELLO:
 711         if (wst == WORK_MORE_A && statem_flush(s) != 1)
 712             return WORK_MORE_A;
 713
 714         if (SSL_IS_DTLS(s)) {
 715             /* Treat the next message as the first packet */
 716             s->first_packet = 1;
 717         }
 718
 719         if (s->early_data_state == SSL_EARLY_DATA_CONNECTING
 720                 && s->max_early_data > 0) {
 721             /*
 722              * We haven't selected TLSv1.3 yet so we don't call the change
 723              * cipher state function associated with the SSL_METHOD. Instead
 724              * we call tls13_change_cipher_state() directly.
 725              */
 726             if (!tls13_change_cipher_state(s,
 727                         SSL3_CC_EARLY | SSL3_CHANGE_CIPHER_CLIENT_WRITE))
 728                 return WORK_ERROR;
 729         }
 730         break;
 731
 732     case TLS_ST_CW_END_OF_EARLY_DATA:
 733         /*
 734          * We set the enc_write_ctx back to NULL because we may end up writing
 735          * in cleartext again if we get a HelloRetryRequest from the server.
 736          */
 737         EVP_CIPHER_CTX_free(s->enc_write_ctx);
 738         s->enc_write_ctx = NULL;
 739         break;
 740
 741     case TLS_ST_CW_KEY_EXCH:
 742         if (tls_client_key_exchange_post_work(s) == 0)
 743             return WORK_ERROR;
 744         break;
 745
 746     case TLS_ST_CW_CHANGE:
 747         s->session->cipher = s->s3->tmp.new_cipher;
 748 #ifdef OPENSSL_NO_COMP
 749         s->session->compress_meth = 0;
 750 #else
 751         if (s->s3->tmp.new_compression == NULL)
 752             s->session->compress_meth = 0;
 753         else
 754             s->session->compress_meth = s->s3->tmp.new_compression->id;
 755 #endif
 756         if (!s->method->ssl3_enc->setup_key_block(s))
 757             return WORK_ERROR;
 758
 759         if (!s->method->ssl3_enc->change_cipher_state(s,
 760                                                       SSL3_CHANGE_CIPHER_CLIENT_WRITE))
 761             return WORK_ERROR;
 762
 763         if (SSL_IS_DTLS(s)) {
 764 #ifndef OPENSSL_NO_SCTP
 765             if (s->hit) {
 766                 /*
 767                  * Change to new shared key of SCTP-Auth, will be ignored if
 768                  * no SCTP used.
 769                  */
 770                 BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY,
 771                          0, NULL);
 772             }
 773 #endif
 774
 775             dtls1_reset_seq_numbers(s, SSL3_CC_WRITE);
 776         }
 777         break;
 778
 779     case TLS_ST_CW_FINISHED:
 780 #ifndef OPENSSL_NO_SCTP
 781         if (wst == WORK_MORE_A && SSL_IS_DTLS(s) && s->hit == 0) {
 782             /*
 783              * Change to new shared key of SCTP-Auth, will be ignored if
 784              * no SCTP used.
 785              */
 786             BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY,
 787                      0, NULL);
 788         }
 789 #endif
 790         if (statem_flush(s) != 1)
 791             return WORK_MORE_B;
 792
 793         if (SSL_IS_TLS13(s)) {
 794             if (!s->method->ssl3_enc->change_cipher_state(s,
 795                         SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_CLIENT_WRITE))
 796             return WORK_ERROR;
 797         }
 798         break;
 799
 800     case TLS_ST_CW_KEY_UPDATE:
 801         if (statem_flush(s) != 1)
 802             return WORK_MORE_A;
 803         if (!tls13_update_key(s, 1))
 804             return WORK_ERROR;
 805         break;
 806     }
 807
 808     return WORK_FINISHED_CONTINUE;
 809 }
 810
 811 /*
 812  * Get the message construction function and message type for sending from the
 813  * client
 814  *
 815  * Valid return values are:
 816  *   1: Success
 817  *   0: Error
 818  */
 819 int ossl_statem_client_construct_message(SSL *s, WPACKET *pkt,
 820                                          confunc_f *confunc, int *mt)
 821 {
 822     OSSL_STATEM *st = &s->statem;
 823
 824     switch (st->hand_state) {
 825     default:
 826         /* Shouldn't happen */
 827         return 0;
 828
 829     case TLS_ST_CW_CHANGE:
 830         if (SSL_IS_DTLS(s))
 831             *confunc = dtls_construct_change_cipher_spec;
 832         else
 833             *confunc = tls_construct_change_cipher_spec;
 834         *mt = SSL3_MT_CHANGE_CIPHER_SPEC;
 835         break;
 836
 837     case TLS_ST_CW_CLNT_HELLO:
 838         *confunc = tls_construct_client_hello;
 839         *mt = SSL3_MT_CLIENT_HELLO;
 840         break;
 841
 842     case TLS_ST_CW_END_OF_EARLY_DATA:
 843         *confunc = tls_construct_end_of_early_data;
 844         *mt = SSL3_MT_END_OF_EARLY_DATA;
 845         break;
 846
 847     case TLS_ST_PENDING_EARLY_DATA_END:
 848         *confunc = NULL;
 849         *mt = SSL3_MT_DUMMY;
 850         break;
 851
 852     case TLS_ST_CW_CERT:
 853         *confunc = tls_construct_client_certificate;
 854         *mt = SSL3_MT_CERTIFICATE;
 855         break;
 856
 857     case TLS_ST_CW_KEY_EXCH:
 858         *confunc = tls_construct_client_key_exchange;
 859         *mt = SSL3_MT_CLIENT_KEY_EXCHANGE;
 860         break;
 861
 862     case TLS_ST_CW_CERT_VRFY:
 863         *confunc = tls_construct_cert_verify;
 864         *mt = SSL3_MT_CERTIFICATE_VERIFY;
 865         break;
 866
 867 #if !defined(OPENSSL_NO_NEXTPROTONEG)
 868     case TLS_ST_CW_NEXT_PROTO:
 869         *confunc = tls_construct_next_proto;
 870         *mt = SSL3_MT_NEXT_PROTO;
 871         break;
 872 #endif
 873     case TLS_ST_CW_FINISHED:
 874         *confunc = tls_construct_finished;
 875         *mt = SSL3_MT_FINISHED;
 876         break;
 877
 878     case TLS_ST_CW_KEY_UPDATE:
 879         *confunc = tls_construct_key_update;
 880         *mt = SSL3_MT_KEY_UPDATE;
 881         break;
 882     }
 883
 884     return 1;
 885 }
 886
 887 /*
 888  * Returns the maximum allowed length for the current message that we are
 889  * reading. Excludes the message header.
 890  */
 891 size_t ossl_statem_client_max_message_size(SSL *s)
 892 {
 893     OSSL_STATEM *st = &s->statem;
 894
 895     switch (st->hand_state) {
 896     default:
 897         /* Shouldn't happen */
 898         return 0;
 899
 900     case TLS_ST_CR_SRVR_HELLO:
 901         return SERVER_HELLO_MAX_LENGTH;
 902
 903     case DTLS_ST_CR_HELLO_VERIFY_REQUEST:
 904         return HELLO_VERIFY_REQUEST_MAX_LENGTH;
 905
 906     case TLS_ST_CR_HELLO_RETRY_REQUEST:
 907         return HELLO_RETRY_REQUEST_MAX_LENGTH;
 908
 909     case TLS_ST_CR_CERT:
 910         return s->max_cert_list;
 911
 912     case TLS_ST_CR_CERT_VRFY:
 913         return SSL3_RT_MAX_PLAIN_LENGTH;
 914
 915     case TLS_ST_CR_CERT_STATUS:
 916         return SSL3_RT_MAX_PLAIN_LENGTH;
 917
 918     case TLS_ST_CR_KEY_EXCH:
 919         return SERVER_KEY_EXCH_MAX_LENGTH;
 920
 921     case TLS_ST_CR_CERT_REQ:
 922         /*
 923          * Set to s->max_cert_list for compatibility with previous releases. In
 924          * practice these messages can get quite long if servers are configured
 925          * to provide a long list of acceptable CAs
 926          */
 927         return s->max_cert_list;
 928
 929     case TLS_ST_CR_SRVR_DONE:
 930         return SERVER_HELLO_DONE_MAX_LENGTH;
 931
 932     case TLS_ST_CR_CHANGE:
 933         if (s->version == DTLS1_BAD_VER)
 934             return 3;
 935         return CCS_MAX_LENGTH;
 936
 937     case TLS_ST_CR_SESSION_TICKET:
 938         return SSL3_RT_MAX_PLAIN_LENGTH;
 939
 940     case TLS_ST_CR_FINISHED:
 941         return FINISHED_MAX_LENGTH;
 942
 943     case TLS_ST_CR_ENCRYPTED_EXTENSIONS:
 944         return ENCRYPTED_EXTENSIONS_MAX_LENGTH;
 945
 946     case TLS_ST_CR_KEY_UPDATE:
 947         return KEY_UPDATE_MAX_LENGTH;
 948     }
 949 }
 950
 951 /*
 952  * Process a message that the client has been received from the server.
 953  */
 954 MSG_PROCESS_RETURN ossl_statem_client_process_message(SSL *s, PACKET *pkt)
 955 {
 956     OSSL_STATEM *st = &s->statem;
 957
 958     switch (st->hand_state) {
 959     default:
 960         /* Shouldn't happen */
 961         return MSG_PROCESS_ERROR;
 962
 963     case TLS_ST_CR_SRVR_HELLO:
 964         return tls_process_server_hello(s, pkt);
 965
 966     case DTLS_ST_CR_HELLO_VERIFY_REQUEST:
 967         return dtls_process_hello_verify(s, pkt);
 968
 969     case TLS_ST_CR_HELLO_RETRY_REQUEST:
 970         return tls_process_hello_retry_request(s, pkt);
 971
 972     case TLS_ST_CR_CERT:
 973         return tls_process_server_certificate(s, pkt);
 974
 975     case TLS_ST_CR_CERT_VRFY:
 976         return tls_process_cert_verify(s, pkt);
 977
 978     case TLS_ST_CR_CERT_STATUS:
 979         return tls_process_cert_status(s, pkt);
 980
 981     case TLS_ST_CR_KEY_EXCH:
 982         return tls_process_key_exchange(s, pkt);
 983
 984     case TLS_ST_CR_CERT_REQ:
 985         return tls_process_certificate_request(s, pkt);
 986
 987     case TLS_ST_CR_SRVR_DONE:
 988         return tls_process_server_done(s, pkt);
 989
 990     case TLS_ST_CR_CHANGE:
 991         return tls_process_change_cipher_spec(s, pkt);
 992
 993     case TLS_ST_CR_SESSION_TICKET:
 994         return tls_process_new_session_ticket(s, pkt);
 995
 996     case TLS_ST_CR_FINISHED:
 997         return tls_process_finished(s, pkt);
 998
 999     case TLS_ST_CR_HELLO_REQ:
1000         return tls_process_hello_req(s, pkt);
1001
1002     case TLS_ST_CR_ENCRYPTED_EXTENSIONS:
1003         return tls_process_encrypted_extensions(s, pkt);
1004
1005     case TLS_ST_CR_KEY_UPDATE:
1006         return tls_process_key_update(s, pkt);
1007     }
1008 }
1009
1010 /*
1011  * Perform any further processing required following the receipt of a message
1012  * from the server
1013  */
1014 WORK_STATE ossl_statem_client_post_process_message(SSL *s, WORK_STATE wst)
1015 {
1016     OSSL_STATEM *st = &s->statem;
1017
1018     switch (st->hand_state) {
1019     default:
1020         /* Shouldn't happen */
1021         return WORK_ERROR;
1022
1023     case TLS_ST_CR_CERT_REQ:
1024         return tls_prepare_client_certificate(s, wst);
1025     }
1026 }
1027
1028 int tls_construct_client_hello(SSL *s, WPACKET *pkt)
1029 {
1030     unsigned char *p;
1031     size_t sess_id_len;
1032     int i, protverr;
1033     int al = SSL_AD_HANDSHAKE_FAILURE;
1034 #ifndef OPENSSL_NO_COMP
1035     SSL_COMP *comp;
1036 #endif
1037     SSL_SESSION *sess = s->session;
1038
1039     if (!WPACKET_set_max_size(pkt, SSL3_RT_MAX_PLAIN_LENGTH)) {
1040         /* Should not happen */
1041         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1042         return 0;
1043     }
1044
1045     /* Work out what SSL/TLS/DTLS version to use */
1046     protverr = ssl_set_client_hello_version(s);
1047     if (protverr != 0) {
1048         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, protverr);
1049         return 0;
1050     }
1051
1052     if (sess == NULL
1053             || !ssl_version_supported(s, sess->ssl_version)
1054             || !SSL_SESSION_is_resumable(sess)) {
1055         if (!ssl_get_new_session(s, 0))
1056             return 0;
1057     }
1058     /* else use the pre-loaded session */
1059
1060     p = s->s3->client_random;
1061
1062     /*
1063      * for DTLS if client_random is initialized, reuse it, we are
1064      * required to use same upon reply to HelloVerify
1065      */
1066     if (SSL_IS_DTLS(s)) {
1067         size_t idx;
1068         i = 1;
1069         for (idx = 0; idx < sizeof(s->s3->client_random); idx++) {
1070             if (p[idx]) {
1071                 i = 0;
1072                 break;
1073             }
1074         }
1075     } else
1076         i = 1;
1077
1078     if (i && ssl_fill_hello_random(s, 0, p, sizeof(s->s3->client_random),
1079                                    DOWNGRADE_NONE) <= 0)
1080         return 0;
1081
1082     /*-
1083      * version indicates the negotiated version: for example from
1084      * an SSLv2/v3 compatible client hello). The client_version
1085      * field is the maximum version we permit and it is also
1086      * used in RSA encrypted premaster secrets. Some servers can
1087      * choke if we initially report a higher version then
1088      * renegotiate to a lower one in the premaster secret. This
1089      * didn't happen with TLS 1.0 as most servers supported it
1090      * but it can with TLS 1.1 or later if the server only supports
1091      * 1.0.
1092      *
1093      * Possible scenario with previous logic:
1094      *      1. Client hello indicates TLS 1.2
1095      *      2. Server hello says TLS 1.0
1096      *      3. RSA encrypted premaster secret uses 1.2.
1097      *      4. Handshake proceeds using TLS 1.0.
1098      *      5. Server sends hello request to renegotiate.
1099      *      6. Client hello indicates TLS v1.0 as we now
1100      *         know that is maximum server supports.
1101      *      7. Server chokes on RSA encrypted premaster secret
1102      *         containing version 1.0.
1103      *
1104      * For interoperability it should be OK to always use the
1105      * maximum version we support in client hello and then rely
1106      * on the checking of version to ensure the servers isn't
1107      * being inconsistent: for example initially negotiating with
1108      * TLS 1.0 and renegotiating with TLS 1.2. We do this by using
1109      * client_version in client hello and not resetting it to
1110      * the negotiated version.
1111      *
1112      * For TLS 1.3 we always set the ClientHello version to 1.2 and rely on the
1113      * supported_versions extension for the real supported versions.
1114      */
1115     if (!WPACKET_put_bytes_u16(pkt, s->client_version)
1116             || !WPACKET_memcpy(pkt, s->s3->client_random, SSL3_RANDOM_SIZE)) {
1117         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1118         return 0;
1119     }
1120
1121     /* Session ID */
1122     if (s->new_session || s->session->ssl_version == TLS1_3_VERSION)
1123         sess_id_len = 0;
1124     else
1125         sess_id_len = s->session->session_id_length;
1126     if (sess_id_len > sizeof(s->session->session_id)
1127             || !WPACKET_start_sub_packet_u8(pkt)
1128             || (sess_id_len != 0 && !WPACKET_memcpy(pkt, s->session->session_id,
1129                                                     sess_id_len))
1130             || !WPACKET_close(pkt)) {
1131         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1132         return 0;
1133     }
1134
1135     /* cookie stuff for DTLS */
1136     if (SSL_IS_DTLS(s)) {
1137         if (s->d1->cookie_len > sizeof(s->d1->cookie)
1138                 || !WPACKET_sub_memcpy_u8(pkt, s->d1->cookie,
1139                                           s->d1->cookie_len)) {
1140             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1141             return 0;
1142         }
1143     }
1144
1145     /* Ciphers supported */
1146     if (!WPACKET_start_sub_packet_u16(pkt)) {
1147         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1148         return 0;
1149     }
1150     /* ssl_cipher_list_to_bytes() raises SSLerr if appropriate */
1151     if (!ssl_cipher_list_to_bytes(s, SSL_get_ciphers(s), pkt))
1152         return 0;
1153     if (!WPACKET_close(pkt)) {
1154         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1155         return 0;
1156     }
1157
1158     /* COMPRESSION */
1159     if (!WPACKET_start_sub_packet_u8(pkt)) {
1160         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1161         return 0;
1162     }
1163 #ifndef OPENSSL_NO_COMP
1164     if (ssl_allow_compression(s)
1165             && s->ctx->comp_methods
1166             && (SSL_IS_DTLS(s) || s->s3->tmp.max_ver < TLS1_3_VERSION)) {
1167         int compnum = sk_SSL_COMP_num(s->ctx->comp_methods);
1168         for (i = 0; i < compnum; i++) {
1169             comp = sk_SSL_COMP_value(s->ctx->comp_methods, i);
1170             if (!WPACKET_put_bytes_u8(pkt, comp->id)) {
1171                 SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1172                 return 0;
1173             }
1174         }
1175     }
1176 #endif
1177     /* Add the NULL method */
1178     if (!WPACKET_put_bytes_u8(pkt, 0) || !WPACKET_close(pkt)) {
1179         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1180         return 0;
1181     }
1182
1183     /* TLS extensions */
1184     if (!tls_construct_extensions(s, pkt, SSL_EXT_CLIENT_HELLO, NULL, 0, &al)) {
1185         ssl3_send_alert(s, SSL3_AL_FATAL, al);
1186         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1187         return 0;
1188     }
1189
1190     return 1;
1191 }
1192
1193 MSG_PROCESS_RETURN dtls_process_hello_verify(SSL *s, PACKET *pkt)
1194 {
1195     int al;
1196     size_t cookie_len;
1197     PACKET cookiepkt;
1198
1199     if (!PACKET_forward(pkt, 2)
1200         || !PACKET_get_length_prefixed_1(pkt, &cookiepkt)) {
1201         al = SSL_AD_DECODE_ERROR;
1202         SSLerr(SSL_F_DTLS_PROCESS_HELLO_VERIFY, SSL_R_LENGTH_MISMATCH);
1203         goto f_err;
1204     }
1205
1206     cookie_len = PACKET_remaining(&cookiepkt);
1207     if (cookie_len > sizeof(s->d1->cookie)) {
1208         al = SSL_AD_ILLEGAL_PARAMETER;
1209         SSLerr(SSL_F_DTLS_PROCESS_HELLO_VERIFY, SSL_R_LENGTH_TOO_LONG);
1210         goto f_err;
1211     }
1212
1213     if (!PACKET_copy_bytes(&cookiepkt, s->d1->cookie, cookie_len)) {
1214         al = SSL_AD_DECODE_ERROR;
1215         SSLerr(SSL_F_DTLS_PROCESS_HELLO_VERIFY, SSL_R_LENGTH_MISMATCH);
1216         goto f_err;
1217     }
1218     s->d1->cookie_len = cookie_len;
1219
1220     return MSG_PROCESS_FINISHED_READING;
1221  f_err:
1222     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1223     ossl_statem_set_error(s);
1224     return MSG_PROCESS_ERROR;
1225 }
1226
1227 static int set_client_ciphersuite(SSL *s, const unsigned char *cipherchars)
1228 {
1229     STACK_OF(SSL_CIPHER) *sk;
1230     const SSL_CIPHER *c;
1231     int i;
1232
1233     c = ssl_get_cipher_by_char(s, cipherchars, 0);
1234     if (c == NULL) {
1235         /* unknown cipher */
1236         SSLerr(SSL_F_SET_CLIENT_CIPHERSUITE, SSL_R_UNKNOWN_CIPHER_RETURNED);
1237         return 0;
1238     }
1239     /*
1240      * If it is a disabled cipher we either didn't send it in client hello,
1241      * or it's not allowed for the selected protocol. So we return an error.
1242      */
1243     if (ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_CHECK, 1)) {
1244         SSLerr(SSL_F_SET_CLIENT_CIPHERSUITE, SSL_R_WRONG_CIPHER_RETURNED);
1245         return 0;
1246     }
1247
1248     sk = ssl_get_ciphers_by_id(s);
1249     i = sk_SSL_CIPHER_find(sk, c);
1250     if (i < 0) {
1251         /* we did not say we would use this cipher */
1252         SSLerr(SSL_F_SET_CLIENT_CIPHERSUITE, SSL_R_WRONG_CIPHER_RETURNED);
1253         return 0;
1254     }
1255
1256     if (SSL_IS_TLS13(s) && s->s3->tmp.new_cipher != NULL
1257             && s->s3->tmp.new_cipher->id != c->id) {
1258         /* ServerHello selected a different ciphersuite to that in the HRR */
1259         SSLerr(SSL_F_SET_CLIENT_CIPHERSUITE, SSL_R_WRONG_CIPHER_RETURNED);
1260         return 0;
1261     }
1262
1263     /*
1264      * Depending on the session caching (internal/external), the cipher
1265      * and/or cipher_id values may not be set. Make sure that cipher_id is
1266      * set and use it for comparison.
1267      */
1268     if (s->session->cipher != NULL)
1269         s->session->cipher_id = s->session->cipher->id;
1270     if (s->hit && (s->session->cipher_id != c->id)) {
1271         SSLerr(SSL_F_SET_CLIENT_CIPHERSUITE,
1272                SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED);
1273         return 0;
1274     }
1275     s->s3->tmp.new_cipher = c;
1276
1277     return 1;
1278 }
1279
1280 MSG_PROCESS_RETURN tls_process_server_hello(SSL *s, PACKET *pkt)
1281 {
1282     PACKET session_id, extpkt;
1283     size_t session_id_len;
1284     const unsigned char *cipherchars;
1285     int al = SSL_AD_INTERNAL_ERROR;
1286     unsigned int compression;
1287     unsigned int sversion;
1288     unsigned int context;
1289     int protverr;
1290     RAW_EXTENSION *extensions = NULL;
1291 #ifndef OPENSSL_NO_COMP
1292     SSL_COMP *comp;
1293 #endif
1294
1295     if (!PACKET_get_net_2(pkt, &sversion)) {
1296         al = SSL_AD_DECODE_ERROR;
1297         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_LENGTH_MISMATCH);
1298         goto f_err;
1299     }
1300
1301     /* load the server random */
1302     if (!PACKET_copy_bytes(pkt, s->s3->server_random, SSL3_RANDOM_SIZE)) {
1303         al = SSL_AD_DECODE_ERROR;
1304         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_LENGTH_MISMATCH);
1305         goto f_err;
1306     }
1307
1308     /*
1309      * We do this immediately so we know what format the ServerHello is in.
1310      * Must be done after reading the random data so we can check for the
1311      * TLSv1.3 downgrade sentinels
1312      */
1313     protverr = ssl_choose_client_version(s, sversion, 1, &al);
1314     if (protverr != 0) {
1315         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, protverr);
1316         goto f_err;
1317     }
1318
1319     /*
1320      * In TLSv1.3 a ServerHello message signals a key change so the end of the
1321      * message must be on a record boundary.
1322      */
1323     if (SSL_IS_TLS13(s) && RECORD_LAYER_processed_read_pending(&s->rlayer)) {
1324         al = SSL_AD_UNEXPECTED_MESSAGE;
1325         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_NOT_ON_RECORD_BOUNDARY);
1326         goto f_err;
1327     }
1328
1329     /* Get the session-id. */
1330     if (!SSL_IS_TLS13(s)) {
1331         if (!PACKET_get_length_prefixed_1(pkt, &session_id)) {
1332             al = SSL_AD_DECODE_ERROR;
1333             SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_LENGTH_MISMATCH);
1334             goto f_err;
1335         }
1336         session_id_len = PACKET_remaining(&session_id);
1337         if (session_id_len > sizeof s->session->session_id
1338             || session_id_len > SSL3_SESSION_ID_SIZE) {
1339             al = SSL_AD_ILLEGAL_PARAMETER;
1340             SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO,
1341                    SSL_R_SSL3_SESSION_ID_TOO_LONG);
1342             goto f_err;
1343         }
1344     } else {
1345         PACKET_null_init(&session_id);
1346         session_id_len = 0;
1347     }
1348
1349     if (!PACKET_get_bytes(pkt, &cipherchars, TLS_CIPHER_LEN)) {
1350         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_LENGTH_MISMATCH);
1351         al = SSL_AD_DECODE_ERROR;
1352         goto f_err;
1353     }
1354
1355     if (!SSL_IS_TLS13(s)) {
1356         if (!PACKET_get_1(pkt, &compression)) {
1357             SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_LENGTH_MISMATCH);
1358             al = SSL_AD_DECODE_ERROR;
1359             goto f_err;
1360         }
1361     } else {
1362         compression = 0;
1363     }
1364
1365     /* TLS extensions */
1366     if (PACKET_remaining(pkt) == 0) {
1367         PACKET_null_init(&extpkt);
1368     } else if (!PACKET_as_length_prefixed_2(pkt, &extpkt)) {
1369         al = SSL_AD_DECODE_ERROR;
1370         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_BAD_LENGTH);
1371         goto f_err;
1372     }
1373
1374     context = SSL_IS_TLS13(s) ? SSL_EXT_TLS1_3_SERVER_HELLO
1375                               : SSL_EXT_TLS1_2_SERVER_HELLO;
1376     if (!tls_collect_extensions(s, &extpkt, context, &extensions, &al, NULL))
1377         goto f_err;
1378
1379     s->hit = 0;
1380
1381     if (SSL_IS_TLS13(s)) {
1382         /* This will set s->hit if we are resuming */
1383         if (!tls_parse_extension(s, TLSEXT_IDX_psk,
1384                                  SSL_EXT_TLS1_3_SERVER_HELLO,
1385                                  extensions, NULL, 0, &al))
1386             goto f_err;
1387     } else {
1388         /*
1389          * Check if we can resume the session based on external pre-shared
1390          * secret. EAP-FAST (RFC 4851) supports two types of session resumption.
1391          * Resumption based on server-side state works with session IDs.
1392          * Resumption based on pre-shared Protected Access Credentials (PACs)
1393          * works by overriding the SessionTicket extension at the application
1394          * layer, and does not send a session ID. (We do not know whether
1395          * EAP-FAST servers would honour the session ID.) Therefore, the session
1396          * ID alone is not a reliable indicator of session resumption, so we
1397          * first check if we can resume, and later peek at the next handshake
1398          * message to see if the server wants to resume.
1399          */
1400         if (s->version >= TLS1_VERSION
1401                 && s->ext.session_secret_cb != NULL && s->session->ext.tick) {
1402             const SSL_CIPHER *pref_cipher = NULL;
1403             /*
1404              * s->session->master_key_length is a size_t, but this is an int for
1405              * backwards compat reasons
1406              */
1407             int master_key_length;
1408             master_key_length = sizeof(s->session->master_key);
1409             if (s->ext.session_secret_cb(s, s->session->master_key,
1410                                          &master_key_length,
1411                                          NULL, &pref_cipher,
1412                                          s->ext.session_secret_cb_arg)
1413                      && master_key_length > 0) {
1414                 s->session->master_key_length = master_key_length;
1415                 s->session->cipher = pref_cipher ?
1416                     pref_cipher : ssl_get_cipher_by_char(s, cipherchars, 0);
1417             } else {
1418                 SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, ERR_R_INTERNAL_ERROR);
1419                 al = SSL_AD_INTERNAL_ERROR;
1420                 goto f_err;
1421             }
1422         }
1423
1424         if (session_id_len != 0
1425                 && session_id_len == s->session->session_id_length
1426                 && memcmp(PACKET_data(&session_id), s->session->session_id,
1427                           session_id_len) == 0)
1428             s->hit = 1;
1429     }
1430
1431     if (s->hit) {
1432         if (s->sid_ctx_length != s->session->sid_ctx_length
1433                 || memcmp(s->session->sid_ctx, s->sid_ctx, s->sid_ctx_length)) {
1434             /* actually a client application bug */
1435             al = SSL_AD_ILLEGAL_PARAMETER;
1436             SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO,
1437                    SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT);
1438             goto f_err;
1439         }
1440     } else {
1441         /*
1442          * If we were trying for session-id reuse but the server
1443          * didn't resume, make a new SSL_SESSION.
1444          * In the case of EAP-FAST and PAC, we do not send a session ID,
1445          * so the PAC-based session secret is always preserved. It'll be
1446          * overwritten if the server refuses resumption.
1447          */
1448         if (s->session->session_id_length > 0
1449                 || (SSL_IS_TLS13(s)
1450                     && s->session->ext.tick_identity
1451                        != TLSEXT_PSK_BAD_IDENTITY)) {
1452             s->ctx->stats.sess_miss++;
1453             if (!ssl_get_new_session(s, 0)) {
1454                 goto f_err;
1455             }
1456         }
1457
1458         s->session->ssl_version = s->version;
1459         s->session->session_id_length = session_id_len;
1460         /* session_id_len could be 0 */
1461         if (session_id_len > 0)
1462             memcpy(s->session->session_id, PACKET_data(&session_id),
1463                    session_id_len);
1464     }
1465
1466     /* Session version and negotiated protocol version should match */
1467     if (s->version != s->session->ssl_version) {
1468         al = SSL_AD_PROTOCOL_VERSION;
1469
1470         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO,
1471                SSL_R_SSL_SESSION_VERSION_MISMATCH);
1472         goto f_err;
1473     }
1474     /*
1475      * Now that we know the version, update the check to see if it's an allowed
1476      * version.
1477      */
1478     s->s3->tmp.min_ver = s->version;
1479     s->s3->tmp.max_ver = s->version;
1480
1481     if (!set_client_ciphersuite(s, cipherchars)) {
1482         al = SSL_AD_ILLEGAL_PARAMETER;
1483         goto f_err;
1484     }
1485
1486 #ifdef OPENSSL_NO_COMP
1487     if (compression != 0) {
1488         al = SSL_AD_ILLEGAL_PARAMETER;
1489         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO,
1490                SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM);
1491         goto f_err;
1492     }
1493     /*
1494      * If compression is disabled we'd better not try to resume a session
1495      * using compression.
1496      */
1497     if (s->session->compress_meth != 0) {
1498         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_INCONSISTENT_COMPRESSION);
1499         goto f_err;
1500     }
1501 #else
1502     if (s->hit && compression != s->session->compress_meth) {
1503         al = SSL_AD_ILLEGAL_PARAMETER;
1504         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO,
1505                SSL_R_OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED);
1506         goto f_err;
1507     }
1508     if (compression == 0)
1509         comp = NULL;
1510     else if (!ssl_allow_compression(s)) {
1511         al = SSL_AD_ILLEGAL_PARAMETER;
1512         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_COMPRESSION_DISABLED);
1513         goto f_err;
1514     } else {
1515         comp = ssl3_comp_find(s->ctx->comp_methods, compression);
1516     }
1517
1518     if (compression != 0 && comp == NULL) {
1519         al = SSL_AD_ILLEGAL_PARAMETER;
1520         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO,
1521                SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM);
1522         goto f_err;
1523     } else {
1524         s->s3->tmp.new_compression = comp;
1525     }
1526 #endif
1527
1528     if (!tls_parse_all_extensions(s, context, extensions, NULL, 0, &al))
1529         goto f_err;
1530
1531 #ifndef OPENSSL_NO_SCTP
1532     if (SSL_IS_DTLS(s) && s->hit) {
1533         unsigned char sctpauthkey[64];
1534         char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)];
1535
1536         /*
1537          * Add new shared key for SCTP-Auth, will be ignored if
1538          * no SCTP used.
1539          */
1540         memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL,
1541                sizeof(DTLS1_SCTP_AUTH_LABEL));
1542
1543         if (SSL_export_keying_material(s, sctpauthkey,
1544                                        sizeof(sctpauthkey),
1545                                        labelbuffer,
1546                                        sizeof(labelbuffer), NULL, 0, 0) <= 0)
1547             goto f_err;
1548
1549         BIO_ctrl(SSL_get_wbio(s),
1550                  BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
1551                  sizeof(sctpauthkey), sctpauthkey);
1552     }
1553 #endif
1554
1555     /*
1556      * In TLSv1.3 we have some post-processing to change cipher state, otherwise
1557      * we're done with this message
1558      */
1559     if (SSL_IS_TLS13(s)
1560             && (!s->method->ssl3_enc->setup_key_block(s)
1561                 || !s->method->ssl3_enc->change_cipher_state(s,
1562                     SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_READ))) {
1563         al = SSL_AD_INTERNAL_ERROR;
1564         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_CANNOT_CHANGE_CIPHER);
1565         goto f_err;
1566     }
1567
1568     OPENSSL_free(extensions);
1569     return MSG_PROCESS_CONTINUE_READING;
1570  f_err:
1571     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1572     ossl_statem_set_error(s);
1573     OPENSSL_free(extensions);
1574     return MSG_PROCESS_ERROR;
1575 }
1576
1577 static MSG_PROCESS_RETURN tls_process_hello_retry_request(SSL *s, PACKET *pkt)
1578 {
1579     unsigned int sversion;
1580     int errorcode;
1581     const unsigned char *cipherchars;
1582     RAW_EXTENSION *extensions = NULL;
1583     int al;
1584     PACKET extpkt;
1585
1586     if (!PACKET_get_net_2(pkt, &sversion)) {
1587         al = SSL_AD_DECODE_ERROR;
1588         SSLerr(SSL_F_TLS_PROCESS_HELLO_RETRY_REQUEST, SSL_R_LENGTH_MISMATCH);
1589         goto f_err;
1590     }
1591
1592     s->hello_retry_request = 1;
1593
1594     /* This will fail if it doesn't choose TLSv1.3+ */
1595     errorcode = ssl_choose_client_version(s, sversion, 0, &al);
1596     if (errorcode != 0) {
1597         SSLerr(SSL_F_TLS_PROCESS_HELLO_RETRY_REQUEST, errorcode);
1598         goto f_err;
1599     }
1600
1601     if (!PACKET_get_bytes(pkt, &cipherchars, TLS_CIPHER_LEN)) {
1602         SSLerr(SSL_F_TLS_PROCESS_HELLO_RETRY_REQUEST, SSL_R_LENGTH_MISMATCH);
1603         al = SSL_AD_DECODE_ERROR;
1604         goto f_err;
1605     }
1606
1607     if (!set_client_ciphersuite(s, cipherchars)) {
1608         al = SSL_AD_ILLEGAL_PARAMETER;
1609         goto f_err;
1610     }
1611
1612     if (!PACKET_as_length_prefixed_2(pkt, &extpkt)) {
1613         al = SSL_AD_DECODE_ERROR;
1614         SSLerr(SSL_F_TLS_PROCESS_HELLO_RETRY_REQUEST, SSL_R_BAD_LENGTH);
1615         goto f_err;
1616     }
1617
1618     if (!tls_collect_extensions(s, &extpkt, SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST,
1619                                 &extensions, &al, NULL)
1620             || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST,
1621                                          extensions, NULL, 0, &al))
1622         goto f_err;
1623
1624     OPENSSL_free(extensions);
1625
1626     /*
1627      * Re-initialise the Transcript Hash. We're going to prepopulate it with
1628      * a synthetic message_hash in place of ClientHello1.
1629      */
1630     if (!create_synthetic_message_hash(s)) {
1631         al = SSL_AD_INTERNAL_ERROR;
1632         goto f_err;
1633     }
1634
1635     /*
1636      * Add this message to the Transcript Hash. Normally this is done
1637      * automatically prior to the message processing stage. However due to the
1638      * need to create the synthetic message hash, we defer that step until now
1639      * for HRR messages.
1640      */
1641     if (!ssl3_finish_mac(s, (unsigned char *)s->init_buf->data,
1642                                 s->init_num + SSL3_HM_HEADER_LENGTH)) {
1643         al = SSL_AD_INTERNAL_ERROR;
1644         SSLerr(SSL_F_TLS_PROCESS_HELLO_RETRY_REQUEST, ERR_R_INTERNAL_ERROR);
1645         goto f_err;
1646     }
1647
1648     return MSG_PROCESS_FINISHED_READING;
1649  f_err:
1650     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1651     ossl_statem_set_error(s);
1652     OPENSSL_free(extensions);
1653     return MSG_PROCESS_ERROR;
1654 }
1655
1656 MSG_PROCESS_RETURN tls_process_server_certificate(SSL *s, PACKET *pkt)
1657 {
1658     int al, i, ret = MSG_PROCESS_ERROR, exp_idx;
1659     unsigned long cert_list_len, cert_len;
1660     X509 *x = NULL;
1661     const unsigned char *certstart, *certbytes;
1662     STACK_OF(X509) *sk = NULL;
1663     EVP_PKEY *pkey = NULL;
1664     size_t chainidx;
1665     unsigned int context = 0;
1666
1667     if ((sk = sk_X509_new_null()) == NULL) {
1668         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE, ERR_R_MALLOC_FAILURE);
1669         goto err;
1670     }
1671
1672     if ((SSL_IS_TLS13(s) && !PACKET_get_1(pkt, &context))
1673             || context != 0
1674             || !PACKET_get_net_3(pkt, &cert_list_len)
1675             || PACKET_remaining(pkt) != cert_list_len) {
1676         al = SSL_AD_DECODE_ERROR;
1677         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE, SSL_R_LENGTH_MISMATCH);
1678         goto f_err;
1679     }
1680     for (chainidx = 0; PACKET_remaining(pkt); chainidx++) {
1681         if (!PACKET_get_net_3(pkt, &cert_len)
1682             || !PACKET_get_bytes(pkt, &certbytes, cert_len)) {
1683             al = SSL_AD_DECODE_ERROR;
1684             SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE,
1685                    SSL_R_CERT_LENGTH_MISMATCH);
1686             goto f_err;
1687         }
1688
1689         certstart = certbytes;
1690         x = d2i_X509(NULL, (const unsigned char **)&certbytes, cert_len);
1691         if (x == NULL) {
1692             al = SSL_AD_BAD_CERTIFICATE;
1693             SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE, ERR_R_ASN1_LIB);
1694             goto f_err;
1695         }
1696         if (certbytes != (certstart + cert_len)) {
1697             al = SSL_AD_DECODE_ERROR;
1698             SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE,
1699                    SSL_R_CERT_LENGTH_MISMATCH);
1700             goto f_err;
1701         }
1702
1703         if (SSL_IS_TLS13(s)) {
1704             RAW_EXTENSION *rawexts = NULL;
1705             PACKET extensions;
1706
1707             if (!PACKET_get_length_prefixed_2(pkt, &extensions)) {
1708                 al = SSL_AD_DECODE_ERROR;
1709                 SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE, SSL_R_BAD_LENGTH);
1710                 goto f_err;
1711             }
1712             if (!tls_collect_extensions(s, &extensions,
1713                                         SSL_EXT_TLS1_3_CERTIFICATE, &rawexts,
1714                                         &al, NULL)
1715                     || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_CERTIFICATE,
1716                                                  rawexts, x, chainidx, &al)) {
1717                 OPENSSL_free(rawexts);
1718                 goto f_err;
1719             }
1720             OPENSSL_free(rawexts);
1721         }
1722
1723         if (!sk_X509_push(sk, x)) {
1724             SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE, ERR_R_MALLOC_FAILURE);
1725             goto err;
1726         }
1727         x = NULL;
1728     }
1729
1730     i = ssl_verify_cert_chain(s, sk);
1731     /*
1732      * The documented interface is that SSL_VERIFY_PEER should be set in order
1733      * for client side verification of the server certificate to take place.
1734      * However, historically the code has only checked that *any* flag is set
1735      * to cause server verification to take place. Use of the other flags makes
1736      * no sense in client mode. An attempt to clean up the semantics was
1737      * reverted because at least one application *only* set
1738      * SSL_VERIFY_FAIL_IF_NO_PEER_CERT. Prior to the clean up this still caused
1739      * server verification to take place, after the clean up it silently did
1740      * nothing. SSL_CTX_set_verify()/SSL_set_verify() cannot validate the flags
1741      * sent to them because they are void functions. Therefore, we now use the
1742      * (less clean) historic behaviour of performing validation if any flag is
1743      * set. The *documented* interface remains the same.
1744      */
1745     if (s->verify_mode != SSL_VERIFY_NONE && i <= 0) {
1746         al = ssl_verify_alarm_type(s->verify_result);
1747         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE,
1748                SSL_R_CERTIFICATE_VERIFY_FAILED);
1749         goto f_err;
1750     }
1751     ERR_clear_error();          /* but we keep s->verify_result */
1752     if (i > 1) {
1753         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE, i);
1754         al = SSL_AD_HANDSHAKE_FAILURE;
1755         goto f_err;
1756     }
1757
1758     s->session->peer_chain = sk;
1759     /*
1760      * Inconsistency alert: cert_chain does include the peer's certificate,
1761      * which we don't include in statem_srvr.c
1762      */
1763     x = sk_X509_value(sk, 0);
1764     sk = NULL;
1765     /*
1766      * VRS 19990621: possible memory leak; sk=null ==> !sk_pop_free() @end
1767      */
1768
1769     pkey = X509_get0_pubkey(x);
1770
1771     if (pkey == NULL || EVP_PKEY_missing_parameters(pkey)) {
1772         x = NULL;
1773         al = SSL3_AL_FATAL;
1774         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE,
1775                SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS);
1776         goto f_err;
1777     }
1778
1779     i = ssl_cert_type(x, pkey);
1780     if (i < 0) {
1781         x = NULL;
1782         al = SSL3_AL_FATAL;
1783         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE,
1784                SSL_R_UNKNOWN_CERTIFICATE_TYPE);
1785         goto f_err;
1786     }
1787     /*
1788      * Check certificate type is consistent with ciphersuite. For TLS 1.3
1789      * skip check since TLS 1.3 ciphersuites can be used with any certificate
1790      * type.
1791      */
1792     if (!SSL_IS_TLS13(s)) {
1793         exp_idx = ssl_cipher_get_cert_index(s->s3->tmp.new_cipher);
1794         if (exp_idx >= 0 && i != exp_idx
1795             && (exp_idx != SSL_PKEY_GOST_EC ||
1796                 (i != SSL_PKEY_GOST12_512 && i != SSL_PKEY_GOST12_256
1797                  && i != SSL_PKEY_GOST01))) {
1798             x = NULL;
1799             al = SSL_AD_ILLEGAL_PARAMETER;
1800             SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE,
1801                    SSL_R_WRONG_CERTIFICATE_TYPE);
1802             goto f_err;
1803         }
1804     }
1805     s->session->peer_type = i;
1806
1807     X509_free(s->session->peer);
1808     X509_up_ref(x);
1809     s->session->peer = x;
1810     s->session->verify_result = s->verify_result;
1811     x = NULL;
1812
1813     /* Save the current hash state for when we receive the CertificateVerify */
1814     if (SSL_IS_TLS13(s)
1815             && !ssl_handshake_hash(s, s->cert_verify_hash,
1816                                    sizeof(s->cert_verify_hash),
1817                                    &s->cert_verify_hash_len)) {
1818         al = SSL_AD_INTERNAL_ERROR;
1819         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE, ERR_R_INTERNAL_ERROR);
1820         goto f_err;
1821     }
1822
1823     ret = MSG_PROCESS_CONTINUE_READING;
1824     goto done;
1825
1826  f_err:
1827     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1828  err:
1829     ossl_statem_set_error(s);
1830  done:
1831     X509_free(x);
1832     sk_X509_pop_free(sk, X509_free);
1833     return ret;
1834 }
1835
1836 static int tls_process_ske_psk_preamble(SSL *s, PACKET *pkt, int *al)
1837 {
1838 #ifndef OPENSSL_NO_PSK
1839     PACKET psk_identity_hint;
1840
1841     /* PSK ciphersuites are preceded by an identity hint */
1842
1843     if (!PACKET_get_length_prefixed_2(pkt, &psk_identity_hint)) {
1844         *al = SSL_AD_DECODE_ERROR;
1845         SSLerr(SSL_F_TLS_PROCESS_SKE_PSK_PREAMBLE, SSL_R_LENGTH_MISMATCH);
1846         return 0;
1847     }
1848
1849     /*
1850      * Store PSK identity hint for later use, hint is used in
1851      * tls_construct_client_key_exchange.  Assume that the maximum length of
1852      * a PSK identity hint can be as long as the maximum length of a PSK
1853      * identity.
1854      */
1855     if (PACKET_remaining(&psk_identity_hint) > PSK_MAX_IDENTITY_LEN) {
1856         *al = SSL_AD_HANDSHAKE_FAILURE;
1857         SSLerr(SSL_F_TLS_PROCESS_SKE_PSK_PREAMBLE, SSL_R_DATA_LENGTH_TOO_LONG);
1858         return 0;
1859     }
1860
1861     if (PACKET_remaining(&psk_identity_hint) == 0) {
1862         OPENSSL_free(s->session->psk_identity_hint);
1863         s->session->psk_identity_hint = NULL;
1864     } else if (!PACKET_strndup(&psk_identity_hint,
1865                                &s->session->psk_identity_hint)) {
1866         *al = SSL_AD_INTERNAL_ERROR;
1867         return 0;
1868     }
1869
1870     return 1;
1871 #else
1872     SSLerr(SSL_F_TLS_PROCESS_SKE_PSK_PREAMBLE, ERR_R_INTERNAL_ERROR);
1873     *al = SSL_AD_INTERNAL_ERROR;
1874     return 0;
1875 #endif
1876 }
1877
1878 static int tls_process_ske_srp(SSL *s, PACKET *pkt, EVP_PKEY **pkey, int *al)
1879 {
1880 #ifndef OPENSSL_NO_SRP
1881     PACKET prime, generator, salt, server_pub;
1882
1883     if (!PACKET_get_length_prefixed_2(pkt, &prime)
1884         || !PACKET_get_length_prefixed_2(pkt, &generator)
1885         || !PACKET_get_length_prefixed_1(pkt, &salt)
1886         || !PACKET_get_length_prefixed_2(pkt, &server_pub)) {
1887         *al = SSL_AD_DECODE_ERROR;
1888         SSLerr(SSL_F_TLS_PROCESS_SKE_SRP, SSL_R_LENGTH_MISMATCH);
1889         return 0;
1890     }
1891
1892     /* TODO(size_t): Convert BN_bin2bn() calls */
1893     if ((s->srp_ctx.N =
1894          BN_bin2bn(PACKET_data(&prime),
1895                    (int)PACKET_remaining(&prime), NULL)) == NULL
1896         || (s->srp_ctx.g =
1897             BN_bin2bn(PACKET_data(&generator),
1898                       (int)PACKET_remaining(&generator), NULL)) == NULL
1899         || (s->srp_ctx.s =
1900             BN_bin2bn(PACKET_data(&salt),
1901                       (int)PACKET_remaining(&salt), NULL)) == NULL
1902         || (s->srp_ctx.B =
1903             BN_bin2bn(PACKET_data(&server_pub),
1904                       (int)PACKET_remaining(&server_pub), NULL)) == NULL) {
1905         *al = SSL_AD_INTERNAL_ERROR;
1906         SSLerr(SSL_F_TLS_PROCESS_SKE_SRP, ERR_R_BN_LIB);
1907         return 0;
1908     }
1909
1910     if (!srp_verify_server_param(s, al)) {
1911         *al = SSL_AD_DECODE_ERROR;
1912         SSLerr(SSL_F_TLS_PROCESS_SKE_SRP, SSL_R_BAD_SRP_PARAMETERS);
1913         return 0;
1914     }
1915
1916     /* We must check if there is a certificate */
1917     if (s->s3->tmp.new_cipher->algorithm_auth & (SSL_aRSA | SSL_aDSS))
1918         *pkey = X509_get0_pubkey(s->session->peer);
1919
1920     return 1;
1921 #else
1922     SSLerr(SSL_F_TLS_PROCESS_SKE_SRP, ERR_R_INTERNAL_ERROR);
1923     *al = SSL_AD_INTERNAL_ERROR;
1924     return 0;
1925 #endif
1926 }
1927
1928 static int tls_process_ske_dhe(SSL *s, PACKET *pkt, EVP_PKEY **pkey, int *al)
1929 {
1930 #ifndef OPENSSL_NO_DH
1931     PACKET prime, generator, pub_key;
1932     EVP_PKEY *peer_tmp = NULL;
1933
1934     DH *dh = NULL;
1935     BIGNUM *p = NULL, *g = NULL, *bnpub_key = NULL;
1936
1937     int check_bits = 0;
1938
1939     if (!PACKET_get_length_prefixed_2(pkt, &prime)
1940         || !PACKET_get_length_prefixed_2(pkt, &generator)
1941         || !PACKET_get_length_prefixed_2(pkt, &pub_key)) {
1942         *al = SSL_AD_DECODE_ERROR;
1943         SSLerr(SSL_F_TLS_PROCESS_SKE_DHE, SSL_R_LENGTH_MISMATCH);
1944         return 0;
1945     }
1946
1947     peer_tmp = EVP_PKEY_new();
1948     dh = DH_new();
1949
1950     if (peer_tmp == NULL || dh == NULL) {
1951         *al = SSL_AD_INTERNAL_ERROR;
1952         SSLerr(SSL_F_TLS_PROCESS_SKE_DHE, ERR_R_MALLOC_FAILURE);
1953         goto err;
1954     }
1955
1956     /* TODO(size_t): Convert these calls */
1957     p = BN_bin2bn(PACKET_data(&prime), (int)PACKET_remaining(&prime), NULL);
1958     g = BN_bin2bn(PACKET_data(&generator), (int)PACKET_remaining(&generator),
1959                   NULL);
1960     bnpub_key = BN_bin2bn(PACKET_data(&pub_key),
1961                           (int)PACKET_remaining(&pub_key), NULL);
1962     if (p == NULL || g == NULL || bnpub_key == NULL) {
1963         *al = SSL_AD_INTERNAL_ERROR;
1964         SSLerr(SSL_F_TLS_PROCESS_SKE_DHE, ERR_R_BN_LIB);
1965         goto err;
1966     }
1967
1968     /* test non-zero pubkey */
1969     if (BN_is_zero(bnpub_key)) {
1970         *al = SSL_AD_DECODE_ERROR;
1971         SSLerr(SSL_F_TLS_PROCESS_SKE_DHE, SSL_R_BAD_DH_VALUE);
1972         goto err;
1973     }
1974
1975     if (!DH_set0_pqg(dh, p, NULL, g)) {
1976         *al = SSL_AD_INTERNAL_ERROR;
1977         SSLerr(SSL_F_TLS_PROCESS_SKE_DHE, ERR_R_BN_LIB);
1978         goto err;
1979     }
1980     p = g = NULL;
1981
1982     if (DH_check_params(dh, &check_bits) == 0 || check_bits != 0) {
1983         *al = SSL_AD_DECODE_ERROR;
1984         SSLerr(SSL_F_TLS_PROCESS_SKE_DHE, SSL_R_BAD_DH_VALUE);
1985         goto err;
1986     }
1987
1988     if (!DH_set0_key(dh, bnpub_key, NULL)) {
1989         *al = SSL_AD_INTERNAL_ERROR;
1990         SSLerr(SSL_F_TLS_PROCESS_SKE_DHE, ERR_R_BN_LIB);
1991         goto err;
1992     }
1993     bnpub_key = NULL;
1994
1995     if (!ssl_security(s, SSL_SECOP_TMP_DH, DH_security_bits(dh), 0, dh)) {
1996         *al = SSL_AD_HANDSHAKE_FAILURE;
1997         SSLerr(SSL_F_TLS_PROCESS_SKE_DHE, SSL_R_DH_KEY_TOO_SMALL);
1998         goto err;
1999     }
2000
2001     if (EVP_PKEY_assign_DH(peer_tmp, dh) == 0) {
2002         *al = SSL_AD_INTERNAL_ERROR;
2003         SSLerr(SSL_F_TLS_PROCESS_SKE_DHE, ERR_R_EVP_LIB);
2004         goto err;
2005     }
2006
2007     s->s3->peer_tmp = peer_tmp;
2008
2009     /*
2010      * FIXME: This makes assumptions about which ciphersuites come with
2011      * public keys. We should have a less ad-hoc way of doing this
2012      */
2013     if (s->s3->tmp.new_cipher->algorithm_auth & (SSL_aRSA | SSL_aDSS))
2014         *pkey = X509_get0_pubkey(s->session->peer);
2015     /* else anonymous DH, so no certificate or pkey. */
2016
2017     return 1;
2018
2019  err:
2020     BN_free(p);
2021     BN_free(g);
2022     BN_free(bnpub_key);
2023     DH_free(dh);
2024     EVP_PKEY_free(peer_tmp);
2025
2026     return 0;
2027 #else
2028     SSLerr(SSL_F_TLS_PROCESS_SKE_DHE, ERR_R_INTERNAL_ERROR);
2029     *al = SSL_AD_INTERNAL_ERROR;
2030     return 0;
2031 #endif
2032 }
2033
2034 static int tls_process_ske_ecdhe(SSL *s, PACKET *pkt, EVP_PKEY **pkey, int *al)
2035 {
2036 #ifndef OPENSSL_NO_EC
2037     PACKET encoded_pt;
2038     const unsigned char *ecparams;
2039     int curve_nid;
2040     unsigned int curve_flags;
2041     EVP_PKEY_CTX *pctx = NULL;
2042
2043     /*
2044      * Extract elliptic curve parameters and the server's ephemeral ECDH
2045      * public key. For now we only support named (not generic) curves and
2046      * ECParameters in this case is just three bytes.
2047      */
2048     if (!PACKET_get_bytes(pkt, &ecparams, 3)) {
2049         *al = SSL_AD_DECODE_ERROR;
2050         SSLerr(SSL_F_TLS_PROCESS_SKE_ECDHE, SSL_R_LENGTH_TOO_SHORT);
2051         return 0;
2052     }
2053     /*
2054      * Check curve is one of our preferences, if not server has sent an
2055      * invalid curve. ECParameters is 3 bytes.
2056      */
2057     if (!tls1_check_curve(s, ecparams, 3)) {
2058         *al = SSL_AD_DECODE_ERROR;
2059         SSLerr(SSL_F_TLS_PROCESS_SKE_ECDHE, SSL_R_WRONG_CURVE);
2060         return 0;
2061     }
2062
2063     curve_nid = tls1_ec_curve_id2nid(*(ecparams + 2), &curve_flags);
2064
2065     if (curve_nid == 0) {
2066         *al = SSL_AD_INTERNAL_ERROR;
2067         SSLerr(SSL_F_TLS_PROCESS_SKE_ECDHE,
2068                SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS);
2069         return 0;
2070     }
2071
2072     if ((curve_flags & TLS_CURVE_TYPE) == TLS_CURVE_CUSTOM) {
2073         EVP_PKEY *key = EVP_PKEY_new();
2074
2075         if (key == NULL || !EVP_PKEY_set_type(key, curve_nid)) {
2076             *al = SSL_AD_INTERNAL_ERROR;
2077             SSLerr(SSL_F_TLS_PROCESS_SKE_ECDHE, ERR_R_EVP_LIB);
2078             EVP_PKEY_free(key);
2079             return 0;
2080         }
2081         s->s3->peer_tmp = key;
2082     } else {
2083         /* Set up EVP_PKEY with named curve as parameters */
2084         pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
2085         if (pctx == NULL
2086             || EVP_PKEY_paramgen_init(pctx) <= 0
2087             || EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx, curve_nid) <= 0
2088             || EVP_PKEY_paramgen(pctx, &s->s3->peer_tmp) <= 0) {
2089             *al = SSL_AD_INTERNAL_ERROR;
2090             SSLerr(SSL_F_TLS_PROCESS_SKE_ECDHE, ERR_R_EVP_LIB);
2091             EVP_PKEY_CTX_free(pctx);
2092             return 0;
2093         }
2094         EVP_PKEY_CTX_free(pctx);
2095         pctx = NULL;
2096     }
2097
2098     if (!PACKET_get_length_prefixed_1(pkt, &encoded_pt)) {
2099         *al = SSL_AD_DECODE_ERROR;
2100         SSLerr(SSL_F_TLS_PROCESS_SKE_ECDHE, SSL_R_LENGTH_MISMATCH);
2101         return 0;
2102     }
2103
2104     if (!EVP_PKEY_set1_tls_encodedpoint(s->s3->peer_tmp,
2105                                         PACKET_data(&encoded_pt),
2106                                         PACKET_remaining(&encoded_pt))) {
2107         *al = SSL_AD_DECODE_ERROR;
2108         SSLerr(SSL_F_TLS_PROCESS_SKE_ECDHE, SSL_R_BAD_ECPOINT);
2109         return 0;
2110     }
2111
2112     /*
2113      * The ECC/TLS specification does not mention the use of DSA to sign
2114      * ECParameters in the server key exchange message. We do support RSA
2115      * and ECDSA.
2116      */
2117     if (s->s3->tmp.new_cipher->algorithm_auth & SSL_aECDSA)
2118         *pkey = X509_get0_pubkey(s->session->peer);
2119     else if (s->s3->tmp.new_cipher->algorithm_auth & SSL_aRSA)
2120         *pkey = X509_get0_pubkey(s->session->peer);
2121     /* else anonymous ECDH, so no certificate or pkey. */
2122
2123     return 1;
2124 #else
2125     SSLerr(SSL_F_TLS_PROCESS_SKE_ECDHE, ERR_R_INTERNAL_ERROR);
2126     *al = SSL_AD_INTERNAL_ERROR;
2127     return 0;
2128 #endif
2129 }
2130
2131 MSG_PROCESS_RETURN tls_process_key_exchange(SSL *s, PACKET *pkt)
2132 {
2133     int al = -1;
2134     long alg_k;
2135     EVP_PKEY *pkey = NULL;
2136     EVP_MD_CTX *md_ctx = NULL;
2137     EVP_PKEY_CTX *pctx = NULL;
2138     PACKET save_param_start, signature;
2139
2140     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
2141
2142     save_param_start = *pkt;
2143
2144 #if !defined(OPENSSL_NO_EC) || !defined(OPENSSL_NO_DH)
2145     EVP_PKEY_free(s->s3->peer_tmp);
2146     s->s3->peer_tmp = NULL;
2147 #endif
2148
2149     if (alg_k & SSL_PSK) {
2150         if (!tls_process_ske_psk_preamble(s, pkt, &al))
2151             goto err;
2152     }
2153
2154     /* Nothing else to do for plain PSK or RSAPSK */
2155     if (alg_k & (SSL_kPSK | SSL_kRSAPSK)) {
2156     } else if (alg_k & SSL_kSRP) {
2157         if (!tls_process_ske_srp(s, pkt, &pkey, &al))
2158             goto err;
2159     } else if (alg_k & (SSL_kDHE | SSL_kDHEPSK)) {
2160         if (!tls_process_ske_dhe(s, pkt, &pkey, &al))
2161             goto err;
2162     } else if (alg_k & (SSL_kECDHE | SSL_kECDHEPSK)) {
2163         if (!tls_process_ske_ecdhe(s, pkt, &pkey, &al))
2164             goto err;
2165     } else if (alg_k) {
2166         al = SSL_AD_UNEXPECTED_MESSAGE;
2167         SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, SSL_R_UNEXPECTED_MESSAGE);
2168         goto err;
2169     }
2170
2171     /* if it was signed, check the signature */
2172     if (pkey != NULL) {
2173         PACKET params;
2174         int maxsig;
2175         const EVP_MD *md = NULL;
2176
2177         /*
2178          * |pkt| now points to the beginning of the signature, so the difference
2179          * equals the length of the parameters.
2180          */
2181         if (!PACKET_get_sub_packet(&save_param_start, &params,
2182                                    PACKET_remaining(&save_param_start) -
2183                                    PACKET_remaining(pkt))) {
2184             al = SSL_AD_INTERNAL_ERROR;
2185             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2186             goto err;
2187         }
2188
2189         if (SSL_USE_SIGALGS(s)) {
2190             unsigned int sigalg;
2191             int rv;
2192
2193             if (!PACKET_get_net_2(pkt, &sigalg)) {
2194                 al = SSL_AD_DECODE_ERROR;
2195                 SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, SSL_R_LENGTH_TOO_SHORT);
2196                 goto err;
2197             }
2198             rv = tls12_check_peer_sigalg(s, sigalg, pkey);
2199             if (rv == -1) {
2200                 al = SSL_AD_INTERNAL_ERROR;
2201                 goto err;
2202             } else if (rv == 0) {
2203                 al = SSL_AD_DECODE_ERROR;
2204                 goto err;
2205             }
2206 #ifdef SSL_DEBUG
2207             fprintf(stderr, "USING TLSv1.2 HASH %s\n", EVP_MD_name(md));
2208 #endif
2209         } else if (!tls1_set_peer_legacy_sigalg(s, pkey)) {
2210             al = SSL_AD_INTERNAL_ERROR;
2211             goto err;
2212         }
2213
2214         md = ssl_md(s->s3->tmp.peer_sigalg->hash_idx);
2215
2216         if (!PACKET_get_length_prefixed_2(pkt, &signature)
2217             || PACKET_remaining(pkt) != 0) {
2218             al = SSL_AD_DECODE_ERROR;
2219             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, SSL_R_LENGTH_MISMATCH);
2220             goto err;
2221         }
2222         maxsig = EVP_PKEY_size(pkey);
2223         if (maxsig < 0) {
2224             al = SSL_AD_INTERNAL_ERROR;
2225             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2226             goto err;
2227         }
2228
2229         /*
2230          * Check signature length
2231          */
2232         if (PACKET_remaining(&signature) > (size_t)maxsig) {
2233             /* wrong packet length */
2234             al = SSL_AD_DECODE_ERROR;
2235             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE,
2236                    SSL_R_WRONG_SIGNATURE_LENGTH);
2237             goto err;
2238         }
2239
2240         md_ctx = EVP_MD_CTX_new();
2241         if (md_ctx == NULL) {
2242             al = SSL_AD_INTERNAL_ERROR;
2243             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
2244             goto err;
2245         }
2246
2247         if (EVP_DigestVerifyInit(md_ctx, &pctx, md, NULL, pkey) <= 0) {
2248             al = SSL_AD_INTERNAL_ERROR;
2249             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, ERR_R_EVP_LIB);
2250             goto err;
2251         }
2252         if (SSL_USE_PSS(s)) {
2253             if (EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) <= 0
2254                 || EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx,
2255                                                 RSA_PSS_SALTLEN_DIGEST) <= 0) {
2256                 al = SSL_AD_INTERNAL_ERROR;
2257                 SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, ERR_R_EVP_LIB);
2258                 goto err;
2259             }
2260         }
2261         if (EVP_DigestVerifyUpdate(md_ctx, &(s->s3->client_random[0]),
2262                                    SSL3_RANDOM_SIZE) <= 0
2263                 || EVP_DigestVerifyUpdate(md_ctx, &(s->s3->server_random[0]),
2264                                           SSL3_RANDOM_SIZE) <= 0
2265                 || EVP_DigestVerifyUpdate(md_ctx, PACKET_data(&params),
2266                                           PACKET_remaining(&params)) <= 0) {
2267             al = SSL_AD_INTERNAL_ERROR;
2268             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, ERR_R_EVP_LIB);
2269             goto err;
2270         }
2271         if (EVP_DigestVerifyFinal(md_ctx, PACKET_data(&signature),
2272                                   PACKET_remaining(&signature)) <= 0) {
2273             /* bad signature */
2274             al = SSL_AD_DECRYPT_ERROR;
2275             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, SSL_R_BAD_SIGNATURE);
2276             goto err;
2277         }
2278         EVP_MD_CTX_free(md_ctx);
2279         md_ctx = NULL;
2280     } else {
2281         /* aNULL, aSRP or PSK do not need public keys */
2282         if (!(s->s3->tmp.new_cipher->algorithm_auth & (SSL_aNULL | SSL_aSRP))
2283             && !(alg_k & SSL_PSK)) {
2284             /* Might be wrong key type, check it */
2285             if (ssl3_check_cert_and_algorithm(s)) {
2286                 /* Otherwise this shouldn't happen */
2287                 al = SSL_AD_INTERNAL_ERROR;
2288                 SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2289             } else {
2290                 al = SSL_AD_DECODE_ERROR;
2291             }
2292             goto err;
2293         }
2294         /* still data left over */
2295         if (PACKET_remaining(pkt) != 0) {
2296             al = SSL_AD_DECODE_ERROR;
2297             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, SSL_R_EXTRA_DATA_IN_MESSAGE);
2298             goto err;
2299         }
2300     }
2301
2302     return MSG_PROCESS_CONTINUE_READING;
2303  err:
2304     if (al != -1)
2305         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2306     ossl_statem_set_error(s);
2307     EVP_MD_CTX_free(md_ctx);
2308     return MSG_PROCESS_ERROR;
2309 }
2310
2311 MSG_PROCESS_RETURN tls_process_certificate_request(SSL *s, PACKET *pkt)
2312 {
2313     int ret = MSG_PROCESS_ERROR;
2314     int al = SSL_AD_DECODE_ERROR;
2315     size_t i;
2316
2317     /* Clear certificate validity flags */
2318     for (i = 0; i < SSL_PKEY_NUM; i++)
2319         s->s3->tmp.valid_flags[i] = 0;
2320
2321     if (SSL_IS_TLS13(s)) {
2322         PACKET reqctx, extensions;
2323         RAW_EXTENSION *rawexts = NULL;
2324
2325         /* Free and zero certificate types: it is not present in TLS 1.3 */
2326         OPENSSL_free(s->s3->tmp.ctype);
2327         s->s3->tmp.ctype = NULL;
2328         s->s3->tmp.ctype_len = 0;
2329
2330         /* TODO(TLS1.3) need to process request context, for now ignore */
2331         if (!PACKET_get_length_prefixed_1(pkt, &reqctx)) {
2332             SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST,
2333                    SSL_R_LENGTH_MISMATCH);
2334             goto err;
2335         }
2336
2337         if (!PACKET_get_length_prefixed_2(pkt, &extensions)) {
2338                 SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST, SSL_R_BAD_LENGTH);
2339                 goto err;
2340         }
2341         if (!tls_collect_extensions(s, &extensions,
2342                                     SSL_EXT_TLS1_3_CERTIFICATE_REQUEST,
2343                                     &rawexts, &al, NULL)
2344             || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_CERTIFICATE_REQUEST,
2345                                          rawexts, NULL, 0, &al)) {
2346             OPENSSL_free(rawexts);
2347             goto err;
2348         }
2349         OPENSSL_free(rawexts);
2350         if (!tls1_process_sigalgs(s)) {
2351             al = SSL_AD_INTERNAL_ERROR;
2352             SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST, ERR_R_MALLOC_FAILURE);
2353             goto err;
2354         }
2355     } else {
2356         PACKET ctypes;
2357
2358         /* get the certificate types */
2359         if (!PACKET_get_length_prefixed_1(pkt, &ctypes)) {
2360             SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST,
2361                    SSL_R_LENGTH_MISMATCH);
2362             goto err;
2363         }
2364
2365         if (!PACKET_memdup(&ctypes, &s->s3->tmp.ctype, &s->s3->tmp.ctype_len)) {
2366             al = SSL_AD_INTERNAL_ERROR;
2367             SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST, ERR_R_INTERNAL_ERROR);
2368             goto err;
2369         }
2370
2371         if (SSL_USE_SIGALGS(s)) {
2372             PACKET sigalgs;
2373
2374             if (!PACKET_get_length_prefixed_2(pkt, &sigalgs)) {
2375                 SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST,
2376                        SSL_R_LENGTH_MISMATCH);
2377                 goto err;
2378             }
2379
2380             if (!tls1_save_sigalgs(s, &sigalgs)) {
2381                 SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST,
2382                        SSL_R_SIGNATURE_ALGORITHMS_ERROR);
2383                 goto err;
2384             }
2385             if (!tls1_process_sigalgs(s)) {
2386                 al = SSL_AD_INTERNAL_ERROR;
2387                 SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST,
2388                        ERR_R_MALLOC_FAILURE);
2389                 goto err;
2390             }
2391         }
2392
2393         /* get the CA RDNs */
2394         if (!parse_ca_names(s, pkt, &al))
2395             goto err;
2396     }
2397
2398     if (PACKET_remaining(pkt) != 0) {
2399         SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST, SSL_R_LENGTH_MISMATCH);
2400         goto err;
2401     }
2402
2403     /* we should setup a certificate to return.... */
2404     s->s3->tmp.cert_req = 1;
2405
2406     ret = MSG_PROCESS_CONTINUE_PROCESSING;
2407     goto done;
2408  err:
2409     ssl3_send_alert(s, SSL3_AL_FATAL, al);
2410     ossl_statem_set_error(s);
2411  done:
2412     return ret;
2413 }
2414
2415 MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL *s, PACKET *pkt)
2416 {
2417     int al = SSL_AD_DECODE_ERROR;
2418     unsigned int ticklen;
2419     unsigned long ticket_lifetime_hint, age_add = 0;
2420     unsigned int sess_len;
2421     RAW_EXTENSION *exts = NULL;
2422
2423     if (!PACKET_get_net_4(pkt, &ticket_lifetime_hint)
2424         || (SSL_IS_TLS13(s) && !PACKET_get_net_4(pkt, &age_add))
2425         || !PACKET_get_net_2(pkt, &ticklen)
2426         || (!SSL_IS_TLS13(s) && PACKET_remaining(pkt) != ticklen)
2427         || (SSL_IS_TLS13(s)
2428             && (ticklen == 0 || PACKET_remaining(pkt) < ticklen))) {
2429         SSLerr(SSL_F_TLS_PROCESS_NEW_SESSION_TICKET, SSL_R_LENGTH_MISMATCH);
2430         goto f_err;
2431     }
2432
2433     /*
2434      * Server is allowed to change its mind (in <=TLSv1.2) and send an empty
2435      * ticket. We already checked this TLSv1.3 case above, so it should never
2436      * be 0 here in that instance
2437      */
2438     if (ticklen == 0)
2439         return MSG_PROCESS_CONTINUE_READING;
2440
2441     if (s->session->session_id_length > 0) {
2442         int i = s->session_ctx->session_cache_mode;
2443         SSL_SESSION *new_sess;
2444         /*
2445          * We reused an existing session, so we need to replace it with a new
2446          * one
2447          */
2448         if (i & SSL_SESS_CACHE_CLIENT) {
2449             /*
2450              * Remove the old session from the cache. We carry on if this fails
2451              */
2452             SSL_CTX_remove_session(s->session_ctx, s->session);
2453         }
2454
2455         if ((new_sess = ssl_session_dup(s->session, 0)) == 0) {
2456             al = SSL_AD_INTERNAL_ERROR;
2457             SSLerr(SSL_F_TLS_PROCESS_NEW_SESSION_TICKET, ERR_R_MALLOC_FAILURE);
2458             goto f_err;
2459         }
2460
2461         SSL_SESSION_free(s->session);
2462         s->session = new_sess;
2463     }
2464
2465     /*
2466      * Technically the cast to long here is not guaranteed by the C standard -
2467      * but we use it elsewhere, so this should be ok.
2468      */
2469     s->session->time = (long)time(NULL);
2470
2471     OPENSSL_free(s->session->ext.tick);
2472     s->session->ext.tick = NULL;
2473     s->session->ext.ticklen = 0;
2474
2475     s->session->ext.tick = OPENSSL_malloc(ticklen);
2476     if (s->session->ext.tick == NULL) {
2477         SSLerr(SSL_F_TLS_PROCESS_NEW_SESSION_TICKET, ERR_R_MALLOC_FAILURE);
2478         goto err;
2479     }
2480     if (!PACKET_copy_bytes(pkt, s->session->ext.tick, ticklen)) {
2481         al = SSL_AD_DECODE_ERROR;
2482         SSLerr(SSL_F_TLS_PROCESS_NEW_SESSION_TICKET, SSL_R_LENGTH_MISMATCH);
2483         goto f_err;
2484     }
2485
2486     s->session->ext.tick_lifetime_hint = ticket_lifetime_hint;
2487     s->session->ext.tick_age_add = age_add;
2488     s->session->ext.ticklen = ticklen;
2489
2490     if (SSL_IS_TLS13(s)) {
2491         PACKET extpkt;
2492
2493         if (!PACKET_as_length_prefixed_2(pkt, &extpkt)
2494                 || !tls_collect_extensions(s, &extpkt,
2495                                            SSL_EXT_TLS1_3_NEW_SESSION_TICKET,
2496                                            &exts, &al, NULL)
2497                 || !tls_parse_all_extensions(s,
2498                                              SSL_EXT_TLS1_3_NEW_SESSION_TICKET,
2499                                              exts, NULL, 0, &al)) {
2500             SSLerr(SSL_F_TLS_PROCESS_NEW_SESSION_TICKET, SSL_R_BAD_EXTENSION);
2501             goto f_err;
2502         }
2503     }
2504
2505     /*
2506      * There are two ways to detect a resumed ticket session. One is to set
2507      * an appropriate session ID and then the server must return a match in
2508      * ServerHello. This allows the normal client session ID matching to work
2509      * and we know much earlier that the ticket has been accepted. The
2510      * other way is to set zero length session ID when the ticket is
2511      * presented and rely on the handshake to determine session resumption.
2512      * We choose the former approach because this fits in with assumptions
2513      * elsewhere in OpenSSL. The session ID is set to the SHA256 (or SHA1 is
2514      * SHA256 is disabled) hash of the ticket.
2515      */
2516     /*
2517      * TODO(size_t): we use sess_len here because EVP_Digest expects an int
2518      * but s->session->session_id_length is a size_t
2519      */
2520     if (!EVP_Digest(s->session->ext.tick, ticklen,
2521                     s->session->session_id, &sess_len,
2522                     EVP_sha256(), NULL)) {
2523         SSLerr(SSL_F_TLS_PROCESS_NEW_SESSION_TICKET, ERR_R_EVP_LIB);
2524         goto err;
2525     }
2526     s->session->session_id_length = sess_len;
2527
2528     /* This is a standalone message in TLSv1.3, so there is no more to read */
2529     if (SSL_IS_TLS13(s)) {
2530         OPENSSL_free(exts);
2531         ssl_update_cache(s, SSL_SESS_CACHE_CLIENT);
2532         return MSG_PROCESS_FINISHED_READING;
2533     }
2534
2535     return MSG_PROCESS_CONTINUE_READING;
2536  f_err:
2537     ssl3_send_alert(s, SSL3_AL_FATAL, al);
2538  err:
2539     ossl_statem_set_error(s);
2540     OPENSSL_free(exts);
2541     return MSG_PROCESS_ERROR;
2542 }
2543
2544 /*
2545  * In TLSv1.3 this is called from the extensions code, otherwise it is used to
2546  * parse a separate message. Returns 1 on success or 0 on failure. On failure
2547  * |*al| is populated with a suitable alert code.
2548  */
2549 int tls_process_cert_status_body(SSL *s, PACKET *pkt, int *al)
2550 {
2551     size_t resplen;
2552     unsigned int type;
2553
2554     if (!PACKET_get_1(pkt, &type)
2555         || type != TLSEXT_STATUSTYPE_ocsp) {
2556         *al = SSL_AD_DECODE_ERROR;
2557         SSLerr(SSL_F_TLS_PROCESS_CERT_STATUS_BODY,
2558                SSL_R_UNSUPPORTED_STATUS_TYPE);
2559         return 0;
2560     }
2561     if (!PACKET_get_net_3_len(pkt, &resplen)
2562         || PACKET_remaining(pkt) != resplen) {
2563         *al = SSL_AD_DECODE_ERROR;
2564         SSLerr(SSL_F_TLS_PROCESS_CERT_STATUS_BODY, SSL_R_LENGTH_MISMATCH);
2565         return 0;
2566     }
2567     s->ext.ocsp.resp = OPENSSL_malloc(resplen);
2568     if (s->ext.ocsp.resp == NULL) {
2569         *al = SSL_AD_INTERNAL_ERROR;
2570         SSLerr(SSL_F_TLS_PROCESS_CERT_STATUS_BODY, ERR_R_MALLOC_FAILURE);
2571         return 0;
2572     }
2573     if (!PACKET_copy_bytes(pkt, s->ext.ocsp.resp, resplen)) {
2574         *al = SSL_AD_DECODE_ERROR;
2575         SSLerr(SSL_F_TLS_PROCESS_CERT_STATUS_BODY, SSL_R_LENGTH_MISMATCH);
2576         return 0;
2577     }
2578     s->ext.ocsp.resp_len = resplen;
2579
2580     return 1;
2581 }
2582
2583
2584 MSG_PROCESS_RETURN tls_process_cert_status(SSL *s, PACKET *pkt)
2585 {
2586     int al;
2587
2588     if (!tls_process_cert_status_body(s, pkt, &al)) {
2589         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2590         ossl_statem_set_error(s);
2591         return MSG_PROCESS_ERROR;
2592     }
2593
2594     return MSG_PROCESS_CONTINUE_READING;
2595 }
2596
2597 /*
2598  * Perform miscellaneous checks and processing after we have received the
2599  * server's initial flight. In TLS1.3 this is after the Server Finished message.
2600  * In <=TLS1.2 this is after the ServerDone message. Returns 1 on success or 0
2601  * on failure.
2602  */
2603 int tls_process_initial_server_flight(SSL *s, int *al)
2604 {
2605     /*
2606      * at this point we check that we have the required stuff from
2607      * the server
2608      */
2609     if (!ssl3_check_cert_and_algorithm(s)) {
2610         *al = SSL_AD_HANDSHAKE_FAILURE;
2611         return 0;
2612     }
2613
2614     /*
2615      * Call the ocsp status callback if needed. The |ext.ocsp.resp| and
2616      * |ext.ocsp.resp_len| values will be set if we actually received a status
2617      * message, or NULL and -1 otherwise
2618      */
2619     if (s->ext.status_type != TLSEXT_STATUSTYPE_nothing
2620             && s->ctx->ext.status_cb != NULL) {
2621         int ret = s->ctx->ext.status_cb(s, s->ctx->ext.status_arg);
2622
2623         if (ret == 0) {
2624             *al = SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE;
2625             SSLerr(SSL_F_TLS_PROCESS_INITIAL_SERVER_FLIGHT,
2626                    SSL_R_INVALID_STATUS_RESPONSE);
2627             return 0;
2628         }
2629         if (ret < 0) {
2630             *al = SSL_AD_INTERNAL_ERROR;
2631             SSLerr(SSL_F_TLS_PROCESS_INITIAL_SERVER_FLIGHT,
2632                    ERR_R_MALLOC_FAILURE);
2633             return 0;
2634         }
2635     }
2636 #ifndef OPENSSL_NO_CT
2637     if (s->ct_validation_callback != NULL) {
2638         /* Note we validate the SCTs whether or not we abort on error */
2639         if (!ssl_validate_ct(s) && (s->verify_mode & SSL_VERIFY_PEER)) {
2640             *al = SSL_AD_HANDSHAKE_FAILURE;
2641             return 0;
2642         }
2643     }
2644 #endif
2645
2646     return 1;
2647 }
2648
2649 MSG_PROCESS_RETURN tls_process_server_done(SSL *s, PACKET *pkt)
2650 {
2651     int al = SSL_AD_INTERNAL_ERROR;
2652
2653     if (PACKET_remaining(pkt) > 0) {
2654         /* should contain no data */
2655         al = SSL_AD_DECODE_ERROR;
2656         SSLerr(SSL_F_TLS_PROCESS_SERVER_DONE, SSL_R_LENGTH_MISMATCH);
2657         goto err;
2658     }
2659 #ifndef OPENSSL_NO_SRP
2660     if (s->s3->tmp.new_cipher->algorithm_mkey & SSL_kSRP) {
2661         if (SRP_Calc_A_param(s) <= 0) {
2662             SSLerr(SSL_F_TLS_PROCESS_SERVER_DONE, SSL_R_SRP_A_CALC);
2663             goto err;
2664         }
2665     }
2666 #endif
2667
2668     /*
2669      * Error queue messages are generated directly by this function
2670      */
2671     if (!tls_process_initial_server_flight(s, &al))
2672         goto err;
2673
2674     return MSG_PROCESS_FINISHED_READING;
2675
2676  err:
2677     ssl3_send_alert(s, SSL3_AL_FATAL, al);
2678     ossl_statem_set_error(s);
2679     return MSG_PROCESS_ERROR;
2680 }
2681
2682 static int tls_construct_cke_psk_preamble(SSL *s, WPACKET *pkt, int *al)
2683 {
2684 #ifndef OPENSSL_NO_PSK
2685     int ret = 0;
2686     /*
2687      * The callback needs PSK_MAX_IDENTITY_LEN + 1 bytes to return a
2688      * \0-terminated identity. The last byte is for us for simulating
2689      * strnlen.
2690      */
2691     char identity[PSK_MAX_IDENTITY_LEN + 1];
2692     size_t identitylen = 0;
2693     unsigned char psk[PSK_MAX_PSK_LEN];
2694     unsigned char *tmppsk = NULL;
2695     char *tmpidentity = NULL;
2696     size_t psklen = 0;
2697
2698     if (s->psk_client_callback == NULL) {
2699         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE, SSL_R_PSK_NO_CLIENT_CB);
2700         *al = SSL_AD_INTERNAL_ERROR;
2701         goto err;
2702     }
2703
2704     memset(identity, 0, sizeof(identity));
2705
2706     psklen = s->psk_client_callback(s, s->session->psk_identity_hint,
2707                                     identity, sizeof(identity) - 1,
2708                                     psk, sizeof(psk));
2709
2710     if (psklen > PSK_MAX_PSK_LEN) {
2711         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE, ERR_R_INTERNAL_ERROR);
2712         *al = SSL_AD_HANDSHAKE_FAILURE;
2713         goto err;
2714     } else if (psklen == 0) {
2715         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE,
2716                SSL_R_PSK_IDENTITY_NOT_FOUND);
2717         *al = SSL_AD_HANDSHAKE_FAILURE;
2718         goto err;
2719     }
2720
2721     identitylen = strlen(identity);
2722     if (identitylen > PSK_MAX_IDENTITY_LEN) {
2723         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE, ERR_R_INTERNAL_ERROR);
2724         *al = SSL_AD_HANDSHAKE_FAILURE;
2725         goto err;
2726     }
2727
2728     tmppsk = OPENSSL_memdup(psk, psklen);
2729     tmpidentity = OPENSSL_strdup(identity);
2730     if (tmppsk == NULL || tmpidentity == NULL) {
2731         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE, ERR_R_MALLOC_FAILURE);
2732         *al = SSL_AD_INTERNAL_ERROR;
2733         goto err;
2734     }
2735
2736     OPENSSL_free(s->s3->tmp.psk);
2737     s->s3->tmp.psk = tmppsk;
2738     s->s3->tmp.psklen = psklen;
2739     tmppsk = NULL;
2740     OPENSSL_free(s->session->psk_identity);
2741     s->session->psk_identity = tmpidentity;
2742     tmpidentity = NULL;
2743
2744     if (!WPACKET_sub_memcpy_u16(pkt, identity, identitylen))  {
2745         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE, ERR_R_INTERNAL_ERROR);
2746         *al = SSL_AD_INTERNAL_ERROR;
2747         goto err;
2748     }
2749
2750     ret = 1;
2751
2752  err:
2753     OPENSSL_cleanse(psk, psklen);
2754     OPENSSL_cleanse(identity, sizeof(identity));
2755     OPENSSL_clear_free(tmppsk, psklen);
2756     OPENSSL_clear_free(tmpidentity, identitylen);
2757
2758     return ret;
2759 #else
2760     SSLerr(SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE, ERR_R_INTERNAL_ERROR);
2761     *al = SSL_AD_INTERNAL_ERROR;
2762     return 0;
2763 #endif
2764 }
2765
2766 static int tls_construct_cke_rsa(SSL *s, WPACKET *pkt, int *al)
2767 {
2768 #ifndef OPENSSL_NO_RSA
2769     unsigned char *encdata = NULL;
2770     EVP_PKEY *pkey = NULL;
2771     EVP_PKEY_CTX *pctx = NULL;
2772     size_t enclen;
2773     unsigned char *pms = NULL;
2774     size_t pmslen = 0;
2775
2776     if (s->session->peer == NULL) {
2777         /*
2778          * We should always have a server certificate with SSL_kRSA.
2779          */
2780         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_RSA, ERR_R_INTERNAL_ERROR);
2781         return 0;
2782     }
2783
2784     pkey = X509_get0_pubkey(s->session->peer);
2785     if (EVP_PKEY_get0_RSA(pkey) == NULL) {
2786         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_RSA, ERR_R_INTERNAL_ERROR);
2787         return 0;
2788     }
2789
2790     pmslen = SSL_MAX_MASTER_KEY_LENGTH;
2791     pms = OPENSSL_malloc(pmslen);
2792     if (pms == NULL) {
2793         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_RSA, ERR_R_MALLOC_FAILURE);
2794         *al = SSL_AD_INTERNAL_ERROR;
2795         return 0;
2796     }
2797
2798     pms[0] = s->client_version >> 8;
2799     pms[1] = s->client_version & 0xff;
2800     /* TODO(size_t): Convert this function */
2801     if (RAND_bytes(pms + 2, (int)(pmslen - 2)) <= 0) {
2802         goto err;
2803     }
2804
2805     /* Fix buf for TLS and beyond */
2806     if (s->version > SSL3_VERSION && !WPACKET_start_sub_packet_u16(pkt)) {
2807         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_RSA, ERR_R_INTERNAL_ERROR);
2808         goto err;
2809     }
2810     pctx = EVP_PKEY_CTX_new(pkey, NULL);
2811     if (pctx == NULL || EVP_PKEY_encrypt_init(pctx) <= 0
2812         || EVP_PKEY_encrypt(pctx, NULL, &enclen, pms, pmslen) <= 0) {
2813         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_RSA, ERR_R_EVP_LIB);
2814         goto err;
2815     }
2816     if (!WPACKET_allocate_bytes(pkt, enclen, &encdata)
2817             || EVP_PKEY_encrypt(pctx, encdata, &enclen, pms, pmslen) <= 0) {
2818         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_RSA, SSL_R_BAD_RSA_ENCRYPT);
2819         goto err;
2820     }
2821     EVP_PKEY_CTX_free(pctx);
2822     pctx = NULL;
2823
2824     /* Fix buf for TLS and beyond */
2825     if (s->version > SSL3_VERSION && !WPACKET_close(pkt)) {
2826         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_RSA, ERR_R_INTERNAL_ERROR);
2827         goto err;
2828     }
2829
2830     /* Log the premaster secret, if logging is enabled. */
2831     if (!ssl_log_rsa_client_key_exchange(s, encdata, enclen, pms, pmslen))
2832         goto err;
2833
2834     s->s3->tmp.pms = pms;
2835     s->s3->tmp.pmslen = pmslen;
2836
2837     return 1;
2838  err:
2839     OPENSSL_clear_free(pms, pmslen);
2840     EVP_PKEY_CTX_free(pctx);
2841
2842     return 0;
2843 #else
2844     SSLerr(SSL_F_TLS_CONSTRUCT_CKE_RSA, ERR_R_INTERNAL_ERROR);
2845     *al = SSL_AD_INTERNAL_ERROR;
2846     return 0;
2847 #endif
2848 }
2849
2850 static int tls_construct_cke_dhe(SSL *s, WPACKET *pkt, int *al)
2851 {
2852 #ifndef OPENSSL_NO_DH
2853     DH *dh_clnt = NULL;
2854     const BIGNUM *pub_key;
2855     EVP_PKEY *ckey = NULL, *skey = NULL;
2856     unsigned char *keybytes = NULL;
2857
2858     skey = s->s3->peer_tmp;
2859     if (skey == NULL)
2860         goto err;
2861
2862     ckey = ssl_generate_pkey(skey);
2863     if (ckey == NULL)
2864         goto err;
2865
2866     dh_clnt = EVP_PKEY_get0_DH(ckey);
2867
2868     if (dh_clnt == NULL || ssl_derive(s, ckey, skey, 0) == 0)
2869         goto err;
2870
2871     /* send off the data */
2872     DH_get0_key(dh_clnt, &pub_key, NULL);
2873     if (!WPACKET_sub_allocate_bytes_u16(pkt, BN_num_bytes(pub_key), &keybytes))
2874         goto err;
2875
2876     BN_bn2bin(pub_key, keybytes);
2877     EVP_PKEY_free(ckey);
2878
2879     return 1;
2880  err:
2881     EVP_PKEY_free(ckey);
2882 #endif
2883     SSLerr(SSL_F_TLS_CONSTRUCT_CKE_DHE, ERR_R_INTERNAL_ERROR);
2884     *al = SSL_AD_INTERNAL_ERROR;
2885     return 0;
2886 }
2887
2888 static int tls_construct_cke_ecdhe(SSL *s, WPACKET *pkt, int *al)
2889 {
2890 #ifndef OPENSSL_NO_EC
2891     unsigned char *encodedPoint = NULL;
2892     size_t encoded_pt_len = 0;
2893     EVP_PKEY *ckey = NULL, *skey = NULL;
2894     int ret = 0;
2895
2896     skey = s->s3->peer_tmp;
2897     if (skey == NULL) {
2898         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_ECDHE, ERR_R_INTERNAL_ERROR);
2899         return 0;
2900     }
2901
2902     ckey = ssl_generate_pkey(skey);
2903     if (ckey == NULL) {
2904         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_ECDHE, ERR_R_MALLOC_FAILURE);
2905         goto err;
2906     }
2907
2908     if (ssl_derive(s, ckey, skey, 0) == 0) {
2909         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_ECDHE, ERR_R_EVP_LIB);
2910         goto err;
2911     }
2912
2913     /* Generate encoding of client key */
2914     encoded_pt_len = EVP_PKEY_get1_tls_encodedpoint(ckey, &encodedPoint);
2915
2916     if (encoded_pt_len == 0) {
2917         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_ECDHE, ERR_R_EC_LIB);
2918         goto err;
2919     }
2920
2921     if (!WPACKET_sub_memcpy_u8(pkt, encodedPoint, encoded_pt_len)) {
2922         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_ECDHE, ERR_R_INTERNAL_ERROR);
2923         goto err;
2924     }
2925
2926     ret = 1;
2927  err:
2928     OPENSSL_free(encodedPoint);
2929     EVP_PKEY_free(ckey);
2930     return ret;
2931 #else
2932     SSLerr(SSL_F_TLS_CONSTRUCT_CKE_ECDHE, ERR_R_INTERNAL_ERROR);
2933     *al = SSL_AD_INTERNAL_ERROR;
2934     return 0;
2935 #endif
2936 }
2937
2938 static int tls_construct_cke_gost(SSL *s, WPACKET *pkt, int *al)
2939 {
2940 #ifndef OPENSSL_NO_GOST
2941     /* GOST key exchange message creation */
2942     EVP_PKEY_CTX *pkey_ctx = NULL;
2943     X509 *peer_cert;
2944     size_t msglen;
2945     unsigned int md_len;
2946     unsigned char shared_ukm[32], tmp[256];
2947     EVP_MD_CTX *ukm_hash = NULL;
2948     int dgst_nid = NID_id_GostR3411_94;
2949     unsigned char *pms = NULL;
2950     size_t pmslen = 0;
2951
2952     if ((s->s3->tmp.new_cipher->algorithm_auth & SSL_aGOST12) != 0)
2953         dgst_nid = NID_id_GostR3411_2012_256;
2954
2955     /*
2956      * Get server certificate PKEY and create ctx from it
2957      */
2958     peer_cert = s->session->peer;
2959     if (!peer_cert) {
2960         *al = SSL_AD_HANDSHAKE_FAILURE;
2961         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_GOST,
2962                SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER);
2963         return 0;
2964     }
2965
2966     pkey_ctx = EVP_PKEY_CTX_new(X509_get0_pubkey(peer_cert), NULL);
2967     if (pkey_ctx == NULL) {
2968         *al = SSL_AD_INTERNAL_ERROR;
2969         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_GOST, ERR_R_MALLOC_FAILURE);
2970         return 0;
2971     }
2972     /*
2973      * If we have send a certificate, and certificate key
2974      * parameters match those of server certificate, use
2975      * certificate key for key exchange
2976      */
2977
2978     /* Otherwise, generate ephemeral key pair */
2979     pmslen = 32;
2980     pms = OPENSSL_malloc(pmslen);
2981     if (pms == NULL) {
2982         *al = SSL_AD_INTERNAL_ERROR;
2983         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_GOST, ERR_R_MALLOC_FAILURE);
2984         goto err;
2985     }
2986
2987     if (EVP_PKEY_encrypt_init(pkey_ctx) <= 0
2988         /* Generate session key
2989          * TODO(size_t): Convert this function
2990          */
2991         || RAND_bytes(pms, (int)pmslen) <= 0) {
2992         *al = SSL_AD_INTERNAL_ERROR;
2993         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_GOST, ERR_R_INTERNAL_ERROR);
2994         goto err;
2995     };
2996     /*
2997      * Compute shared IV and store it in algorithm-specific context
2998      * data
2999      */
3000     ukm_hash = EVP_MD_CTX_new();
3001     if (ukm_hash == NULL
3002         || EVP_DigestInit(ukm_hash, EVP_get_digestbynid(dgst_nid)) <= 0
3003         || EVP_DigestUpdate(ukm_hash, s->s3->client_random,
3004                             SSL3_RANDOM_SIZE) <= 0
3005         || EVP_DigestUpdate(ukm_hash, s->s3->server_random,
3006                             SSL3_RANDOM_SIZE) <= 0
3007         || EVP_DigestFinal_ex(ukm_hash, shared_ukm, &md_len) <= 0) {
3008         *al = SSL_AD_INTERNAL_ERROR;
3009         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_GOST, ERR_R_INTERNAL_ERROR);
3010         goto err;
3011     }
3012     EVP_MD_CTX_free(ukm_hash);
3013     ukm_hash = NULL;
3014     if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_ENCRYPT,
3015                           EVP_PKEY_CTRL_SET_IV, 8, shared_ukm) < 0) {
3016         *al = SSL_AD_INTERNAL_ERROR;
3017         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_GOST, SSL_R_LIBRARY_BUG);
3018         goto err;
3019     }
3020     /* Make GOST keytransport blob message */
3021     /*
3022      * Encapsulate it into sequence
3023      */
3024     msglen = 255;
3025     if (EVP_PKEY_encrypt(pkey_ctx, tmp, &msglen, pms, pmslen) <= 0) {
3026         *al = SSL_AD_INTERNAL_ERROR;
3027         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_GOST, SSL_R_LIBRARY_BUG);
3028         goto err;
3029     }
3030
3031     if (!WPACKET_put_bytes_u8(pkt, V_ASN1_SEQUENCE | V_ASN1_CONSTRUCTED)
3032             || (msglen >= 0x80 && !WPACKET_put_bytes_u8(pkt, 0x81))
3033             || !WPACKET_sub_memcpy_u8(pkt, tmp, msglen)) {
3034         *al = SSL_AD_INTERNAL_ERROR;
3035         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_GOST, ERR_R_INTERNAL_ERROR);
3036         goto err;
3037     }
3038
3039     EVP_PKEY_CTX_free(pkey_ctx);
3040     s->s3->tmp.pms = pms;
3041     s->s3->tmp.pmslen = pmslen;
3042
3043     return 1;
3044  err:
3045     EVP_PKEY_CTX_free(pkey_ctx);
3046     OPENSSL_clear_free(pms, pmslen);
3047     EVP_MD_CTX_free(ukm_hash);
3048     return 0;
3049 #else
3050     SSLerr(SSL_F_TLS_CONSTRUCT_CKE_GOST, ERR_R_INTERNAL_ERROR);
3051     *al = SSL_AD_INTERNAL_ERROR;
3052     return 0;
3053 #endif
3054 }
3055
3056 static int tls_construct_cke_srp(SSL *s, WPACKET *pkt, int *al)
3057 {
3058 #ifndef OPENSSL_NO_SRP
3059     unsigned char *abytes = NULL;
3060
3061     if (s->srp_ctx.A == NULL
3062             || !WPACKET_sub_allocate_bytes_u16(pkt, BN_num_bytes(s->srp_ctx.A),
3063                                                &abytes)) {
3064         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_SRP, ERR_R_INTERNAL_ERROR);
3065         return 0;
3066     }
3067     BN_bn2bin(s->srp_ctx.A, abytes);
3068
3069     OPENSSL_free(s->session->srp_username);
3070     s->session->srp_username = OPENSSL_strdup(s->srp_ctx.login);
3071     if (s->session->srp_username == NULL) {
3072         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_SRP, ERR_R_MALLOC_FAILURE);
3073         return 0;
3074     }
3075
3076     return 1;
3077 #else
3078     SSLerr(SSL_F_TLS_CONSTRUCT_CKE_SRP, ERR_R_INTERNAL_ERROR);
3079     *al = SSL_AD_INTERNAL_ERROR;
3080     return 0;
3081 #endif
3082 }
3083
3084 int tls_construct_client_key_exchange(SSL *s, WPACKET *pkt)
3085 {
3086     unsigned long alg_k;
3087     int al = -1;
3088
3089     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
3090
3091     if ((alg_k & SSL_PSK)
3092         && !tls_construct_cke_psk_preamble(s, pkt, &al))
3093         goto err;
3094
3095     if (alg_k & (SSL_kRSA | SSL_kRSAPSK)) {
3096         if (!tls_construct_cke_rsa(s, pkt, &al))
3097             goto err;
3098     } else if (alg_k & (SSL_kDHE | SSL_kDHEPSK)) {
3099         if (!tls_construct_cke_dhe(s, pkt, &al))
3100             goto err;
3101     } else if (alg_k & (SSL_kECDHE | SSL_kECDHEPSK)) {
3102         if (!tls_construct_cke_ecdhe(s, pkt, &al))
3103             goto err;
3104     } else if (alg_k & SSL_kGOST) {
3105         if (!tls_construct_cke_gost(s, pkt, &al))
3106             goto err;
3107     } else if (alg_k & SSL_kSRP) {
3108         if (!tls_construct_cke_srp(s, pkt, &al))
3109             goto err;
3110     } else if (!(alg_k & SSL_kPSK)) {
3111         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_HANDSHAKE_FAILURE);
3112         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
3113         goto err;
3114     }
3115
3116     return 1;
3117  err:
3118     if (al != -1)
3119         ssl3_send_alert(s, SSL3_AL_FATAL, al);
3120     OPENSSL_clear_free(s->s3->tmp.pms, s->s3->tmp.pmslen);
3121     s->s3->tmp.pms = NULL;
3122 #ifndef OPENSSL_NO_PSK
3123     OPENSSL_clear_free(s->s3->tmp.psk, s->s3->tmp.psklen);
3124     s->s3->tmp.psk = NULL;
3125 #endif
3126     return 0;
3127 }
3128
3129 int tls_client_key_exchange_post_work(SSL *s)
3130 {
3131     unsigned char *pms = NULL;
3132     size_t pmslen = 0;
3133
3134     pms = s->s3->tmp.pms;
3135     pmslen = s->s3->tmp.pmslen;
3136
3137 #ifndef OPENSSL_NO_SRP
3138     /* Check for SRP */
3139     if (s->s3->tmp.new_cipher->algorithm_mkey & SSL_kSRP) {
3140         if (!srp_generate_client_master_secret(s)) {
3141             SSLerr(SSL_F_TLS_CLIENT_KEY_EXCHANGE_POST_WORK,
3142                    ERR_R_INTERNAL_ERROR);
3143             goto err;
3144         }
3145         return 1;
3146     }
3147 #endif
3148
3149     if (pms == NULL && !(s->s3->tmp.new_cipher->algorithm_mkey & SSL_kPSK)) {
3150         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
3151         SSLerr(SSL_F_TLS_CLIENT_KEY_EXCHANGE_POST_WORK, ERR_R_MALLOC_FAILURE);
3152         goto err;
3153     }
3154     if (!ssl_generate_master_secret(s, pms, pmslen, 1)) {
3155         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
3156         SSLerr(SSL_F_TLS_CLIENT_KEY_EXCHANGE_POST_WORK, ERR_R_INTERNAL_ERROR);
3157         /* ssl_generate_master_secret frees the pms even on error */
3158         pms = NULL;
3159         pmslen = 0;
3160         goto err;
3161     }
3162     pms = NULL;
3163     pmslen = 0;
3164
3165 #ifndef OPENSSL_NO_SCTP
3166     if (SSL_IS_DTLS(s)) {
3167         unsigned char sctpauthkey[64];
3168         char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)];
3169
3170         /*
3171          * Add new shared key for SCTP-Auth, will be ignored if no SCTP
3172          * used.
3173          */
3174         memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL,
3175                sizeof(DTLS1_SCTP_AUTH_LABEL));
3176
3177         if (SSL_export_keying_material(s, sctpauthkey,
3178                                        sizeof(sctpauthkey), labelbuffer,
3179                                        sizeof(labelbuffer), NULL, 0, 0) <= 0)
3180             goto err;
3181
3182         BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
3183                  sizeof(sctpauthkey), sctpauthkey);
3184     }
3185 #endif
3186
3187     return 1;
3188  err:
3189     OPENSSL_clear_free(pms, pmslen);
3190     s->s3->tmp.pms = NULL;
3191     return 0;
3192 }
3193
3194 /*
3195  * Check a certificate can be used for client authentication. Currently check
3196  * cert exists, if we have a suitable digest for TLS 1.2 if static DH client
3197  * certificates can be used and optionally checks suitability for Suite B.
3198  */
3199 static int ssl3_check_client_certificate(SSL *s)
3200 {
3201     /* If no suitable signature algorithm can't use certificate */
3202     if (!tls_choose_sigalg(s, NULL) || s->s3->tmp.sigalg == NULL)
3203         return 0;
3204     /*
3205      * If strict mode check suitability of chain before using it. This also
3206      * adjusts suite B digest if necessary.
3207      */
3208     if (s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT &&
3209         !tls1_check_chain(s, NULL, NULL, NULL, -2))
3210         return 0;
3211     return 1;
3212 }
3213
3214 WORK_STATE tls_prepare_client_certificate(SSL *s, WORK_STATE wst)
3215 {
3216     X509 *x509 = NULL;
3217     EVP_PKEY *pkey = NULL;
3218     int i;
3219
3220     if (wst == WORK_MORE_A) {
3221         /* Let cert callback update client certificates if required */
3222         if (s->cert->cert_cb) {
3223             i = s->cert->cert_cb(s, s->cert->cert_cb_arg);
3224             if (i < 0) {
3225                 s->rwstate = SSL_X509_LOOKUP;
3226                 return WORK_MORE_A;
3227             }
3228             if (i == 0) {
3229                 ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
3230                 ossl_statem_set_error(s);
3231                 return 0;
3232             }
3233             s->rwstate = SSL_NOTHING;
3234         }
3235         if (ssl3_check_client_certificate(s))
3236             return WORK_FINISHED_CONTINUE;
3237
3238         /* Fall through to WORK_MORE_B */
3239         wst = WORK_MORE_B;
3240     }
3241
3242     /* We need to get a client cert */
3243     if (wst == WORK_MORE_B) {
3244         /*
3245          * If we get an error, we need to ssl->rwstate=SSL_X509_LOOKUP;
3246          * return(-1); We then get retied later
3247          */
3248         i = ssl_do_client_cert_cb(s, &x509, &pkey);
3249         if (i < 0) {
3250             s->rwstate = SSL_X509_LOOKUP;
3251             return WORK_MORE_B;
3252         }
3253         s->rwstate = SSL_NOTHING;
3254         if ((i == 1) && (pkey != NULL) && (x509 != NULL)) {
3255             if (!SSL_use_certificate(s, x509) || !SSL_use_PrivateKey(s, pkey))
3256                 i = 0;
3257         } else if (i == 1) {
3258             i = 0;
3259             SSLerr(SSL_F_TLS_PREPARE_CLIENT_CERTIFICATE,
3260                    SSL_R_BAD_DATA_RETURNED_BY_CALLBACK);
3261         }
3262
3263         X509_free(x509);
3264         EVP_PKEY_free(pkey);
3265         if (i && !ssl3_check_client_certificate(s))
3266             i = 0;
3267         if (i == 0) {
3268             if (s->version == SSL3_VERSION) {
3269                 s->s3->tmp.cert_req = 0;
3270                 ssl3_send_alert(s, SSL3_AL_WARNING, SSL_AD_NO_CERTIFICATE);
3271                 return WORK_FINISHED_CONTINUE;
3272             } else {
3273                 s->s3->tmp.cert_req = 2;
3274                 if (!ssl3_digest_cached_records(s, 0)) {
3275                     ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
3276                     ossl_statem_set_error(s);
3277                     return 0;
3278                 }
3279             }
3280         }
3281
3282         return WORK_FINISHED_CONTINUE;
3283     }
3284
3285     /* Shouldn't ever get here */
3286     return WORK_ERROR;
3287 }
3288
3289 int tls_construct_client_certificate(SSL *s, WPACKET *pkt)
3290 {
3291     int al = SSL_AD_INTERNAL_ERROR;
3292
3293     /*
3294      * TODO(TLS1.3): For now we must put an empty context. Needs to be filled in
3295      * later
3296      */
3297     if ((SSL_IS_TLS13(s) && !WPACKET_put_bytes_u8(pkt, 0))
3298             || !ssl3_output_cert_chain(s, pkt,
3299                                (s->s3->tmp.cert_req == 2) ? NULL
3300                                                           : s->cert->key,
3301                                 &al)) {
3302         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_CERTIFICATE, ERR_R_INTERNAL_ERROR);
3303         goto err;
3304     }
3305
3306     if (SSL_IS_TLS13(s)
3307             && SSL_IS_FIRST_HANDSHAKE(s)
3308             && (!s->method->ssl3_enc->change_cipher_state(s,
3309                     SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_WRITE))) {
3310         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_CERTIFICATE,
3311                SSL_R_CANNOT_CHANGE_CIPHER);
3312         goto err;
3313     }
3314
3315     return 1;
3316  err:
3317     ssl3_send_alert(s, SSL3_AL_FATAL, al);
3318     return 0;
3319 }
3320
3321 #define has_bits(i,m)   (((i)&(m)) == (m))
3322
3323 int ssl3_check_cert_and_algorithm(SSL *s)
3324 {
3325     int i;
3326 #ifndef OPENSSL_NO_EC
3327     int idx;
3328 #endif
3329     long alg_k, alg_a;
3330     EVP_PKEY *pkey = NULL;
3331     int al = SSL_AD_HANDSHAKE_FAILURE;
3332
3333     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
3334     alg_a = s->s3->tmp.new_cipher->algorithm_auth;
3335
3336     /* we don't have a certificate */
3337     if ((alg_a & SSL_aNULL) || (alg_k & SSL_kPSK))
3338         return (1);
3339
3340     /* This is the passed certificate */
3341
3342 #ifndef OPENSSL_NO_EC
3343     idx = s->session->peer_type;
3344     if (idx == SSL_PKEY_ECC) {
3345         if (ssl_check_srvr_ecc_cert_and_alg(s->session->peer, s) == 0) {
3346             /* check failed */
3347             SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM, SSL_R_BAD_ECC_CERT);
3348             goto f_err;
3349         } else {
3350             return 1;
3351         }
3352     } else if (alg_a & SSL_aECDSA) {
3353         SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3354                SSL_R_MISSING_ECDSA_SIGNING_CERT);
3355         goto f_err;
3356     }
3357 #endif
3358     pkey = X509_get0_pubkey(s->session->peer);
3359     i = X509_certificate_type(s->session->peer, pkey);
3360
3361     /* Check that we have a certificate if we require one */
3362     if ((alg_a & SSL_aRSA) && !has_bits(i, EVP_PK_RSA | EVP_PKT_SIGN)) {
3363         SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3364                SSL_R_MISSING_RSA_SIGNING_CERT);
3365         goto f_err;
3366     }
3367 #ifndef OPENSSL_NO_DSA
3368     else if ((alg_a & SSL_aDSS) && !has_bits(i, EVP_PK_DSA | EVP_PKT_SIGN)) {
3369         SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3370                SSL_R_MISSING_DSA_SIGNING_CERT);
3371         goto f_err;
3372     }
3373 #endif
3374 #ifndef OPENSSL_NO_RSA
3375     if (alg_k & (SSL_kRSA | SSL_kRSAPSK) &&
3376         !has_bits(i, EVP_PK_RSA | EVP_PKT_ENC)) {
3377         SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3378                SSL_R_MISSING_RSA_ENCRYPTING_CERT);
3379         goto f_err;
3380     }
3381 #endif
3382 #ifndef OPENSSL_NO_DH
3383     if ((alg_k & SSL_kDHE) && (s->s3->peer_tmp == NULL)) {
3384         al = SSL_AD_INTERNAL_ERROR;
3385         SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM, ERR_R_INTERNAL_ERROR);
3386         goto f_err;
3387     }
3388 #endif
3389
3390     return (1);
3391  f_err:
3392     ssl3_send_alert(s, SSL3_AL_FATAL, al);
3393     return (0);
3394 }
3395
3396 #ifndef OPENSSL_NO_NEXTPROTONEG
3397 int tls_construct_next_proto(SSL *s, WPACKET *pkt)
3398 {
3399     size_t len, padding_len;
3400     unsigned char *padding = NULL;
3401
3402     len = s->ext.npn_len;
3403     padding_len = 32 - ((len + 2) % 32);
3404
3405     if (!WPACKET_sub_memcpy_u8(pkt, s->ext.npn, len)
3406             || !WPACKET_sub_allocate_bytes_u8(pkt, padding_len, &padding)) {
3407         SSLerr(SSL_F_TLS_CONSTRUCT_NEXT_PROTO, ERR_R_INTERNAL_ERROR);
3408         goto err;
3409     }
3410
3411     memset(padding, 0, padding_len);
3412
3413     return 1;
3414  err:
3415     ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
3416     return 0;
3417 }
3418 #endif
3419
3420 MSG_PROCESS_RETURN tls_process_hello_req(SSL *s, PACKET *pkt)
3421 {
3422     if (PACKET_remaining(pkt) > 0) {
3423         /* should contain no data */
3424         SSLerr(SSL_F_TLS_PROCESS_HELLO_REQ, SSL_R_LENGTH_MISMATCH);
3425         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
3426         ossl_statem_set_error(s);
3427         return MSG_PROCESS_ERROR;
3428     }
3429
3430     /*
3431      * This is a historical discrepancy (not in the RFC) maintained for
3432      * compatibility reasons. If a TLS client receives a HelloRequest it will
3433      * attempt an abbreviated handshake. However if a DTLS client receives a
3434      * HelloRequest it will do a full handshake. Either behaviour is reasonable
3435      * but doing one for TLS and another for DTLS is odd.
3436      */
3437     if (SSL_IS_DTLS(s))
3438         SSL_renegotiate(s);
3439     else
3440         SSL_renegotiate_abbreviated(s);
3441
3442     return MSG_PROCESS_FINISHED_READING;
3443 }
3444
3445 static MSG_PROCESS_RETURN tls_process_encrypted_extensions(SSL *s, PACKET *pkt)
3446 {
3447     int al = SSL_AD_INTERNAL_ERROR;
3448     PACKET extensions;
3449     RAW_EXTENSION *rawexts = NULL;
3450
3451     if (!PACKET_as_length_prefixed_2(pkt, &extensions)) {
3452         al = SSL_AD_DECODE_ERROR;
3453         SSLerr(SSL_F_TLS_PROCESS_ENCRYPTED_EXTENSIONS, SSL_R_LENGTH_MISMATCH);
3454         goto err;
3455     }
3456
3457     if (!tls_collect_extensions(s, &extensions,
3458                                 SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS, &rawexts,
3459                                 &al, NULL)
3460             || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
3461                                          rawexts, NULL, 0, &al))
3462         goto err;
3463
3464     OPENSSL_free(rawexts);
3465     return MSG_PROCESS_CONTINUE_READING;
3466
3467  err:
3468     ssl3_send_alert(s, SSL3_AL_FATAL, al);
3469     ossl_statem_set_error(s);
3470     OPENSSL_free(rawexts);
3471     return MSG_PROCESS_ERROR;
3472 }
3473
3474 int ssl_do_client_cert_cb(SSL *s, X509 **px509, EVP_PKEY **ppkey)
3475 {
3476     int i = 0;
3477 #ifndef OPENSSL_NO_ENGINE
3478     if (s->ctx->client_cert_engine) {
3479         i = ENGINE_load_ssl_client_cert(s->ctx->client_cert_engine, s,
3480                                         SSL_get_client_CA_list(s),
3481                                         px509, ppkey, NULL, NULL, NULL);
3482         if (i != 0)
3483             return i;
3484     }
3485 #endif
3486     if (s->ctx->client_cert_cb)
3487         i = s->ctx->client_cert_cb(s, px509, ppkey);
3488     return i;
3489 }
3490
3491 int ssl_cipher_list_to_bytes(SSL *s, STACK_OF(SSL_CIPHER) *sk, WPACKET *pkt)
3492 {
3493     int i;
3494     size_t totlen = 0, len, maxlen, maxverok = 0;
3495     int empty_reneg_info_scsv = !s->renegotiate;
3496     /* Set disabled masks for this session */
3497     ssl_set_client_disabled(s);
3498
3499     if (sk == NULL)
3500         return (0);
3501
3502 #ifdef OPENSSL_MAX_TLS1_2_CIPHER_LENGTH
3503 # if OPENSSL_MAX_TLS1_2_CIPHER_LENGTH < 6
3504 #  error Max cipher length too short
3505 # endif
3506     /*
3507      * Some servers hang if client hello > 256 bytes as hack workaround
3508      * chop number of supported ciphers to keep it well below this if we
3509      * use TLS v1.2
3510      */
3511     if (TLS1_get_version(s) >= TLS1_2_VERSION)
3512         maxlen = OPENSSL_MAX_TLS1_2_CIPHER_LENGTH & ~1;
3513     else
3514 #endif
3515         /* Maximum length that can be stored in 2 bytes. Length must be even */
3516         maxlen = 0xfffe;
3517
3518     if (empty_reneg_info_scsv)
3519         maxlen -= 2;
3520     if (s->mode & SSL_MODE_SEND_FALLBACK_SCSV)
3521         maxlen -= 2;
3522
3523     for (i = 0; i < sk_SSL_CIPHER_num(sk) && totlen < maxlen; i++) {
3524         const SSL_CIPHER *c;
3525
3526         c = sk_SSL_CIPHER_value(sk, i);
3527         /* Skip disabled ciphers */
3528         if (ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_SUPPORTED, 0))
3529             continue;
3530
3531         if (!s->method->put_cipher_by_char(c, pkt, &len)) {
3532             SSLerr(SSL_F_SSL_CIPHER_LIST_TO_BYTES, ERR_R_INTERNAL_ERROR);
3533             return 0;
3534         }
3535
3536         /* Sanity check that the maximum version we offer has ciphers enabled */
3537         if (!maxverok) {
3538             if (SSL_IS_DTLS(s)) {
3539                 if (DTLS_VERSION_GE(c->max_dtls, s->s3->tmp.max_ver)
3540                         && DTLS_VERSION_LE(c->min_dtls, s->s3->tmp.max_ver))
3541                     maxverok = 1;
3542             } else {
3543                 if (c->max_tls >= s->s3->tmp.max_ver
3544                         && c->min_tls <= s->s3->tmp.max_ver)
3545                     maxverok = 1;
3546             }
3547         }
3548
3549         totlen += len;
3550     }
3551
3552     if (totlen == 0 || !maxverok) {
3553         SSLerr(SSL_F_SSL_CIPHER_LIST_TO_BYTES, SSL_R_NO_CIPHERS_AVAILABLE);
3554
3555         if (!maxverok)
3556             ERR_add_error_data(1, "No ciphers enabled for max supported "
3557                                   "SSL/TLS version");
3558
3559         return 0;
3560     }
3561
3562     if (totlen != 0) {
3563         if (empty_reneg_info_scsv) {
3564             static SSL_CIPHER scsv = {
3565                 0, NULL, SSL3_CK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0
3566             };
3567             if (!s->method->put_cipher_by_char(&scsv, pkt, &len)) {
3568                 SSLerr(SSL_F_SSL_CIPHER_LIST_TO_BYTES, ERR_R_INTERNAL_ERROR);
3569                 return 0;
3570             }
3571         }
3572         if (s->mode & SSL_MODE_SEND_FALLBACK_SCSV) {
3573             static SSL_CIPHER scsv = {
3574                 0, NULL, SSL3_CK_FALLBACK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0
3575             };
3576             if (!s->method->put_cipher_by_char(&scsv, pkt, &len)) {
3577                 SSLerr(SSL_F_SSL_CIPHER_LIST_TO_BYTES, ERR_R_INTERNAL_ERROR);
3578                 return 0;
3579             }
3580         }
3581     }
3582
3583     return 1;
3584 }
3585
3586 int tls_construct_end_of_early_data(SSL *s, WPACKET *pkt)
3587 {
3588     if (s->early_data_state != SSL_EARLY_DATA_WRITE_RETRY
3589             && s->early_data_state != SSL_EARLY_DATA_FINISHED_WRITING) {
3590         SSLerr(SSL_F_TLS_CONSTRUCT_END_OF_EARLY_DATA,
3591                ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
3592         return 0;
3593     }
3594
3595     s->early_data_state = SSL_EARLY_DATA_FINISHED_WRITING;
3596     return 1;
3597 }