ssl/statem/statem_clnt.c

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