ssl/statem/statem_clnt.c

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