ssl/statem/statem_clnt.c

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