ssl/statem/statem_clnt.c

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