ssl/statem/statem_clnt.c

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