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             && (!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     OPENSSL_free(extensions);
1794     return MSG_PROCESS_CONTINUE_READING;
1795  err:
1796     OPENSSL_free(extensions);
1797     return MSG_PROCESS_ERROR;
1798 }
1799
1800 static MSG_PROCESS_RETURN tls_process_as_hello_retry_request(SSL_CONNECTION *s,
1801                                                              PACKET *extpkt)
1802 {
1803     RAW_EXTENSION *extensions = NULL;
1804
1805     /*
1806      * If we were sending early_data then any alerts should not be sent using
1807      * the old wrlmethod.
1808      */
1809     if (s->early_data_state == SSL_EARLY_DATA_FINISHED_WRITING
1810             && !ssl_set_new_record_layer(s,
1811                                          TLS_ANY_VERSION,
1812                                          OSSL_RECORD_DIRECTION_WRITE,
1813                                          OSSL_RECORD_PROTECTION_LEVEL_NONE,
1814                                          NULL, 0, NULL, 0, NULL, 0, NULL,  0,
1815                                          NULL, 0, NID_undef, NULL, NULL, NULL)) {
1816         /* SSLfatal already called */
1817         goto err;
1818     }
1819     /* We are definitely going to be using TLSv1.3 */
1820     s->rlayer.wrlmethod->set_protocol_version(s->rlayer.wrl, TLS1_3_VERSION);
1821
1822     if (!tls_collect_extensions(s, extpkt, SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST,
1823                                 &extensions, NULL, 1)
1824             || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST,
1825                                          extensions, NULL, 0, 1)) {
1826         /* SSLfatal() already called */
1827         goto err;
1828     }
1829
1830     OPENSSL_free(extensions);
1831     extensions = NULL;
1832
1833     if (s->ext.tls13_cookie_len == 0 && s->s3.tmp.pkey != NULL) {
1834         /*
1835          * We didn't receive a cookie or a new key_share so the next
1836          * ClientHello will not change
1837          */
1838         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_NO_CHANGE_FOLLOWING_HRR);
1839         goto err;
1840     }
1841
1842     /*
1843      * Re-initialise the Transcript Hash. We're going to prepopulate it with
1844      * a synthetic message_hash in place of ClientHello1.
1845      */
1846     if (!create_synthetic_message_hash(s, NULL, 0, NULL, 0)) {
1847         /* SSLfatal() already called */
1848         goto err;
1849     }
1850
1851     /*
1852      * Add this message to the Transcript Hash. Normally this is done
1853      * automatically prior to the message processing stage. However due to the
1854      * need to create the synthetic message hash, we defer that step until now
1855      * for HRR messages.
1856      */
1857     if (!ssl3_finish_mac(s, (unsigned char *)s->init_buf->data,
1858                                 s->init_num + SSL3_HM_HEADER_LENGTH)) {
1859         /* SSLfatal() already called */
1860         goto err;
1861     }
1862
1863     return MSG_PROCESS_FINISHED_READING;
1864  err:
1865     OPENSSL_free(extensions);
1866     return MSG_PROCESS_ERROR;
1867 }
1868
1869 MSG_PROCESS_RETURN tls_process_server_rpk(SSL_CONNECTION *sc, PACKET *pkt)
1870 {
1871     EVP_PKEY *peer_rpk;
1872
1873     if (!tls_process_rpk(sc, pkt, &peer_rpk)) {
1874         /* SSLfatal() already called */
1875         return MSG_PROCESS_ERROR;
1876     }
1877
1878     if (peer_rpk == NULL) {
1879         SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_CERTIFICATE);
1880         return MSG_PROCESS_ERROR;
1881     }
1882
1883     EVP_PKEY_free(sc->session->peer_rpk);
1884     sc->session->peer_rpk = peer_rpk;
1885
1886     return MSG_PROCESS_CONTINUE_PROCESSING;
1887 }
1888
1889 static WORK_STATE tls_post_process_server_rpk(SSL_CONNECTION *sc,
1890                                               WORK_STATE wst)
1891 {
1892     size_t certidx;
1893     const SSL_CERT_LOOKUP *clu;
1894
1895     if (sc->session->peer_rpk == NULL) {
1896         SSLfatal(sc, SSL_AD_ILLEGAL_PARAMETER,
1897                  SSL_R_INVALID_RAW_PUBLIC_KEY);
1898         return WORK_ERROR;
1899     }
1900
1901     if (sc->rwstate == SSL_RETRY_VERIFY)
1902         sc->rwstate = SSL_NOTHING;
1903     if (ssl_verify_rpk(sc, sc->session->peer_rpk) > 0
1904             && sc->rwstate == SSL_RETRY_VERIFY)
1905         return WORK_MORE_A;
1906
1907     if ((clu = ssl_cert_lookup_by_pkey(sc->session->peer_rpk, &certidx,
1908                                        SSL_CONNECTION_GET_CTX(sc))) == NULL) {
1909         SSLfatal(sc, SSL_AD_ILLEGAL_PARAMETER, SSL_R_UNKNOWN_CERTIFICATE_TYPE);
1910         return WORK_ERROR;
1911     }
1912
1913     /*
1914      * Check certificate type is consistent with ciphersuite. For TLS 1.3
1915      * skip check since TLS 1.3 ciphersuites can be used with any certificate
1916      * type.
1917      */
1918     if (!SSL_CONNECTION_IS_TLS13(sc)) {
1919         if ((clu->amask & sc->s3.tmp.new_cipher->algorithm_auth) == 0) {
1920             SSLfatal(sc, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_RPK_TYPE);
1921             return WORK_ERROR;
1922         }
1923     }
1924
1925     /* Ensure there is no peer/peer_chain */
1926     X509_free(sc->session->peer);
1927     sc->session->peer = NULL;
1928     sk_X509_pop_free(sc->session->peer_chain, X509_free);
1929     sc->session->peer_chain = NULL;
1930     sc->session->verify_result = sc->verify_result;
1931
1932     /* Save the current hash state for when we receive the CertificateVerify */
1933     if (SSL_CONNECTION_IS_TLS13(sc)
1934             && !ssl_handshake_hash(sc, sc->cert_verify_hash,
1935                                    sizeof(sc->cert_verify_hash),
1936                                    &sc->cert_verify_hash_len)) {
1937         /* SSLfatal() already called */
1938         return WORK_ERROR;
1939     }
1940
1941     return WORK_FINISHED_CONTINUE;
1942 }
1943
1944 /* prepare server cert verification by setting s->session->peer_chain from pkt */
1945 MSG_PROCESS_RETURN tls_process_server_certificate(SSL_CONNECTION *s,
1946                                                   PACKET *pkt)
1947 {
1948     unsigned long cert_list_len, cert_len;
1949     X509 *x = NULL;
1950     const unsigned char *certstart, *certbytes;
1951     size_t chainidx;
1952     unsigned int context = 0;
1953     SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
1954
1955     if (s->ext.server_cert_type == TLSEXT_cert_type_rpk)
1956         return tls_process_server_rpk(s, pkt);
1957     if (s->ext.server_cert_type != TLSEXT_cert_type_x509) {
1958         SSLfatal(s, SSL_AD_UNSUPPORTED_CERTIFICATE,
1959                  SSL_R_UNKNOWN_CERTIFICATE_TYPE);
1960         goto err;
1961     }
1962
1963     if ((s->session->peer_chain = sk_X509_new_null()) == NULL) {
1964         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
1965         goto err;
1966     }
1967
1968     if ((SSL_CONNECTION_IS_TLS13(s) && !PACKET_get_1(pkt, &context))
1969             || context != 0
1970             || !PACKET_get_net_3(pkt, &cert_list_len)
1971             || PACKET_remaining(pkt) != cert_list_len
1972             || PACKET_remaining(pkt) == 0) {
1973         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
1974         goto err;
1975     }
1976     for (chainidx = 0; PACKET_remaining(pkt); chainidx++) {
1977         if (!PACKET_get_net_3(pkt, &cert_len)
1978             || !PACKET_get_bytes(pkt, &certbytes, cert_len)) {
1979             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_CERT_LENGTH_MISMATCH);
1980             goto err;
1981         }
1982
1983         certstart = certbytes;
1984         x = X509_new_ex(sctx->libctx, sctx->propq);
1985         if (x == NULL) {
1986             SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_ASN1_LIB);
1987             goto err;
1988         }
1989         if (d2i_X509(&x, (const unsigned char **)&certbytes,
1990                      cert_len) == NULL) {
1991             SSLfatal(s, SSL_AD_BAD_CERTIFICATE, ERR_R_ASN1_LIB);
1992             goto err;
1993         }
1994
1995         if (certbytes != (certstart + cert_len)) {
1996             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_CERT_LENGTH_MISMATCH);
1997             goto err;
1998         }
1999
2000         if (SSL_CONNECTION_IS_TLS13(s)) {
2001             RAW_EXTENSION *rawexts = NULL;
2002             PACKET extensions;
2003
2004             if (!PACKET_get_length_prefixed_2(pkt, &extensions)) {
2005                 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_LENGTH);
2006                 goto err;
2007             }
2008             if (!tls_collect_extensions(s, &extensions,
2009                                         SSL_EXT_TLS1_3_CERTIFICATE, &rawexts,
2010                                         NULL, chainidx == 0)
2011                 || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_CERTIFICATE,
2012                                              rawexts, x, chainidx,
2013                                              PACKET_remaining(pkt) == 0)) {
2014                 OPENSSL_free(rawexts);
2015                 /* SSLfatal already called */
2016                 goto err;
2017             }
2018             OPENSSL_free(rawexts);
2019         }
2020
2021         if (!sk_X509_push(s->session->peer_chain, x)) {
2022             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
2023             goto err;
2024         }
2025         x = NULL;
2026     }
2027     return MSG_PROCESS_CONTINUE_PROCESSING;
2028
2029  err:
2030     X509_free(x);
2031     OSSL_STACK_OF_X509_free(s->session->peer_chain);
2032     s->session->peer_chain = NULL;
2033     return MSG_PROCESS_ERROR;
2034 }
2035
2036 /*
2037  * Verify the s->session->peer_chain and check server cert type.
2038  * On success set s->session->peer and s->session->verify_result.
2039  * Else the peer certificate verification callback may request retry.
2040  */
2041 WORK_STATE tls_post_process_server_certificate(SSL_CONNECTION *s,
2042                                                WORK_STATE wst)
2043 {
2044     X509 *x;
2045     EVP_PKEY *pkey = NULL;
2046     const SSL_CERT_LOOKUP *clu;
2047     size_t certidx;
2048     int i;
2049
2050     if (s->ext.server_cert_type == TLSEXT_cert_type_rpk)
2051         return tls_post_process_server_rpk(s, wst);
2052
2053     if (s->rwstate == SSL_RETRY_VERIFY)
2054         s->rwstate = SSL_NOTHING;
2055     i = ssl_verify_cert_chain(s, s->session->peer_chain);
2056     if (i > 0 && s->rwstate == SSL_RETRY_VERIFY) {
2057         return WORK_MORE_A;
2058     }
2059     /*
2060      * The documented interface is that SSL_VERIFY_PEER should be set in order
2061      * for client side verification of the server certificate to take place.
2062      * However, historically the code has only checked that *any* flag is set
2063      * to cause server verification to take place. Use of the other flags makes
2064      * no sense in client mode. An attempt to clean up the semantics was
2065      * reverted because at least one application *only* set
2066      * SSL_VERIFY_FAIL_IF_NO_PEER_CERT. Prior to the clean up this still caused
2067      * server verification to take place, after the clean up it silently did
2068      * nothing. SSL_CTX_set_verify()/SSL_set_verify() cannot validate the flags
2069      * sent to them because they are void functions. Therefore, we now use the
2070      * (less clean) historic behaviour of performing validation if any flag is
2071      * set. The *documented* interface remains the same.
2072      */
2073     if (s->verify_mode != SSL_VERIFY_NONE && i <= 0) {
2074         SSLfatal(s, ssl_x509err2alert(s->verify_result),
2075                  SSL_R_CERTIFICATE_VERIFY_FAILED);
2076         return WORK_ERROR;
2077     }
2078     ERR_clear_error();          /* but we keep s->verify_result */
2079
2080     /*
2081      * Inconsistency alert: cert_chain does include the peer's certificate,
2082      * which we don't include in statem_srvr.c
2083      */
2084     x = sk_X509_value(s->session->peer_chain, 0);
2085
2086     pkey = X509_get0_pubkey(x);
2087
2088     if (pkey == NULL || EVP_PKEY_missing_parameters(pkey)) {
2089         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2090                  SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS);
2091         return WORK_ERROR;
2092     }
2093
2094     if ((clu = ssl_cert_lookup_by_pkey(pkey, &certidx,
2095                                        SSL_CONNECTION_GET_CTX(s))) == NULL) {
2096         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_UNKNOWN_CERTIFICATE_TYPE);
2097         return WORK_ERROR;
2098     }
2099     /*
2100      * Check certificate type is consistent with ciphersuite. For TLS 1.3
2101      * skip check since TLS 1.3 ciphersuites can be used with any certificate
2102      * type.
2103      */
2104     if (!SSL_CONNECTION_IS_TLS13(s)) {
2105         if ((clu->amask & s->s3.tmp.new_cipher->algorithm_auth) == 0) {
2106             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CERTIFICATE_TYPE);
2107             return WORK_ERROR;
2108         }
2109     }
2110
2111     X509_free(s->session->peer);
2112     X509_up_ref(x);
2113     s->session->peer = x;
2114     s->session->verify_result = s->verify_result;
2115     /* Ensure there is no RPK */
2116     EVP_PKEY_free(s->session->peer_rpk);
2117     s->session->peer_rpk = NULL;
2118
2119     /* Save the current hash state for when we receive the CertificateVerify */
2120     if (SSL_CONNECTION_IS_TLS13(s)
2121             && !ssl_handshake_hash(s, s->cert_verify_hash,
2122                                    sizeof(s->cert_verify_hash),
2123                                    &s->cert_verify_hash_len)) {
2124         /* SSLfatal() already called */;
2125         return WORK_ERROR;
2126     }
2127     return WORK_FINISHED_CONTINUE;
2128 }
2129
2130 #ifndef OPENSSL_NO_COMP_ALG
2131 MSG_PROCESS_RETURN tls_process_server_compressed_certificate(SSL_CONNECTION *sc, PACKET *pkt)
2132 {
2133     MSG_PROCESS_RETURN ret = MSG_PROCESS_ERROR;
2134     PACKET tmppkt;
2135     BUF_MEM *buf = BUF_MEM_new();
2136
2137     if (tls13_process_compressed_certificate(sc, pkt, &tmppkt, buf) != MSG_PROCESS_ERROR)
2138         ret = tls_process_server_certificate(sc, &tmppkt);
2139
2140     BUF_MEM_free(buf);
2141     return ret;
2142 }
2143 #endif
2144
2145 static int tls_process_ske_psk_preamble(SSL_CONNECTION *s, PACKET *pkt)
2146 {
2147 #ifndef OPENSSL_NO_PSK
2148     PACKET psk_identity_hint;
2149
2150     /* PSK ciphersuites are preceded by an identity hint */
2151
2152     if (!PACKET_get_length_prefixed_2(pkt, &psk_identity_hint)) {
2153         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
2154         return 0;
2155     }
2156
2157     /*
2158      * Store PSK identity hint for later use, hint is used in
2159      * tls_construct_client_key_exchange.  Assume that the maximum length of
2160      * a PSK identity hint can be as long as the maximum length of a PSK
2161      * identity.
2162      */
2163     if (PACKET_remaining(&psk_identity_hint) > PSK_MAX_IDENTITY_LEN) {
2164         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_DATA_LENGTH_TOO_LONG);
2165         return 0;
2166     }
2167
2168     if (PACKET_remaining(&psk_identity_hint) == 0) {
2169         OPENSSL_free(s->session->psk_identity_hint);
2170         s->session->psk_identity_hint = NULL;
2171     } else if (!PACKET_strndup(&psk_identity_hint,
2172                                &s->session->psk_identity_hint)) {
2173         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
2174         return 0;
2175     }
2176
2177     return 1;
2178 #else
2179     SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
2180     return 0;
2181 #endif
2182 }
2183
2184 static int tls_process_ske_srp(SSL_CONNECTION *s, PACKET *pkt, EVP_PKEY **pkey)
2185 {
2186 #ifndef OPENSSL_NO_SRP
2187     PACKET prime, generator, salt, server_pub;
2188
2189     if (!PACKET_get_length_prefixed_2(pkt, &prime)
2190         || !PACKET_get_length_prefixed_2(pkt, &generator)
2191         || !PACKET_get_length_prefixed_1(pkt, &salt)
2192         || !PACKET_get_length_prefixed_2(pkt, &server_pub)) {
2193         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
2194         return 0;
2195     }
2196
2197     if ((s->srp_ctx.N =
2198          BN_bin2bn(PACKET_data(&prime),
2199                    (int)PACKET_remaining(&prime), NULL)) == NULL
2200         || (s->srp_ctx.g =
2201             BN_bin2bn(PACKET_data(&generator),
2202                       (int)PACKET_remaining(&generator), NULL)) == NULL
2203         || (s->srp_ctx.s =
2204             BN_bin2bn(PACKET_data(&salt),
2205                       (int)PACKET_remaining(&salt), NULL)) == NULL
2206         || (s->srp_ctx.B =
2207             BN_bin2bn(PACKET_data(&server_pub),
2208                       (int)PACKET_remaining(&server_pub), NULL)) == NULL) {
2209         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_BN_LIB);
2210         return 0;
2211     }
2212
2213     if (!srp_verify_server_param(s)) {
2214         /* SSLfatal() already called */
2215         return 0;
2216     }
2217
2218     /* We must check if there is a certificate */
2219     if (s->s3.tmp.new_cipher->algorithm_auth & (SSL_aRSA | SSL_aDSS))
2220         *pkey = tls_get_peer_pkey(s);
2221
2222     return 1;
2223 #else
2224     SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
2225     return 0;
2226 #endif
2227 }
2228
2229 static int tls_process_ske_dhe(SSL_CONNECTION *s, PACKET *pkt, EVP_PKEY **pkey)
2230 {
2231     PACKET prime, generator, pub_key;
2232     EVP_PKEY *peer_tmp = NULL;
2233     BIGNUM *p = NULL, *g = NULL, *bnpub_key = NULL;
2234     EVP_PKEY_CTX *pctx = NULL;
2235     OSSL_PARAM *params = NULL;
2236     OSSL_PARAM_BLD *tmpl = NULL;
2237     SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
2238     int ret = 0;
2239
2240     if (!PACKET_get_length_prefixed_2(pkt, &prime)
2241         || !PACKET_get_length_prefixed_2(pkt, &generator)
2242         || !PACKET_get_length_prefixed_2(pkt, &pub_key)) {
2243         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
2244         return 0;
2245     }
2246
2247     p = BN_bin2bn(PACKET_data(&prime), (int)PACKET_remaining(&prime), NULL);
2248     g = BN_bin2bn(PACKET_data(&generator), (int)PACKET_remaining(&generator),
2249                   NULL);
2250     bnpub_key = BN_bin2bn(PACKET_data(&pub_key),
2251                           (int)PACKET_remaining(&pub_key), NULL);
2252     if (p == NULL || g == NULL || bnpub_key == NULL) {
2253         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_BN_LIB);
2254         goto err;
2255     }
2256
2257     tmpl = OSSL_PARAM_BLD_new();
2258     if (tmpl == NULL
2259             || !OSSL_PARAM_BLD_push_BN(tmpl, OSSL_PKEY_PARAM_FFC_P, p)
2260             || !OSSL_PARAM_BLD_push_BN(tmpl, OSSL_PKEY_PARAM_FFC_G, g)
2261             || !OSSL_PARAM_BLD_push_BN(tmpl, OSSL_PKEY_PARAM_PUB_KEY,
2262                                        bnpub_key)
2263             || (params = OSSL_PARAM_BLD_to_param(tmpl)) == NULL) {
2264         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
2265         goto err;
2266     }
2267
2268     pctx = EVP_PKEY_CTX_new_from_name(sctx->libctx, "DH", sctx->propq);
2269     if (pctx == NULL) {
2270         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
2271         goto err;
2272     }
2273     if (EVP_PKEY_fromdata_init(pctx) <= 0
2274             || EVP_PKEY_fromdata(pctx, &peer_tmp, EVP_PKEY_KEYPAIR, params) <= 0) {
2275         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_DH_VALUE);
2276         goto err;
2277     }
2278
2279     EVP_PKEY_CTX_free(pctx);
2280     pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, peer_tmp, sctx->propq);
2281     if (pctx == NULL
2282             /*
2283              * EVP_PKEY_param_check() will verify that the DH params are using
2284              * a safe prime. In this context, because we're using ephemeral DH,
2285              * we're ok with it not being a safe prime.
2286              * EVP_PKEY_param_check_quick() skips the safe prime check.
2287              */
2288             || EVP_PKEY_param_check_quick(pctx) != 1
2289             || EVP_PKEY_public_check(pctx) != 1) {
2290         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_DH_VALUE);
2291         goto err;
2292     }
2293
2294     if (!ssl_security(s, SSL_SECOP_TMP_DH,
2295                       EVP_PKEY_get_security_bits(peer_tmp),
2296                       0, peer_tmp)) {
2297         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_DH_KEY_TOO_SMALL);
2298         goto err;
2299     }
2300
2301     s->s3.peer_tmp = peer_tmp;
2302     peer_tmp = NULL;
2303
2304     /*
2305      * FIXME: This makes assumptions about which ciphersuites come with
2306      * public keys. We should have a less ad-hoc way of doing this
2307      */
2308     if (s->s3.tmp.new_cipher->algorithm_auth & (SSL_aRSA | SSL_aDSS))
2309         *pkey = tls_get_peer_pkey(s);
2310     /* else anonymous DH, so no certificate or pkey. */
2311
2312     ret = 1;
2313
2314  err:
2315     OSSL_PARAM_BLD_free(tmpl);
2316     OSSL_PARAM_free(params);
2317     EVP_PKEY_free(peer_tmp);
2318     EVP_PKEY_CTX_free(pctx);
2319     BN_free(p);
2320     BN_free(g);
2321     BN_free(bnpub_key);
2322
2323     return ret;
2324 }
2325
2326 static int tls_process_ske_ecdhe(SSL_CONNECTION *s, PACKET *pkt, EVP_PKEY **pkey)
2327 {
2328     PACKET encoded_pt;
2329     unsigned int curve_type, curve_id;
2330
2331     /*
2332      * Extract elliptic curve parameters and the server's ephemeral ECDH
2333      * public key. We only support named (not generic) curves and
2334      * ECParameters in this case is just three bytes.
2335      */
2336     if (!PACKET_get_1(pkt, &curve_type) || !PACKET_get_net_2(pkt, &curve_id)) {
2337         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_TOO_SHORT);
2338         return 0;
2339     }
2340     /*
2341      * Check curve is named curve type and one of our preferences, if not
2342      * server has sent an invalid curve.
2343      */
2344     if (curve_type != NAMED_CURVE_TYPE
2345             || !tls1_check_group_id(s, curve_id, 1)) {
2346         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CURVE);
2347         return 0;
2348     }
2349
2350     if ((s->s3.peer_tmp = ssl_generate_param_group(s, curve_id)) == NULL) {
2351         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2352                  SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS);
2353         return 0;
2354     }
2355
2356     if (!PACKET_get_length_prefixed_1(pkt, &encoded_pt)) {
2357         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
2358         return 0;
2359     }
2360
2361     if (EVP_PKEY_set1_encoded_public_key(s->s3.peer_tmp,
2362                                          PACKET_data(&encoded_pt),
2363                                          PACKET_remaining(&encoded_pt)) <= 0) {
2364         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_ECPOINT);
2365         return 0;
2366     }
2367
2368     /*
2369      * The ECC/TLS specification does not mention the use of DSA to sign
2370      * ECParameters in the server key exchange message. We do support RSA
2371      * and ECDSA.
2372      */
2373     if (s->s3.tmp.new_cipher->algorithm_auth & SSL_aECDSA)
2374         *pkey = tls_get_peer_pkey(s);
2375     else if (s->s3.tmp.new_cipher->algorithm_auth & SSL_aRSA)
2376         *pkey = tls_get_peer_pkey(s);
2377     /* else anonymous ECDH, so no certificate or pkey. */
2378
2379     /* Cache the agreed upon group in the SSL_SESSION */
2380     s->session->kex_group = curve_id;
2381     return 1;
2382 }
2383
2384 MSG_PROCESS_RETURN tls_process_key_exchange(SSL_CONNECTION *s, PACKET *pkt)
2385 {
2386     long alg_k;
2387     EVP_PKEY *pkey = NULL;
2388     EVP_MD_CTX *md_ctx = NULL;
2389     EVP_PKEY_CTX *pctx = NULL;
2390     PACKET save_param_start, signature;
2391     SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
2392
2393     alg_k = s->s3.tmp.new_cipher->algorithm_mkey;
2394
2395     save_param_start = *pkt;
2396
2397     EVP_PKEY_free(s->s3.peer_tmp);
2398     s->s3.peer_tmp = NULL;
2399
2400     if (alg_k & SSL_PSK) {
2401         if (!tls_process_ske_psk_preamble(s, pkt)) {
2402             /* SSLfatal() already called */
2403             goto err;
2404         }
2405     }
2406
2407     /* Nothing else to do for plain PSK or RSAPSK */
2408     if (alg_k & (SSL_kPSK | SSL_kRSAPSK)) {
2409     } else if (alg_k & SSL_kSRP) {
2410         if (!tls_process_ske_srp(s, pkt, &pkey)) {
2411             /* SSLfatal() already called */
2412             goto err;
2413         }
2414     } else if (alg_k & (SSL_kDHE | SSL_kDHEPSK)) {
2415         if (!tls_process_ske_dhe(s, pkt, &pkey)) {
2416             /* SSLfatal() already called */
2417             goto err;
2418         }
2419     } else if (alg_k & (SSL_kECDHE | SSL_kECDHEPSK)) {
2420         if (!tls_process_ske_ecdhe(s, pkt, &pkey)) {
2421             /* SSLfatal() already called */
2422             goto err;
2423         }
2424     } else if (alg_k) {
2425         SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE);
2426         goto err;
2427     }
2428
2429     /* if it was signed, check the signature */
2430     if (pkey != NULL) {
2431         PACKET params;
2432         const EVP_MD *md = NULL;
2433         unsigned char *tbs;
2434         size_t tbslen;
2435         int rv;
2436
2437         /*
2438          * |pkt| now points to the beginning of the signature, so the difference
2439          * equals the length of the parameters.
2440          */
2441         if (!PACKET_get_sub_packet(&save_param_start, &params,
2442                                    PACKET_remaining(&save_param_start) -
2443                                    PACKET_remaining(pkt))) {
2444             SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_INTERNAL_ERROR);
2445             goto err;
2446         }
2447
2448         if (SSL_USE_SIGALGS(s)) {
2449             unsigned int sigalg;
2450
2451             if (!PACKET_get_net_2(pkt, &sigalg)) {
2452                 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_TOO_SHORT);
2453                 goto err;
2454             }
2455             if (tls12_check_peer_sigalg(s, sigalg, pkey) <=0) {
2456                 /* SSLfatal() already called */
2457                 goto err;
2458             }
2459         } else if (!tls1_set_peer_legacy_sigalg(s, pkey)) {
2460             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2461                      SSL_R_LEGACY_SIGALG_DISALLOWED_OR_UNSUPPORTED);
2462             goto err;
2463         }
2464
2465         if (!tls1_lookup_md(sctx, s->s3.tmp.peer_sigalg, &md)) {
2466             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2467                      SSL_R_NO_SUITABLE_DIGEST_ALGORITHM);
2468             goto err;
2469         }
2470         if (SSL_USE_SIGALGS(s))
2471             OSSL_TRACE1(TLS, "USING TLSv1.2 HASH %s\n",
2472                         md == NULL ? "n/a" : EVP_MD_get0_name(md));
2473
2474         if (!PACKET_get_length_prefixed_2(pkt, &signature)
2475             || PACKET_remaining(pkt) != 0) {
2476             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
2477             goto err;
2478         }
2479
2480         md_ctx = EVP_MD_CTX_new();
2481         if (md_ctx == NULL) {
2482             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
2483             goto err;
2484         }
2485
2486         if (EVP_DigestVerifyInit_ex(md_ctx, &pctx,
2487                                     md == NULL ? NULL : EVP_MD_get0_name(md),
2488                                     sctx->libctx, sctx->propq, pkey,
2489                                     NULL) <= 0) {
2490             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
2491             goto err;
2492         }
2493         if (SSL_USE_PSS(s)) {
2494             if (EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) <= 0
2495                 || EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx,
2496                                                 RSA_PSS_SALTLEN_DIGEST) <= 0) {
2497                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
2498                 goto err;
2499             }
2500         }
2501         tbslen = construct_key_exchange_tbs(s, &tbs, PACKET_data(&params),
2502                                             PACKET_remaining(&params));
2503         if (tbslen == 0) {
2504             /* SSLfatal() already called */
2505             goto err;
2506         }
2507
2508         rv = EVP_DigestVerify(md_ctx, PACKET_data(&signature),
2509                               PACKET_remaining(&signature), tbs, tbslen);
2510         OPENSSL_free(tbs);
2511         if (rv <= 0) {
2512             SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_R_BAD_SIGNATURE);
2513             goto err;
2514         }
2515         EVP_MD_CTX_free(md_ctx);
2516         md_ctx = NULL;
2517     } else {
2518         /* aNULL, aSRP or PSK do not need public keys */
2519         if (!(s->s3.tmp.new_cipher->algorithm_auth & (SSL_aNULL | SSL_aSRP))
2520             && !(alg_k & SSL_PSK)) {
2521             /* Might be wrong key type, check it */
2522             if (ssl3_check_cert_and_algorithm(s)) {
2523                 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_DATA);
2524             }
2525             /* else this shouldn't happen, SSLfatal() already called */
2526             goto err;
2527         }
2528         /* still data left over */
2529         if (PACKET_remaining(pkt) != 0) {
2530             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_EXTRA_DATA_IN_MESSAGE);
2531             goto err;
2532         }
2533     }
2534
2535     return MSG_PROCESS_CONTINUE_READING;
2536  err:
2537     EVP_MD_CTX_free(md_ctx);
2538     return MSG_PROCESS_ERROR;
2539 }
2540
2541 MSG_PROCESS_RETURN tls_process_certificate_request(SSL_CONNECTION *s,
2542                                                    PACKET *pkt)
2543 {
2544     /* Clear certificate validity flags */
2545     if (s->s3.tmp.valid_flags != NULL)
2546         memset(s->s3.tmp.valid_flags, 0, s->ssl_pkey_num * sizeof(uint32_t));
2547     else
2548         s->s3.tmp.valid_flags = OPENSSL_zalloc(s->ssl_pkey_num * sizeof(uint32_t));
2549
2550     /* Give up for good if allocation didn't work */
2551     if (s->s3.tmp.valid_flags == NULL)
2552         return 0;
2553
2554     if (SSL_CONNECTION_IS_TLS13(s)) {
2555         PACKET reqctx, extensions;
2556         RAW_EXTENSION *rawexts = NULL;
2557
2558         if ((s->shutdown & SSL_SENT_SHUTDOWN) != 0) {
2559             /*
2560              * We already sent close_notify. This can only happen in TLSv1.3
2561              * post-handshake messages. We can't reasonably respond to this, so
2562              * we just ignore it
2563              */
2564             return MSG_PROCESS_FINISHED_READING;
2565         }
2566
2567         /* Free and zero certificate types: it is not present in TLS 1.3 */
2568         OPENSSL_free(s->s3.tmp.ctype);
2569         s->s3.tmp.ctype = NULL;
2570         s->s3.tmp.ctype_len = 0;
2571         OPENSSL_free(s->pha_context);
2572         s->pha_context = NULL;
2573         s->pha_context_len = 0;
2574
2575         if (!PACKET_get_length_prefixed_1(pkt, &reqctx) ||
2576             !PACKET_memdup(&reqctx, &s->pha_context, &s->pha_context_len)) {
2577             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
2578             return MSG_PROCESS_ERROR;
2579         }
2580
2581         if (!PACKET_get_length_prefixed_2(pkt, &extensions)) {
2582             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_LENGTH);
2583             return MSG_PROCESS_ERROR;
2584         }
2585         if (!tls_collect_extensions(s, &extensions,
2586                                     SSL_EXT_TLS1_3_CERTIFICATE_REQUEST,
2587                                     &rawexts, NULL, 1)
2588             || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_CERTIFICATE_REQUEST,
2589                                          rawexts, NULL, 0, 1)) {
2590             /* SSLfatal() already called */
2591             OPENSSL_free(rawexts);
2592             return MSG_PROCESS_ERROR;
2593         }
2594         OPENSSL_free(rawexts);
2595         if (!tls1_process_sigalgs(s)) {
2596             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_LENGTH);
2597             return MSG_PROCESS_ERROR;
2598         }
2599     } else {
2600         PACKET ctypes;
2601
2602         /* get the certificate types */
2603         if (!PACKET_get_length_prefixed_1(pkt, &ctypes)) {
2604             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
2605             return MSG_PROCESS_ERROR;
2606         }
2607
2608         if (!PACKET_memdup(&ctypes, &s->s3.tmp.ctype, &s->s3.tmp.ctype_len)) {
2609             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
2610             return MSG_PROCESS_ERROR;
2611         }
2612
2613         if (SSL_USE_SIGALGS(s)) {
2614             PACKET sigalgs;
2615
2616             if (!PACKET_get_length_prefixed_2(pkt, &sigalgs)) {
2617                 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
2618                 return MSG_PROCESS_ERROR;
2619             }
2620
2621             /*
2622              * Despite this being for certificates, preserve compatibility
2623              * with pre-TLS 1.3 and use the regular sigalgs field.
2624              */
2625             if (!tls1_save_sigalgs(s, &sigalgs, 0)) {
2626                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2627                          SSL_R_SIGNATURE_ALGORITHMS_ERROR);
2628                 return MSG_PROCESS_ERROR;
2629             }
2630             if (!tls1_process_sigalgs(s)) {
2631                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB);
2632                 return MSG_PROCESS_ERROR;
2633             }
2634         }
2635
2636         /* get the CA RDNs */
2637         if (!parse_ca_names(s, pkt)) {
2638             /* SSLfatal() already called */
2639             return MSG_PROCESS_ERROR;
2640         }
2641     }
2642
2643     if (PACKET_remaining(pkt) != 0) {
2644         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
2645         return MSG_PROCESS_ERROR;
2646     }
2647
2648     /* we should setup a certificate to return.... */
2649     s->s3.tmp.cert_req = 1;
2650
2651     /*
2652      * In TLSv1.3 we don't prepare the client certificate yet. We wait until
2653      * after the CertificateVerify message has been received. This is because
2654      * in TLSv1.3 the CertificateRequest arrives before the Certificate message
2655      * but in TLSv1.2 it is the other way around. We want to make sure that
2656      * SSL_get1_peer_certificate() returns something sensible in
2657      * client_cert_cb.
2658      */
2659     if (SSL_CONNECTION_IS_TLS13(s)
2660         && s->post_handshake_auth != SSL_PHA_REQUESTED)
2661         return MSG_PROCESS_CONTINUE_READING;
2662
2663     return MSG_PROCESS_CONTINUE_PROCESSING;
2664 }
2665
2666 MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL_CONNECTION *s,
2667                                                   PACKET *pkt)
2668 {
2669     unsigned int ticklen;
2670     unsigned long ticket_lifetime_hint, age_add = 0;
2671     unsigned int sess_len;
2672     RAW_EXTENSION *exts = NULL;
2673     PACKET nonce;
2674     EVP_MD *sha256 = NULL;
2675     SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
2676
2677     PACKET_null_init(&nonce);
2678
2679     if (!PACKET_get_net_4(pkt, &ticket_lifetime_hint)
2680         || (SSL_CONNECTION_IS_TLS13(s)
2681             && (!PACKET_get_net_4(pkt, &age_add)
2682                 || !PACKET_get_length_prefixed_1(pkt, &nonce)))
2683         || !PACKET_get_net_2(pkt, &ticklen)
2684         || (SSL_CONNECTION_IS_TLS13(s) ? (ticklen == 0
2685                                           || PACKET_remaining(pkt) < ticklen)
2686                                        : PACKET_remaining(pkt) != ticklen)) {
2687         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
2688         goto err;
2689     }
2690
2691     /*
2692      * Server is allowed to change its mind (in <=TLSv1.2) and send an empty
2693      * ticket. We already checked this TLSv1.3 case above, so it should never
2694      * be 0 here in that instance
2695      */
2696     if (ticklen == 0)
2697         return MSG_PROCESS_CONTINUE_READING;
2698
2699     /*
2700      * Sessions must be immutable once they go into the session cache. Otherwise
2701      * we can get multi-thread problems. Therefore we don't "update" sessions,
2702      * we replace them with a duplicate. In TLSv1.3 we need to do this every
2703      * time a NewSessionTicket arrives because those messages arrive
2704      * post-handshake and the session may have already gone into the session
2705      * cache.
2706      */
2707     if (SSL_CONNECTION_IS_TLS13(s) || s->session->session_id_length > 0) {
2708         SSL_SESSION *new_sess;
2709
2710         /*
2711          * We reused an existing session, so we need to replace it with a new
2712          * one
2713          */
2714         if ((new_sess = ssl_session_dup(s->session, 0)) == 0) {
2715             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB);
2716             goto err;
2717         }
2718
2719         if ((s->session_ctx->session_cache_mode & SSL_SESS_CACHE_CLIENT) != 0
2720                 && !SSL_CONNECTION_IS_TLS13(s)) {
2721             /*
2722              * In TLSv1.2 and below the arrival of a new tickets signals that
2723              * any old ticket we were using is now out of date, so we remove the
2724              * old session from the cache. We carry on if this fails
2725              */
2726             SSL_CTX_remove_session(s->session_ctx, s->session);
2727         }
2728
2729         SSL_SESSION_free(s->session);
2730         s->session = new_sess;
2731     }
2732
2733     s->session->time = ossl_time_now();
2734     ssl_session_calculate_timeout(s->session);
2735
2736     OPENSSL_free(s->session->ext.tick);
2737     s->session->ext.tick = NULL;
2738     s->session->ext.ticklen = 0;
2739
2740     s->session->ext.tick = OPENSSL_malloc(ticklen);
2741     if (s->session->ext.tick == NULL) {
2742         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
2743         goto err;
2744     }
2745     if (!PACKET_copy_bytes(pkt, s->session->ext.tick, ticklen)) {
2746         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
2747         goto err;
2748     }
2749
2750     s->session->ext.tick_lifetime_hint = ticket_lifetime_hint;
2751     s->session->ext.tick_age_add = age_add;
2752     s->session->ext.ticklen = ticklen;
2753
2754     if (SSL_CONNECTION_IS_TLS13(s)) {
2755         PACKET extpkt;
2756
2757         if (!PACKET_as_length_prefixed_2(pkt, &extpkt)
2758                 || PACKET_remaining(pkt) != 0) {
2759             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
2760             goto err;
2761         }
2762
2763         if (!tls_collect_extensions(s, &extpkt,
2764                                     SSL_EXT_TLS1_3_NEW_SESSION_TICKET, &exts,
2765                                     NULL, 1)
2766                 || !tls_parse_all_extensions(s,
2767                                              SSL_EXT_TLS1_3_NEW_SESSION_TICKET,
2768                                              exts, NULL, 0, 1)) {
2769             /* SSLfatal() already called */
2770             goto err;
2771         }
2772     }
2773
2774     /*
2775      * There are two ways to detect a resumed ticket session. One is to set
2776      * an appropriate session ID and then the server must return a match in
2777      * ServerHello. This allows the normal client session ID matching to work
2778      * and we know much earlier that the ticket has been accepted. The
2779      * other way is to set zero length session ID when the ticket is
2780      * presented and rely on the handshake to determine session resumption.
2781      * We choose the former approach because this fits in with assumptions
2782      * elsewhere in OpenSSL. The session ID is set to the SHA256 hash of the
2783      * ticket.
2784      */
2785     sha256 = EVP_MD_fetch(sctx->libctx, "SHA2-256", sctx->propq);
2786     if (sha256 == NULL) {
2787         /* Error is already recorded */
2788         SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR);
2789         goto err;
2790     }
2791     /*
2792      * We use sess_len here because EVP_Digest expects an int
2793      * but s->session->session_id_length is a size_t
2794      */
2795     if (!EVP_Digest(s->session->ext.tick, ticklen,
2796                     s->session->session_id, &sess_len,
2797                     sha256, NULL)) {
2798         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
2799         goto err;
2800     }
2801     EVP_MD_free(sha256);
2802     sha256 = NULL;
2803     s->session->session_id_length = sess_len;
2804     s->session->not_resumable = 0;
2805
2806     /* This is a standalone message in TLSv1.3, so there is no more to read */
2807     if (SSL_CONNECTION_IS_TLS13(s)) {
2808         const EVP_MD *md = ssl_handshake_md(s);
2809         int hashleni = EVP_MD_get_size(md);
2810         size_t hashlen;
2811         static const unsigned char nonce_label[] = "resumption";
2812
2813         /* Ensure cast to size_t is safe */
2814         if (!ossl_assert(hashleni >= 0)) {
2815             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
2816             goto err;
2817         }
2818         hashlen = (size_t)hashleni;
2819
2820         if (!tls13_hkdf_expand(s, md, s->resumption_master_secret,
2821                                nonce_label,
2822                                sizeof(nonce_label) - 1,
2823                                PACKET_data(&nonce),
2824                                PACKET_remaining(&nonce),
2825                                s->session->master_key,
2826                                hashlen, 1)) {
2827             /* SSLfatal() already called */
2828             goto err;
2829         }
2830         s->session->master_key_length = hashlen;
2831
2832         OPENSSL_free(exts);
2833         ssl_update_cache(s, SSL_SESS_CACHE_CLIENT);
2834         return MSG_PROCESS_FINISHED_READING;
2835     }
2836
2837     return MSG_PROCESS_CONTINUE_READING;
2838  err:
2839     EVP_MD_free(sha256);
2840     OPENSSL_free(exts);
2841     return MSG_PROCESS_ERROR;
2842 }
2843
2844 /*
2845  * In TLSv1.3 this is called from the extensions code, otherwise it is used to
2846  * parse a separate message. Returns 1 on success or 0 on failure
2847  */
2848 int tls_process_cert_status_body(SSL_CONNECTION *s, PACKET *pkt)
2849 {
2850     size_t resplen;
2851     unsigned int type;
2852
2853     if (!PACKET_get_1(pkt, &type)
2854         || type != TLSEXT_STATUSTYPE_ocsp) {
2855         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_UNSUPPORTED_STATUS_TYPE);
2856         return 0;
2857     }
2858     if (!PACKET_get_net_3_len(pkt, &resplen)
2859         || PACKET_remaining(pkt) != resplen) {
2860         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
2861         return 0;
2862     }
2863     s->ext.ocsp.resp = OPENSSL_malloc(resplen);
2864     if (s->ext.ocsp.resp == NULL) {
2865         s->ext.ocsp.resp_len = 0;
2866         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
2867         return 0;
2868     }
2869     s->ext.ocsp.resp_len = resplen;
2870     if (!PACKET_copy_bytes(pkt, s->ext.ocsp.resp, resplen)) {
2871         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
2872         return 0;
2873     }
2874
2875     return 1;
2876 }
2877
2878
2879 MSG_PROCESS_RETURN tls_process_cert_status(SSL_CONNECTION *s, PACKET *pkt)
2880 {
2881     if (!tls_process_cert_status_body(s, pkt)) {
2882         /* SSLfatal() already called */
2883         return MSG_PROCESS_ERROR;
2884     }
2885
2886     return MSG_PROCESS_CONTINUE_READING;
2887 }
2888
2889 /*
2890  * Perform miscellaneous checks and processing after we have received the
2891  * server's initial flight. In TLS1.3 this is after the Server Finished message.
2892  * In <=TLS1.2 this is after the ServerDone message. Returns 1 on success or 0
2893  * on failure.
2894  */
2895 int tls_process_initial_server_flight(SSL_CONNECTION *s)
2896 {
2897     SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
2898
2899     /*
2900      * at this point we check that we have the required stuff from
2901      * the server
2902      */
2903     if (!ssl3_check_cert_and_algorithm(s)) {
2904         /* SSLfatal() already called */
2905         return 0;
2906     }
2907
2908     /*
2909      * Call the ocsp status callback if needed. The |ext.ocsp.resp| and
2910      * |ext.ocsp.resp_len| values will be set if we actually received a status
2911      * message, or NULL and -1 otherwise
2912      */
2913     if (s->ext.status_type != TLSEXT_STATUSTYPE_nothing
2914             && sctx->ext.status_cb != NULL) {
2915         int ret = sctx->ext.status_cb(SSL_CONNECTION_GET_SSL(s),
2916                                       sctx->ext.status_arg);
2917
2918         if (ret == 0) {
2919             SSLfatal(s, SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE,
2920                      SSL_R_INVALID_STATUS_RESPONSE);
2921             return 0;
2922         }
2923         if (ret < 0) {
2924             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2925                      SSL_R_OCSP_CALLBACK_FAILURE);
2926             return 0;
2927         }
2928     }
2929 #ifndef OPENSSL_NO_CT
2930     if (s->ct_validation_callback != NULL) {
2931         /* Note we validate the SCTs whether or not we abort on error */
2932         if (!ssl_validate_ct(s) && (s->verify_mode & SSL_VERIFY_PEER)) {
2933             /* SSLfatal() already called */
2934             return 0;
2935         }
2936     }
2937 #endif
2938
2939     return 1;
2940 }
2941
2942 MSG_PROCESS_RETURN tls_process_server_done(SSL_CONNECTION *s, PACKET *pkt)
2943 {
2944     if (PACKET_remaining(pkt) > 0) {
2945         /* should contain no data */
2946         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
2947         return MSG_PROCESS_ERROR;
2948     }
2949 #ifndef OPENSSL_NO_SRP
2950     if (s->s3.tmp.new_cipher->algorithm_mkey & SSL_kSRP) {
2951         if (ssl_srp_calc_a_param_intern(s) <= 0) {
2952             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_SRP_A_CALC);
2953             return MSG_PROCESS_ERROR;
2954         }
2955     }
2956 #endif
2957
2958     if (!tls_process_initial_server_flight(s)) {
2959         /* SSLfatal() already called */
2960         return MSG_PROCESS_ERROR;
2961     }
2962
2963     return MSG_PROCESS_FINISHED_READING;
2964 }
2965
2966 static int tls_construct_cke_psk_preamble(SSL_CONNECTION *s, WPACKET *pkt)
2967 {
2968 #ifndef OPENSSL_NO_PSK
2969     int ret = 0;
2970     /*
2971      * The callback needs PSK_MAX_IDENTITY_LEN + 1 bytes to return a
2972      * \0-terminated identity. The last byte is for us for simulating
2973      * strnlen.
2974      */
2975     char identity[PSK_MAX_IDENTITY_LEN + 1];
2976     size_t identitylen = 0;
2977     unsigned char psk[PSK_MAX_PSK_LEN];
2978     unsigned char *tmppsk = NULL;
2979     char *tmpidentity = NULL;
2980     size_t psklen = 0;
2981
2982     if (s->psk_client_callback == NULL) {
2983         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_PSK_NO_CLIENT_CB);
2984         goto err;
2985     }
2986
2987     memset(identity, 0, sizeof(identity));
2988
2989     psklen = s->psk_client_callback(SSL_CONNECTION_GET_SSL(s),
2990                                     s->session->psk_identity_hint,
2991                                     identity, sizeof(identity) - 1,
2992                                     psk, sizeof(psk));
2993
2994     if (psklen > PSK_MAX_PSK_LEN) {
2995         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, ERR_R_INTERNAL_ERROR);
2996         psklen = PSK_MAX_PSK_LEN;   /* Avoid overrunning the array on cleanse */
2997         goto err;
2998     } else if (psklen == 0) {
2999         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_PSK_IDENTITY_NOT_FOUND);
3000         goto err;
3001     }
3002
3003     identitylen = strlen(identity);
3004     if (identitylen > PSK_MAX_IDENTITY_LEN) {
3005         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3006         goto err;
3007     }
3008
3009     tmppsk = OPENSSL_memdup(psk, psklen);
3010     tmpidentity = OPENSSL_strdup(identity);
3011     if (tmppsk == NULL || tmpidentity == NULL) {
3012         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
3013         goto err;
3014     }
3015
3016     OPENSSL_free(s->s3.tmp.psk);
3017     s->s3.tmp.psk = tmppsk;
3018     s->s3.tmp.psklen = psklen;
3019     tmppsk = NULL;
3020     OPENSSL_free(s->session->psk_identity);
3021     s->session->psk_identity = tmpidentity;
3022     tmpidentity = NULL;
3023
3024     if (!WPACKET_sub_memcpy_u16(pkt, identity, identitylen))  {
3025         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3026         goto err;
3027     }
3028
3029     ret = 1;
3030
3031  err:
3032     OPENSSL_cleanse(psk, psklen);
3033     OPENSSL_cleanse(identity, sizeof(identity));
3034     OPENSSL_clear_free(tmppsk, psklen);
3035     OPENSSL_clear_free(tmpidentity, identitylen);
3036
3037     return ret;
3038 #else
3039     SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3040     return 0;
3041 #endif
3042 }
3043
3044 static int tls_construct_cke_rsa(SSL_CONNECTION *s, WPACKET *pkt)
3045 {
3046     unsigned char *encdata = NULL;
3047     EVP_PKEY *pkey = NULL;
3048     EVP_PKEY_CTX *pctx = NULL;
3049     size_t enclen;
3050     unsigned char *pms = NULL;
3051     size_t pmslen = 0;
3052     SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
3053
3054     if (!received_server_cert(s)) {
3055         /*
3056          * We should always have a server certificate with SSL_kRSA.
3057          */
3058         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3059         return 0;
3060     }
3061
3062     if ((pkey = tls_get_peer_pkey(s)) == NULL) {
3063         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3064         return 0;
3065     }
3066
3067     if (!EVP_PKEY_is_a(pkey, "RSA")) {
3068         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3069         return 0;
3070     }
3071
3072     pmslen = SSL_MAX_MASTER_KEY_LENGTH;
3073     pms = OPENSSL_malloc(pmslen);
3074     if (pms == NULL) {
3075         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
3076         return 0;
3077     }
3078
3079     pms[0] = s->client_version >> 8;
3080     pms[1] = s->client_version & 0xff;
3081     if (RAND_bytes_ex(sctx->libctx, pms + 2, pmslen - 2, 0) <= 0) {
3082         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_RAND_LIB);
3083         goto err;
3084     }
3085
3086     /* Fix buf for TLS and beyond */
3087     if (s->version > SSL3_VERSION && !WPACKET_start_sub_packet_u16(pkt)) {
3088         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3089         goto err;
3090     }
3091
3092     pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pkey, sctx->propq);
3093     if (pctx == NULL || EVP_PKEY_encrypt_init(pctx) <= 0
3094         || EVP_PKEY_encrypt(pctx, NULL, &enclen, pms, pmslen) <= 0) {
3095         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
3096         goto err;
3097     }
3098     if (!WPACKET_allocate_bytes(pkt, enclen, &encdata)
3099             || EVP_PKEY_encrypt(pctx, encdata, &enclen, pms, pmslen) <= 0) {
3100         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_RSA_ENCRYPT);
3101         goto err;
3102     }
3103     EVP_PKEY_CTX_free(pctx);
3104     pctx = NULL;
3105
3106     /* Fix buf for TLS and beyond */
3107     if (s->version > SSL3_VERSION && !WPACKET_close(pkt)) {
3108         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3109         goto err;
3110     }
3111
3112     /* Log the premaster secret, if logging is enabled. */
3113     if (!ssl_log_rsa_client_key_exchange(s, encdata, enclen, pms, pmslen)) {
3114         /* SSLfatal() already called */
3115         goto err;
3116     }
3117
3118     s->s3.tmp.pms = pms;
3119     s->s3.tmp.pmslen = pmslen;
3120
3121     return 1;
3122  err:
3123     OPENSSL_clear_free(pms, pmslen);
3124     EVP_PKEY_CTX_free(pctx);
3125
3126     return 0;
3127 }
3128
3129 static int tls_construct_cke_dhe(SSL_CONNECTION *s, WPACKET *pkt)
3130 {
3131     EVP_PKEY *ckey = NULL, *skey = NULL;
3132     unsigned char *keybytes = NULL;
3133     int prime_len;
3134     unsigned char *encoded_pub = NULL;
3135     size_t encoded_pub_len, pad_len;
3136     int ret = 0;
3137
3138     skey = s->s3.peer_tmp;
3139     if (skey == NULL) {
3140         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3141         goto err;
3142     }
3143
3144     ckey = ssl_generate_pkey(s, skey);
3145     if (ckey == NULL) {
3146         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3147         goto err;
3148     }
3149
3150     if (ssl_derive(s, ckey, skey, 0) == 0) {
3151         /* SSLfatal() already called */
3152         goto err;
3153     }
3154
3155     /* send off the data */
3156
3157     /* Generate encoding of server key */
3158     encoded_pub_len = EVP_PKEY_get1_encoded_public_key(ckey, &encoded_pub);
3159     if (encoded_pub_len == 0) {
3160         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3161         EVP_PKEY_free(ckey);
3162         return EXT_RETURN_FAIL;
3163     }
3164
3165     /*
3166      * For interoperability with some versions of the Microsoft TLS
3167      * stack, we need to zero pad the DHE pub key to the same length
3168      * as the prime.
3169      */
3170     prime_len = EVP_PKEY_get_size(ckey);
3171     pad_len = prime_len - encoded_pub_len;
3172     if (pad_len > 0) {
3173         if (!WPACKET_sub_allocate_bytes_u16(pkt, pad_len, &keybytes)) {
3174             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3175             goto err;
3176         }
3177         memset(keybytes, 0, pad_len);
3178     }
3179
3180     if (!WPACKET_sub_memcpy_u16(pkt, encoded_pub, encoded_pub_len)) {
3181         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3182         goto err;
3183     }
3184
3185     ret = 1;
3186  err:
3187     OPENSSL_free(encoded_pub);
3188     EVP_PKEY_free(ckey);
3189     return ret;
3190 }
3191
3192 static int tls_construct_cke_ecdhe(SSL_CONNECTION *s, WPACKET *pkt)
3193 {
3194     unsigned char *encodedPoint = NULL;
3195     size_t encoded_pt_len = 0;
3196     EVP_PKEY *ckey = NULL, *skey = NULL;
3197     int ret = 0;
3198
3199     skey = s->s3.peer_tmp;
3200     if (skey == NULL) {
3201         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3202         return 0;
3203     }
3204
3205     ckey = ssl_generate_pkey(s, skey);
3206     if (ckey == NULL) {
3207         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB);
3208         goto err;
3209     }
3210
3211     if (ssl_derive(s, ckey, skey, 0) == 0) {
3212         /* SSLfatal() already called */
3213         goto err;
3214     }
3215
3216     /* Generate encoding of client key */
3217     encoded_pt_len = EVP_PKEY_get1_encoded_public_key(ckey, &encodedPoint);
3218
3219     if (encoded_pt_len == 0) {
3220         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EC_LIB);
3221         goto err;
3222     }
3223
3224     if (!WPACKET_sub_memcpy_u8(pkt, encodedPoint, encoded_pt_len)) {
3225         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3226         goto err;
3227     }
3228
3229     ret = 1;
3230  err:
3231     OPENSSL_free(encodedPoint);
3232     EVP_PKEY_free(ckey);
3233     return ret;
3234 }
3235
3236 static int tls_construct_cke_gost(SSL_CONNECTION *s, WPACKET *pkt)
3237 {
3238 #ifndef OPENSSL_NO_GOST
3239     /* GOST key exchange message creation */
3240     EVP_PKEY_CTX *pkey_ctx = NULL;
3241     EVP_PKEY *pkey = NULL;
3242     size_t msglen;
3243     unsigned int md_len;
3244     unsigned char shared_ukm[32], tmp[256];
3245     EVP_MD_CTX *ukm_hash = NULL;
3246     int dgst_nid = NID_id_GostR3411_94;
3247     unsigned char *pms = NULL;
3248     size_t pmslen = 0;
3249     SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
3250
3251     if ((s->s3.tmp.new_cipher->algorithm_auth & SSL_aGOST12) != 0)
3252         dgst_nid = NID_id_GostR3411_2012_256;
3253
3254     /*
3255      * Get server certificate PKEY and create ctx from it
3256      */
3257     if ((pkey = tls_get_peer_pkey(s)) == NULL) {
3258         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
3259                  SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER);
3260         return 0;
3261     }
3262
3263     pkey_ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx,
3264                                           pkey,
3265                                           sctx->propq);
3266     if (pkey_ctx == NULL) {
3267         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
3268         return 0;
3269     }
3270     /*
3271      * If we have send a certificate, and certificate key
3272      * parameters match those of server certificate, use
3273      * certificate key for key exchange
3274      */
3275
3276     /* Otherwise, generate ephemeral key pair */
3277     pmslen = 32;
3278     pms = OPENSSL_malloc(pmslen);
3279     if (pms == NULL) {
3280         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
3281         goto err;
3282     }
3283
3284     if (EVP_PKEY_encrypt_init(pkey_ctx) <= 0
3285         /* Generate session key
3286          */
3287         || RAND_bytes_ex(sctx->libctx, pms, pmslen, 0) <= 0) {
3288         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3289         goto err;
3290     };
3291     /*
3292      * Compute shared IV and store it in algorithm-specific context
3293      * data
3294      */
3295     ukm_hash = EVP_MD_CTX_new();
3296     if (ukm_hash == NULL
3297         || EVP_DigestInit(ukm_hash, EVP_get_digestbynid(dgst_nid)) <= 0
3298         || EVP_DigestUpdate(ukm_hash, s->s3.client_random,
3299                             SSL3_RANDOM_SIZE) <= 0
3300         || EVP_DigestUpdate(ukm_hash, s->s3.server_random,
3301                             SSL3_RANDOM_SIZE) <= 0
3302         || EVP_DigestFinal_ex(ukm_hash, shared_ukm, &md_len) <= 0) {
3303         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3304         goto err;
3305     }
3306     EVP_MD_CTX_free(ukm_hash);
3307     ukm_hash = NULL;
3308     if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_ENCRYPT,
3309                           EVP_PKEY_CTRL_SET_IV, 8, shared_ukm) <= 0) {
3310         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG);
3311         goto err;
3312     }
3313     /* Make GOST keytransport blob message */
3314     /*
3315      * Encapsulate it into sequence
3316      */
3317     msglen = 255;
3318     if (EVP_PKEY_encrypt(pkey_ctx, tmp, &msglen, pms, pmslen) <= 0) {
3319         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG);
3320         goto err;
3321     }
3322
3323     if (!WPACKET_put_bytes_u8(pkt, V_ASN1_SEQUENCE | V_ASN1_CONSTRUCTED)
3324             || (msglen >= 0x80 && !WPACKET_put_bytes_u8(pkt, 0x81))
3325             || !WPACKET_sub_memcpy_u8(pkt, tmp, msglen)) {
3326         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3327         goto err;
3328     }
3329
3330     EVP_PKEY_CTX_free(pkey_ctx);
3331     s->s3.tmp.pms = pms;
3332     s->s3.tmp.pmslen = pmslen;
3333
3334     return 1;
3335  err:
3336     EVP_PKEY_CTX_free(pkey_ctx);
3337     OPENSSL_clear_free(pms, pmslen);
3338     EVP_MD_CTX_free(ukm_hash);
3339     return 0;
3340 #else
3341     SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3342     return 0;
3343 #endif
3344 }
3345
3346 #ifndef OPENSSL_NO_GOST
3347 int ossl_gost18_cke_cipher_nid(const SSL_CONNECTION *s)
3348 {
3349     if ((s->s3.tmp.new_cipher->algorithm_enc & SSL_MAGMA) != 0)
3350         return NID_magma_ctr;
3351     else if ((s->s3.tmp.new_cipher->algorithm_enc & SSL_KUZNYECHIK) != 0)
3352         return NID_kuznyechik_ctr;
3353
3354     return NID_undef;
3355 }
3356
3357 int ossl_gost_ukm(const SSL_CONNECTION *s, unsigned char *dgst_buf)
3358 {
3359     EVP_MD_CTX * hash = NULL;
3360     unsigned int md_len;
3361     SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
3362     const EVP_MD *md = ssl_evp_md_fetch(sctx->libctx, NID_id_GostR3411_2012_256,
3363                                         sctx->propq);
3364
3365     if (md == NULL)
3366         return 0;
3367
3368     if ((hash = EVP_MD_CTX_new()) == NULL
3369         || EVP_DigestInit(hash, md) <= 0
3370         || EVP_DigestUpdate(hash, s->s3.client_random, SSL3_RANDOM_SIZE) <= 0
3371         || EVP_DigestUpdate(hash, s->s3.server_random, SSL3_RANDOM_SIZE) <= 0
3372         || EVP_DigestFinal_ex(hash, dgst_buf, &md_len) <= 0) {
3373         EVP_MD_CTX_free(hash);
3374         ssl_evp_md_free(md);
3375         return 0;
3376     }
3377
3378     EVP_MD_CTX_free(hash);
3379     ssl_evp_md_free(md);
3380     return 1;
3381 }
3382 #endif
3383
3384 static int tls_construct_cke_gost18(SSL_CONNECTION *s, WPACKET *pkt)
3385 {
3386 #ifndef OPENSSL_NO_GOST
3387     /* GOST 2018 key exchange message creation */
3388     unsigned char rnd_dgst[32];
3389     unsigned char *encdata = NULL;
3390     EVP_PKEY_CTX *pkey_ctx = NULL;
3391     EVP_PKEY *pkey;
3392     unsigned char *pms = NULL;
3393     size_t pmslen = 0;
3394     size_t msglen;
3395     int cipher_nid = ossl_gost18_cke_cipher_nid(s);
3396     SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
3397
3398     if (cipher_nid == NID_undef) {
3399         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3400         return 0;
3401     }
3402
3403     if (ossl_gost_ukm(s, rnd_dgst) <= 0) {
3404         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3405         goto err;
3406     }
3407
3408     /* Pre-master secret - random bytes */
3409     pmslen = 32;
3410     pms = OPENSSL_malloc(pmslen);
3411     if (pms == NULL) {
3412         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
3413         goto err;
3414     }
3415
3416     if (RAND_bytes_ex(sctx->libctx, pms, pmslen, 0) <= 0) {
3417         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3418         goto err;
3419     }
3420
3421      /* Get server certificate PKEY and create ctx from it */
3422     if ((pkey = tls_get_peer_pkey(s)) == NULL) {
3423         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
3424                  SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER);
3425         goto err;
3426     }
3427
3428     pkey_ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx,
3429                                           pkey,
3430                                           sctx->propq);
3431     if (pkey_ctx == NULL) {
3432         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
3433         goto err;
3434     }
3435
3436     if (EVP_PKEY_encrypt_init(pkey_ctx) <= 0) {
3437         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3438         goto err;
3439     };
3440
3441     /* Reuse EVP_PKEY_CTRL_SET_IV, make choice in engine code */
3442     if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_ENCRYPT,
3443                           EVP_PKEY_CTRL_SET_IV, 32, rnd_dgst) <= 0) {
3444         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG);
3445         goto err;
3446     }
3447
3448     if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_ENCRYPT,
3449                           EVP_PKEY_CTRL_CIPHER, cipher_nid, NULL) <= 0) {
3450         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG);
3451         goto err;
3452     }
3453
3454     if (EVP_PKEY_encrypt(pkey_ctx, NULL, &msglen, pms, pmslen) <= 0) {
3455         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
3456         goto err;
3457     }
3458
3459     if (!WPACKET_allocate_bytes(pkt, msglen, &encdata)
3460             || EVP_PKEY_encrypt(pkey_ctx, encdata, &msglen, pms, pmslen) <= 0) {
3461         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
3462         goto err;
3463     }
3464
3465     EVP_PKEY_CTX_free(pkey_ctx);
3466     pkey_ctx = NULL;
3467     s->s3.tmp.pms = pms;
3468     s->s3.tmp.pmslen = pmslen;
3469
3470     return 1;
3471  err:
3472     EVP_PKEY_CTX_free(pkey_ctx);
3473     OPENSSL_clear_free(pms, pmslen);
3474     return 0;
3475 #else
3476     SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3477     return 0;
3478 #endif
3479 }
3480
3481 static int tls_construct_cke_srp(SSL_CONNECTION *s, WPACKET *pkt)
3482 {
3483 #ifndef OPENSSL_NO_SRP
3484     unsigned char *abytes = NULL;
3485
3486     if (s->srp_ctx.A == NULL
3487             || !WPACKET_sub_allocate_bytes_u16(pkt, BN_num_bytes(s->srp_ctx.A),
3488                                                &abytes)) {
3489         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3490         return 0;
3491     }
3492     BN_bn2bin(s->srp_ctx.A, abytes);
3493
3494     OPENSSL_free(s->session->srp_username);
3495     s->session->srp_username = OPENSSL_strdup(s->srp_ctx.login);
3496     if (s->session->srp_username == NULL) {
3497         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
3498         return 0;
3499     }
3500
3501     return 1;
3502 #else
3503     SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3504     return 0;
3505 #endif
3506 }
3507
3508 CON_FUNC_RETURN tls_construct_client_key_exchange(SSL_CONNECTION *s,
3509                                                   WPACKET *pkt)
3510 {
3511     unsigned long alg_k;
3512
3513     alg_k = s->s3.tmp.new_cipher->algorithm_mkey;
3514
3515     /*
3516      * All of the construct functions below call SSLfatal() if necessary so
3517      * no need to do so here.
3518      */
3519     if ((alg_k & SSL_PSK)
3520         && !tls_construct_cke_psk_preamble(s, pkt))
3521         goto err;
3522
3523     if (alg_k & (SSL_kRSA | SSL_kRSAPSK)) {
3524         if (!tls_construct_cke_rsa(s, pkt))
3525             goto err;
3526     } else if (alg_k & (SSL_kDHE | SSL_kDHEPSK)) {
3527         if (!tls_construct_cke_dhe(s, pkt))
3528             goto err;
3529     } else if (alg_k & (SSL_kECDHE | SSL_kECDHEPSK)) {
3530         if (!tls_construct_cke_ecdhe(s, pkt))
3531             goto err;
3532     } else if (alg_k & SSL_kGOST) {
3533         if (!tls_construct_cke_gost(s, pkt))
3534             goto err;
3535     } else if (alg_k & SSL_kGOST18) {
3536         if (!tls_construct_cke_gost18(s, pkt))
3537             goto err;
3538     } else if (alg_k & SSL_kSRP) {
3539         if (!tls_construct_cke_srp(s, pkt))
3540             goto err;
3541     } else if (!(alg_k & SSL_kPSK)) {
3542         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3543         goto err;
3544     }
3545
3546     return CON_FUNC_SUCCESS;
3547  err:
3548     OPENSSL_clear_free(s->s3.tmp.pms, s->s3.tmp.pmslen);
3549     s->s3.tmp.pms = NULL;
3550     s->s3.tmp.pmslen = 0;
3551 #ifndef OPENSSL_NO_PSK
3552     OPENSSL_clear_free(s->s3.tmp.psk, s->s3.tmp.psklen);
3553     s->s3.tmp.psk = NULL;
3554     s->s3.tmp.psklen = 0;
3555 #endif
3556     return CON_FUNC_ERROR;
3557 }
3558
3559 int tls_client_key_exchange_post_work(SSL_CONNECTION *s)
3560 {
3561     unsigned char *pms = NULL;
3562     size_t pmslen = 0;
3563
3564     pms = s->s3.tmp.pms;
3565     pmslen = s->s3.tmp.pmslen;
3566
3567 #ifndef OPENSSL_NO_SRP
3568     /* Check for SRP */
3569     if (s->s3.tmp.new_cipher->algorithm_mkey & SSL_kSRP) {
3570         if (!srp_generate_client_master_secret(s)) {
3571             /* SSLfatal() already called */
3572             goto err;
3573         }
3574         return 1;
3575     }
3576 #endif
3577
3578     if (pms == NULL && !(s->s3.tmp.new_cipher->algorithm_mkey & SSL_kPSK)) {
3579         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_PASSED_INVALID_ARGUMENT);
3580         goto err;
3581     }
3582     if (!ssl_generate_master_secret(s, pms, pmslen, 1)) {
3583         /* SSLfatal() already called */
3584         /* ssl_generate_master_secret frees the pms even on error */
3585         pms = NULL;
3586         pmslen = 0;
3587         goto err;
3588     }
3589     pms = NULL;
3590     pmslen = 0;
3591
3592 #ifndef OPENSSL_NO_SCTP
3593     if (SSL_CONNECTION_IS_DTLS(s)) {
3594         unsigned char sctpauthkey[64];
3595         char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)];
3596         size_t labellen;
3597         SSL *ssl = SSL_CONNECTION_GET_SSL(s);
3598
3599         /*
3600          * Add new shared key for SCTP-Auth, will be ignored if no SCTP
3601          * used.
3602          */
3603         memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL,
3604                sizeof(DTLS1_SCTP_AUTH_LABEL));
3605
3606         /* Don't include the terminating zero. */
3607         labellen = sizeof(labelbuffer) - 1;
3608         if (s->mode & SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG)
3609             labellen += 1;
3610
3611         if (SSL_export_keying_material(ssl, sctpauthkey,
3612                                        sizeof(sctpauthkey), labelbuffer,
3613                                        labellen, NULL, 0, 0) <= 0) {
3614             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3615             goto err;
3616         }
3617
3618         BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
3619                  sizeof(sctpauthkey), sctpauthkey);
3620     }
3621 #endif
3622
3623     return 1;
3624  err:
3625     OPENSSL_clear_free(pms, pmslen);
3626     s->s3.tmp.pms = NULL;
3627     s->s3.tmp.pmslen = 0;
3628     return 0;
3629 }
3630
3631 /*
3632  * Check a certificate can be used for client authentication. Currently check
3633  * cert exists, if we have a suitable digest for TLS 1.2 if static DH client
3634  * certificates can be used and optionally checks suitability for Suite B.
3635  */
3636 static int ssl3_check_client_certificate(SSL_CONNECTION *s)
3637 {
3638     /* If no suitable signature algorithm can't use certificate */
3639     if (!tls_choose_sigalg(s, 0) || s->s3.tmp.sigalg == NULL)
3640         return 0;
3641     /*
3642      * If strict mode check suitability of chain before using it. This also
3643      * adjusts suite B digest if necessary.
3644      */
3645     if (s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT &&
3646         !tls1_check_chain(s, NULL, NULL, NULL, -2))
3647         return 0;
3648     return 1;
3649 }
3650
3651 WORK_STATE tls_prepare_client_certificate(SSL_CONNECTION *s, WORK_STATE wst)
3652 {
3653     X509 *x509 = NULL;
3654     EVP_PKEY *pkey = NULL;
3655     int i;
3656     SSL *ssl = SSL_CONNECTION_GET_SSL(s);
3657
3658     if (wst == WORK_MORE_A) {
3659         /* Let cert callback update client certificates if required */
3660         if (s->cert->cert_cb) {
3661             i = s->cert->cert_cb(ssl, s->cert->cert_cb_arg);
3662             if (i < 0) {
3663                 s->rwstate = SSL_X509_LOOKUP;
3664                 return WORK_MORE_A;
3665             }
3666             if (i == 0) {
3667                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_CALLBACK_FAILED);
3668                 return WORK_ERROR;
3669             }
3670             s->rwstate = SSL_NOTHING;
3671         }
3672         if (ssl3_check_client_certificate(s)) {
3673             if (s->post_handshake_auth == SSL_PHA_REQUESTED) {
3674                 return WORK_FINISHED_STOP;
3675             }
3676             return WORK_FINISHED_CONTINUE;
3677         }
3678
3679         /* Fall through to WORK_MORE_B */
3680         wst = WORK_MORE_B;
3681     }
3682
3683     /* We need to get a client cert */
3684     if (wst == WORK_MORE_B) {
3685         /*
3686          * If we get an error, we need to ssl->rwstate=SSL_X509_LOOKUP;
3687          * return(-1); We then get retied later
3688          */
3689         i = ssl_do_client_cert_cb(s, &x509, &pkey);
3690         if (i < 0) {
3691             s->rwstate = SSL_X509_LOOKUP;
3692             return WORK_MORE_B;
3693         }
3694         s->rwstate = SSL_NOTHING;
3695         if ((i == 1) && (pkey != NULL) && (x509 != NULL)) {
3696             if (!SSL_use_certificate(ssl, x509)
3697                 || !SSL_use_PrivateKey(ssl, pkey))
3698                 i = 0;
3699         } else if (i == 1) {
3700             i = 0;
3701             ERR_raise(ERR_LIB_SSL, SSL_R_BAD_DATA_RETURNED_BY_CALLBACK);
3702         }
3703
3704         X509_free(x509);
3705         EVP_PKEY_free(pkey);
3706         if (i && !ssl3_check_client_certificate(s))
3707             i = 0;
3708         if (i == 0) {
3709             if (s->version == SSL3_VERSION) {
3710                 s->s3.tmp.cert_req = 0;
3711                 ssl3_send_alert(s, SSL3_AL_WARNING, SSL_AD_NO_CERTIFICATE);
3712                 return WORK_FINISHED_CONTINUE;
3713             } else {
3714                 s->s3.tmp.cert_req = 2;
3715                 s->ext.compress_certificate_from_peer[0] = TLSEXT_comp_cert_none;
3716                 if (!ssl3_digest_cached_records(s, 0)) {
3717                     /* SSLfatal() already called */
3718                     return WORK_ERROR;
3719                 }
3720             }
3721         }
3722
3723         if (!SSL_CONNECTION_IS_TLS13(s)
3724                 || (s->options & SSL_OP_NO_TX_CERTIFICATE_COMPRESSION) != 0)
3725             s->ext.compress_certificate_from_peer[0] = TLSEXT_comp_cert_none;
3726
3727         if (s->post_handshake_auth == SSL_PHA_REQUESTED)
3728             return WORK_FINISHED_STOP;
3729         return WORK_FINISHED_CONTINUE;
3730     }
3731
3732     /* Shouldn't ever get here */
3733     SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3734     return WORK_ERROR;
3735 }
3736
3737 CON_FUNC_RETURN tls_construct_client_certificate(SSL_CONNECTION *s,
3738                                                  WPACKET *pkt)
3739 {
3740     CERT_PKEY *cpk = NULL;
3741     SSL *ssl = SSL_CONNECTION_GET_SSL(s);
3742
3743     if (SSL_CONNECTION_IS_TLS13(s)) {
3744         if (s->pha_context == NULL) {
3745             /* no context available, add 0-length context */
3746             if (!WPACKET_put_bytes_u8(pkt, 0)) {
3747                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3748                 return CON_FUNC_ERROR;
3749             }
3750         } else if (!WPACKET_sub_memcpy_u8(pkt, s->pha_context, s->pha_context_len)) {
3751             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3752             return CON_FUNC_ERROR;
3753         }
3754     }
3755     if (s->s3.tmp.cert_req != 2)
3756         cpk = s->cert->key;
3757     switch (s->ext.client_cert_type) {
3758     case TLSEXT_cert_type_rpk:
3759         if (!tls_output_rpk(s, pkt, cpk)) {
3760             /* SSLfatal() already called */
3761             return CON_FUNC_ERROR;
3762         }
3763         break;
3764     case TLSEXT_cert_type_x509:
3765         if (!ssl3_output_cert_chain(s, pkt, cpk, 0)) {
3766             /* SSLfatal() already called */
3767             return CON_FUNC_ERROR;
3768         }
3769         break;
3770     default:
3771         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3772         return CON_FUNC_ERROR;
3773     }
3774
3775     if (SSL_CONNECTION_IS_TLS13(s)
3776             && SSL_IS_FIRST_HANDSHAKE(s)
3777             && (!ssl->method->ssl3_enc->change_cipher_state(s,
3778                     SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_WRITE))) {
3779         /*
3780          * This is a fatal error, which leaves enc_write_ctx in an inconsistent
3781          * state and thus ssl3_send_alert may crash.
3782          */
3783         SSLfatal(s, SSL_AD_NO_ALERT, SSL_R_CANNOT_CHANGE_CIPHER);
3784         return CON_FUNC_ERROR;
3785     }
3786
3787     return CON_FUNC_SUCCESS;
3788 }
3789
3790 #ifndef OPENSSL_NO_COMP_ALG
3791 CON_FUNC_RETURN tls_construct_client_compressed_certificate(SSL_CONNECTION *sc,
3792                                                             WPACKET *pkt)
3793 {
3794     SSL *ssl = SSL_CONNECTION_GET_SSL(sc);
3795     WPACKET tmppkt;
3796     BUF_MEM *buf = NULL;
3797     size_t length;
3798     size_t max_length;
3799     COMP_METHOD *method;
3800     COMP_CTX *comp = NULL;
3801     int comp_len;
3802     int ret = 0;
3803     int alg = sc->ext.compress_certificate_from_peer[0];
3804
3805     /* Note that sc->s3.tmp.cert_req == 2 is checked in write transition */
3806
3807     if ((buf = BUF_MEM_new()) == NULL || !WPACKET_init(&tmppkt, buf))
3808         goto err;
3809
3810     /* Use the |tmppkt| for the to-be-compressed data */
3811     if (sc->pha_context == NULL) {
3812         /* no context available, add 0-length context */
3813         if (!WPACKET_put_bytes_u8(&tmppkt, 0))
3814             goto err;
3815     } else if (!WPACKET_sub_memcpy_u8(&tmppkt, sc->pha_context, sc->pha_context_len))
3816         goto err;
3817
3818     if (!ssl3_output_cert_chain(sc, &tmppkt, sc->cert->key, 0)) {
3819         /* SSLfatal() already called */
3820         goto out;
3821     }
3822
3823     /* continue with the real |pkt| */
3824     if (!WPACKET_put_bytes_u16(pkt, alg)
3825             || !WPACKET_get_total_written(&tmppkt, &length)
3826             || !WPACKET_put_bytes_u24(pkt, length))
3827         goto err;
3828
3829     switch (alg) {
3830     case TLSEXT_comp_cert_zlib:
3831         method = COMP_zlib_oneshot();
3832         break;
3833     case TLSEXT_comp_cert_brotli:
3834         method = COMP_brotli_oneshot();
3835         break;
3836     case TLSEXT_comp_cert_zstd:
3837         method = COMP_zstd_oneshot();
3838         break;
3839     default:
3840         goto err;
3841     }
3842     max_length = ossl_calculate_comp_expansion(alg, length);
3843
3844     if ((comp = COMP_CTX_new(method)) == NULL
3845             || !WPACKET_start_sub_packet_u24(pkt)
3846             || !WPACKET_reserve_bytes(pkt, max_length, NULL))
3847         goto err;
3848
3849     comp_len = COMP_compress_block(comp, WPACKET_get_curr(pkt), max_length,
3850                                    (unsigned char *)buf->data, length);
3851     if (comp_len <= 0)
3852         goto err;
3853
3854     if (!WPACKET_allocate_bytes(pkt, comp_len, NULL)
3855             || !WPACKET_close(pkt))
3856         goto err;
3857
3858     if (SSL_IS_FIRST_HANDSHAKE(sc)
3859             && (!ssl->method->ssl3_enc->change_cipher_state(sc,
3860                     SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_WRITE))) {
3861         /*
3862          * This is a fatal error, which leaves sc->enc_write_ctx in an
3863          * inconsistent state and thus ssl3_send_alert may crash.
3864          */
3865         SSLfatal(sc, SSL_AD_NO_ALERT, SSL_R_CANNOT_CHANGE_CIPHER);
3866         goto out;
3867     }
3868     ret = 1;
3869     goto out;
3870
3871  err:
3872     SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3873  out:
3874     if (buf != NULL) {
3875         /* If |buf| is NULL, then |tmppkt| could not have been initialized */
3876         WPACKET_cleanup(&tmppkt);
3877     }
3878     BUF_MEM_free(buf);
3879     COMP_CTX_free(comp);
3880     return ret;
3881 }
3882 #endif
3883
3884 int ssl3_check_cert_and_algorithm(SSL_CONNECTION *s)
3885 {
3886     const SSL_CERT_LOOKUP *clu;
3887     size_t idx;
3888     long alg_k, alg_a;
3889     EVP_PKEY *pkey;
3890
3891     alg_k = s->s3.tmp.new_cipher->algorithm_mkey;
3892     alg_a = s->s3.tmp.new_cipher->algorithm_auth;
3893
3894     /* we don't have a certificate */
3895     if (!(alg_a & SSL_aCERT))
3896         return 1;
3897
3898     /* This is the passed certificate */
3899     pkey = tls_get_peer_pkey(s);
3900     clu = ssl_cert_lookup_by_pkey(pkey, &idx, SSL_CONNECTION_GET_CTX(s));
3901
3902     /* Check certificate is recognised and suitable for cipher */
3903     if (clu == NULL || (alg_a & clu->amask) == 0) {
3904         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_MISSING_SIGNING_CERT);
3905         return 0;
3906     }
3907
3908     if (alg_k & (SSL_kRSA | SSL_kRSAPSK) && idx != SSL_PKEY_RSA) {
3909         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
3910                  SSL_R_MISSING_RSA_ENCRYPTING_CERT);
3911         return 0;
3912     }
3913
3914     if ((alg_k & SSL_kDHE) && (s->s3.peer_tmp == NULL)) {
3915         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3916         return 0;
3917     }
3918
3919     /* Early out to skip the checks below */
3920     if (s->session->peer_rpk != NULL)
3921         return 1;
3922
3923     if (clu->amask & SSL_aECDSA) {
3924         if (ssl_check_srvr_ecc_cert_and_alg(s->session->peer, s))
3925             return 1;
3926         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_BAD_ECC_CERT);
3927         return 0;
3928     }
3929
3930     return 1;
3931 }
3932
3933 #ifndef OPENSSL_NO_NEXTPROTONEG
3934 CON_FUNC_RETURN tls_construct_next_proto(SSL_CONNECTION *s, WPACKET *pkt)
3935 {
3936     size_t len, padding_len;
3937     unsigned char *padding = NULL;
3938
3939     len = s->ext.npn_len;
3940     padding_len = 32 - ((len + 2) % 32);
3941
3942     if (!WPACKET_sub_memcpy_u8(pkt, s->ext.npn, len)
3943             || !WPACKET_sub_allocate_bytes_u8(pkt, padding_len, &padding)) {
3944         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
3945         return CON_FUNC_ERROR;
3946     }
3947
3948     memset(padding, 0, padding_len);
3949
3950     return CON_FUNC_SUCCESS;
3951 }
3952 #endif
3953
3954 MSG_PROCESS_RETURN tls_process_hello_req(SSL_CONNECTION *s, PACKET *pkt)
3955 {
3956     SSL *ssl = SSL_CONNECTION_GET_SSL(s);
3957
3958     if (PACKET_remaining(pkt) > 0) {
3959         /* should contain no data */
3960         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
3961         return MSG_PROCESS_ERROR;
3962     }
3963
3964     if ((s->options & SSL_OP_NO_RENEGOTIATION)) {
3965         ssl3_send_alert(s, SSL3_AL_WARNING, SSL_AD_NO_RENEGOTIATION);
3966         return MSG_PROCESS_FINISHED_READING;
3967     }
3968
3969     /*
3970      * This is a historical discrepancy (not in the RFC) maintained for
3971      * compatibility reasons. If a TLS client receives a HelloRequest it will
3972      * attempt an abbreviated handshake. However if a DTLS client receives a
3973      * HelloRequest it will do a full handshake. Either behaviour is reasonable
3974      * but doing one for TLS and another for DTLS is odd.
3975      */
3976     if (SSL_CONNECTION_IS_DTLS(s))
3977         SSL_renegotiate(ssl);
3978     else
3979         SSL_renegotiate_abbreviated(ssl);
3980
3981     return MSG_PROCESS_FINISHED_READING;
3982 }
3983
3984 static MSG_PROCESS_RETURN tls_process_encrypted_extensions(SSL_CONNECTION *s,
3985                                                            PACKET *pkt)
3986 {
3987     PACKET extensions;
3988     RAW_EXTENSION *rawexts = NULL;
3989
3990     if (!PACKET_as_length_prefixed_2(pkt, &extensions)
3991             || PACKET_remaining(pkt) != 0) {
3992         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
3993         goto err;
3994     }
3995
3996     if (!tls_collect_extensions(s, &extensions,
3997                                 SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS, &rawexts,
3998                                 NULL, 1)
3999             || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
4000                                          rawexts, NULL, 0, 1)) {
4001         /* SSLfatal() already called */
4002         goto err;
4003     }
4004
4005     OPENSSL_free(rawexts);
4006     return MSG_PROCESS_CONTINUE_READING;
4007
4008  err:
4009     OPENSSL_free(rawexts);
4010     return MSG_PROCESS_ERROR;
4011 }
4012
4013 int ssl_do_client_cert_cb(SSL_CONNECTION *s, X509 **px509, EVP_PKEY **ppkey)
4014 {
4015     int i = 0;
4016     SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
4017
4018 #ifndef OPENSSL_NO_ENGINE
4019     if (sctx->client_cert_engine) {
4020         i = tls_engine_load_ssl_client_cert(s, px509, ppkey);
4021         if (i != 0)
4022             return i;
4023     }
4024 #endif
4025     if (sctx->client_cert_cb)
4026         i = sctx->client_cert_cb(SSL_CONNECTION_GET_SSL(s), px509, ppkey);
4027     return i;
4028 }
4029
4030 int ssl_cipher_list_to_bytes(SSL_CONNECTION *s, STACK_OF(SSL_CIPHER) *sk,
4031                              WPACKET *pkt)
4032 {
4033     int i;
4034     size_t totlen = 0, len, maxlen, maxverok = 0;
4035     int empty_reneg_info_scsv = !s->renegotiate
4036                                 && (SSL_CONNECTION_IS_DTLS(s)
4037                                     || s->min_proto_version < TLS1_3_VERSION);
4038     SSL *ssl = SSL_CONNECTION_GET_SSL(s);
4039
4040     /* Set disabled masks for this session */
4041     if (!ssl_set_client_disabled(s)) {
4042         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_PROTOCOLS_AVAILABLE);
4043         return 0;
4044     }
4045
4046     if (sk == NULL) {
4047         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
4048         return 0;
4049     }
4050
4051 #ifdef OPENSSL_MAX_TLS1_2_CIPHER_LENGTH
4052 # if OPENSSL_MAX_TLS1_2_CIPHER_LENGTH < 6
4053 #  error Max cipher length too short
4054 # endif
4055     /*
4056      * Some servers hang if client hello > 256 bytes as hack workaround
4057      * chop number of supported ciphers to keep it well below this if we
4058      * use TLS v1.2
4059      */
4060     if (TLS1_get_version(ssl) >= TLS1_2_VERSION)
4061         maxlen = OPENSSL_MAX_TLS1_2_CIPHER_LENGTH & ~1;
4062     else
4063 #endif
4064         /* Maximum length that can be stored in 2 bytes. Length must be even */
4065         maxlen = 0xfffe;
4066
4067     if (empty_reneg_info_scsv)
4068         maxlen -= 2;
4069     if (s->mode & SSL_MODE_SEND_FALLBACK_SCSV)
4070         maxlen -= 2;
4071
4072     for (i = 0; i < sk_SSL_CIPHER_num(sk) && totlen < maxlen; i++) {
4073         const SSL_CIPHER *c;
4074
4075         c = sk_SSL_CIPHER_value(sk, i);
4076         /* Skip disabled ciphers */
4077         if (ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_SUPPORTED, 0))
4078             continue;
4079
4080         if (!ssl->method->put_cipher_by_char(c, pkt, &len)) {
4081             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
4082             return 0;
4083         }
4084
4085         /* Sanity check that the maximum version we offer has ciphers enabled */
4086         if (!maxverok) {
4087             if (SSL_CONNECTION_IS_DTLS(s)) {
4088                 if (DTLS_VERSION_GE(c->max_dtls, s->s3.tmp.max_ver)
4089                         && DTLS_VERSION_LE(c->min_dtls, s->s3.tmp.max_ver))
4090                     maxverok = 1;
4091             } else {
4092                 if (c->max_tls >= s->s3.tmp.max_ver
4093                         && c->min_tls <= s->s3.tmp.max_ver)
4094                     maxverok = 1;
4095             }
4096         }
4097
4098         totlen += len;
4099     }
4100
4101     if (totlen == 0 || !maxverok) {
4102         const char *maxvertext =
4103             !maxverok
4104             ? "No ciphers enabled for max supported SSL/TLS version"
4105             : NULL;
4106
4107         SSLfatal_data(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_CIPHERS_AVAILABLE,
4108                       maxvertext);
4109         return 0;
4110     }
4111
4112     if (totlen != 0) {
4113         if (empty_reneg_info_scsv) {
4114             static SSL_CIPHER scsv = {
4115                 0, NULL, NULL, SSL3_CK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0
4116             };
4117             if (!ssl->method->put_cipher_by_char(&scsv, pkt, &len)) {
4118                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
4119                 return 0;
4120             }
4121         }
4122         if (s->mode & SSL_MODE_SEND_FALLBACK_SCSV) {
4123             static SSL_CIPHER scsv = {
4124                 0, NULL, NULL, SSL3_CK_FALLBACK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0
4125             };
4126             if (!ssl->method->put_cipher_by_char(&scsv, pkt, &len)) {
4127                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
4128                 return 0;
4129             }
4130         }
4131     }
4132
4133     return 1;
4134 }
4135
4136 CON_FUNC_RETURN tls_construct_end_of_early_data(SSL_CONNECTION *s, WPACKET *pkt)
4137 {
4138     if (s->early_data_state != SSL_EARLY_DATA_WRITE_RETRY
4139             && s->early_data_state != SSL_EARLY_DATA_FINISHED_WRITING) {
4140         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
4141         return CON_FUNC_ERROR;
4142     }
4143
4144     s->early_data_state = SSL_EARLY_DATA_FINISHED_WRITING;
4145     return CON_FUNC_SUCCESS;
4146 }