ssl/statem/statem_clnt.c

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