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         SSL_SESSION *new_sess;
2594         /*
2595          * We reused an existing session, so we need to replace it with a new
2596          * one
2597          */
2598         if ((new_sess = ssl_session_dup(s->session, 0)) == 0) {
2599             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2600                      SSL_F_TLS_PROCESS_NEW_SESSION_TICKET,
2601                      ERR_R_MALLOC_FAILURE);
2602             goto err;
2603         }
2604
2605         SSL_SESSION_free(s->session);
2606         s->session = new_sess;
2607     }
2608
2609     /*
2610      * Technically the cast to long here is not guaranteed by the C standard -
2611      * but we use it elsewhere, so this should be ok.
2612      */
2613     s->session->time = (long)time(NULL);
2614
2615     OPENSSL_free(s->session->ext.tick);
2616     s->session->ext.tick = NULL;
2617     s->session->ext.ticklen = 0;
2618
2619     s->session->ext.tick = OPENSSL_malloc(ticklen);
2620     if (s->session->ext.tick == NULL) {
2621         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_NEW_SESSION_TICKET,
2622                  ERR_R_MALLOC_FAILURE);
2623         goto err;
2624     }
2625     if (!PACKET_copy_bytes(pkt, s->session->ext.tick, ticklen)) {
2626         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_NEW_SESSION_TICKET,
2627                  SSL_R_LENGTH_MISMATCH);
2628         goto err;
2629     }
2630
2631     s->session->ext.tick_lifetime_hint = ticket_lifetime_hint;
2632     s->session->ext.tick_age_add = age_add;
2633     s->session->ext.ticklen = ticklen;
2634
2635     if (SSL_IS_TLS13(s)) {
2636         PACKET extpkt;
2637
2638         if (!PACKET_as_length_prefixed_2(pkt, &extpkt)
2639                 || PACKET_remaining(pkt) != 0
2640                 || !tls_collect_extensions(s, &extpkt,
2641                                            SSL_EXT_TLS1_3_NEW_SESSION_TICKET,
2642                                            &exts, NULL, 1)
2643                 || !tls_parse_all_extensions(s,
2644                                              SSL_EXT_TLS1_3_NEW_SESSION_TICKET,
2645                                              exts, NULL, 0, 1)) {
2646             /* SSLfatal() already called */
2647             goto err;
2648         }
2649     }
2650
2651     /*
2652      * There are two ways to detect a resumed ticket session. One is to set
2653      * an appropriate session ID and then the server must return a match in
2654      * ServerHello. This allows the normal client session ID matching to work
2655      * and we know much earlier that the ticket has been accepted. The
2656      * other way is to set zero length session ID when the ticket is
2657      * presented and rely on the handshake to determine session resumption.
2658      * We choose the former approach because this fits in with assumptions
2659      * elsewhere in OpenSSL. The session ID is set to the SHA256 (or SHA1 is
2660      * SHA256 is disabled) hash of the ticket.
2661      */
2662     /*
2663      * TODO(size_t): we use sess_len here because EVP_Digest expects an int
2664      * but s->session->session_id_length is a size_t
2665      */
2666     if (!EVP_Digest(s->session->ext.tick, ticklen,
2667                     s->session->session_id, &sess_len,
2668                     EVP_sha256(), NULL)) {
2669         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_NEW_SESSION_TICKET,
2670                  ERR_R_EVP_LIB);
2671         goto err;
2672     }
2673     s->session->session_id_length = sess_len;
2674
2675     /* This is a standalone message in TLSv1.3, so there is no more to read */
2676     if (SSL_IS_TLS13(s)) {
2677         OPENSSL_free(exts);
2678         ssl_update_cache(s, SSL_SESS_CACHE_CLIENT);
2679         return MSG_PROCESS_FINISHED_READING;
2680     }
2681
2682     return MSG_PROCESS_CONTINUE_READING;
2683  err:
2684     OPENSSL_free(exts);
2685     return MSG_PROCESS_ERROR;
2686 }
2687
2688 /*
2689  * In TLSv1.3 this is called from the extensions code, otherwise it is used to
2690  * parse a separate message. Returns 1 on success or 0 on failure
2691  */
2692 int tls_process_cert_status_body(SSL *s, PACKET *pkt)
2693 {
2694     size_t resplen;
2695     unsigned int type;
2696
2697     if (!PACKET_get_1(pkt, &type)
2698         || type != TLSEXT_STATUSTYPE_ocsp) {
2699         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CERT_STATUS_BODY,
2700                  SSL_R_UNSUPPORTED_STATUS_TYPE);
2701         return 0;
2702     }
2703     if (!PACKET_get_net_3_len(pkt, &resplen)
2704         || PACKET_remaining(pkt) != resplen) {
2705         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CERT_STATUS_BODY,
2706                  SSL_R_LENGTH_MISMATCH);
2707         return 0;
2708     }
2709     s->ext.ocsp.resp = OPENSSL_malloc(resplen);
2710     if (s->ext.ocsp.resp == NULL) {
2711         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CERT_STATUS_BODY,
2712                  ERR_R_MALLOC_FAILURE);
2713         return 0;
2714     }
2715     if (!PACKET_copy_bytes(pkt, s->ext.ocsp.resp, resplen)) {
2716         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CERT_STATUS_BODY,
2717                  SSL_R_LENGTH_MISMATCH);
2718         return 0;
2719     }
2720     s->ext.ocsp.resp_len = resplen;
2721
2722     return 1;
2723 }
2724
2725
2726 MSG_PROCESS_RETURN tls_process_cert_status(SSL *s, PACKET *pkt)
2727 {
2728     if (!tls_process_cert_status_body(s, pkt)) {
2729         /* SSLfatal() already called */
2730         return MSG_PROCESS_ERROR;
2731     }
2732
2733     return MSG_PROCESS_CONTINUE_READING;
2734 }
2735
2736 /*
2737  * Perform miscellaneous checks and processing after we have received the
2738  * server's initial flight. In TLS1.3 this is after the Server Finished message.
2739  * In <=TLS1.2 this is after the ServerDone message. Returns 1 on success or 0
2740  * on failure.
2741  */
2742 int tls_process_initial_server_flight(SSL *s)
2743 {
2744     /*
2745      * at this point we check that we have the required stuff from
2746      * the server
2747      */
2748     if (!ssl3_check_cert_and_algorithm(s)) {
2749         /* SSLfatal() already called */
2750         return 0;
2751     }
2752
2753     /*
2754      * Call the ocsp status callback if needed. The |ext.ocsp.resp| and
2755      * |ext.ocsp.resp_len| values will be set if we actually received a status
2756      * message, or NULL and -1 otherwise
2757      */
2758     if (s->ext.status_type != TLSEXT_STATUSTYPE_nothing
2759             && s->ctx->ext.status_cb != NULL) {
2760         int ret = s->ctx->ext.status_cb(s, s->ctx->ext.status_arg);
2761
2762         if (ret == 0) {
2763             SSLfatal(s, SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE,
2764                      SSL_F_TLS_PROCESS_INITIAL_SERVER_FLIGHT,
2765                      SSL_R_INVALID_STATUS_RESPONSE);
2766             return 0;
2767         }
2768         if (ret < 0) {
2769             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2770                      SSL_F_TLS_PROCESS_INITIAL_SERVER_FLIGHT,
2771                      ERR_R_MALLOC_FAILURE);
2772             return 0;
2773         }
2774     }
2775 #ifndef OPENSSL_NO_CT
2776     if (s->ct_validation_callback != NULL) {
2777         /* Note we validate the SCTs whether or not we abort on error */
2778         if (!ssl_validate_ct(s) && (s->verify_mode & SSL_VERIFY_PEER)) {
2779             /* SSLfatal() already called */
2780             return 0;
2781         }
2782     }
2783 #endif
2784
2785     return 1;
2786 }
2787
2788 MSG_PROCESS_RETURN tls_process_server_done(SSL *s, PACKET *pkt)
2789 {
2790     if (PACKET_remaining(pkt) > 0) {
2791         /* should contain no data */
2792         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_SERVER_DONE,
2793                  SSL_R_LENGTH_MISMATCH);
2794         return MSG_PROCESS_ERROR;
2795     }
2796 #ifndef OPENSSL_NO_SRP
2797     if (s->s3->tmp.new_cipher->algorithm_mkey & SSL_kSRP) {
2798         if (SRP_Calc_A_param(s) <= 0) {
2799             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_SERVER_DONE,
2800                      SSL_R_SRP_A_CALC);
2801             return MSG_PROCESS_ERROR;
2802         }
2803     }
2804 #endif
2805
2806     if (!tls_process_initial_server_flight(s)) {
2807         /* SSLfatal() already called */
2808         return MSG_PROCESS_ERROR;
2809     }
2810
2811     return MSG_PROCESS_FINISHED_READING;
2812 }
2813
2814 static int tls_construct_cke_psk_preamble(SSL *s, WPACKET *pkt)
2815 {
2816 #ifndef OPENSSL_NO_PSK
2817     int ret = 0;
2818     /*
2819      * The callback needs PSK_MAX_IDENTITY_LEN + 1 bytes to return a
2820      * \0-terminated identity. The last byte is for us for simulating
2821      * strnlen.
2822      */
2823     char identity[PSK_MAX_IDENTITY_LEN + 1];
2824     size_t identitylen = 0;
2825     unsigned char psk[PSK_MAX_PSK_LEN];
2826     unsigned char *tmppsk = NULL;
2827     char *tmpidentity = NULL;
2828     size_t psklen = 0;
2829
2830     if (s->psk_client_callback == NULL) {
2831         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE,
2832                  SSL_R_PSK_NO_CLIENT_CB);
2833         goto err;
2834     }
2835
2836     memset(identity, 0, sizeof(identity));
2837
2838     psklen = s->psk_client_callback(s, s->session->psk_identity_hint,
2839                                     identity, sizeof(identity) - 1,
2840                                     psk, sizeof(psk));
2841
2842     if (psklen > PSK_MAX_PSK_LEN) {
2843         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
2844                  SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE, ERR_R_INTERNAL_ERROR);
2845         goto err;
2846     } else if (psklen == 0) {
2847         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
2848                  SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE,
2849                  SSL_R_PSK_IDENTITY_NOT_FOUND);
2850         goto err;
2851     }
2852
2853     identitylen = strlen(identity);
2854     if (identitylen > PSK_MAX_IDENTITY_LEN) {
2855         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE,
2856                  ERR_R_INTERNAL_ERROR);
2857         goto err;
2858     }
2859
2860     tmppsk = OPENSSL_memdup(psk, psklen);
2861     tmpidentity = OPENSSL_strdup(identity);
2862     if (tmppsk == NULL || tmpidentity == NULL) {
2863         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE,
2864                  ERR_R_MALLOC_FAILURE);
2865         goto err;
2866     }
2867
2868     OPENSSL_free(s->s3->tmp.psk);
2869     s->s3->tmp.psk = tmppsk;
2870     s->s3->tmp.psklen = psklen;
2871     tmppsk = NULL;
2872     OPENSSL_free(s->session->psk_identity);
2873     s->session->psk_identity = tmpidentity;
2874     tmpidentity = NULL;
2875
2876     if (!WPACKET_sub_memcpy_u16(pkt, identity, identitylen))  {
2877         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE,
2878                  ERR_R_INTERNAL_ERROR);
2879         goto err;
2880     }
2881
2882     ret = 1;
2883
2884  err:
2885     OPENSSL_cleanse(psk, psklen);
2886     OPENSSL_cleanse(identity, sizeof(identity));
2887     OPENSSL_clear_free(tmppsk, psklen);
2888     OPENSSL_clear_free(tmpidentity, identitylen);
2889
2890     return ret;
2891 #else
2892     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE,
2893              ERR_R_INTERNAL_ERROR);
2894     return 0;
2895 #endif
2896 }
2897
2898 static int tls_construct_cke_rsa(SSL *s, WPACKET *pkt)
2899 {
2900 #ifndef OPENSSL_NO_RSA
2901     unsigned char *encdata = NULL;
2902     EVP_PKEY *pkey = NULL;
2903     EVP_PKEY_CTX *pctx = NULL;
2904     size_t enclen;
2905     unsigned char *pms = NULL;
2906     size_t pmslen = 0;
2907
2908     if (s->session->peer == NULL) {
2909         /*
2910          * We should always have a server certificate with SSL_kRSA.
2911          */
2912         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_RSA,
2913                  ERR_R_INTERNAL_ERROR);
2914         return 0;
2915     }
2916
2917     pkey = X509_get0_pubkey(s->session->peer);
2918     if (EVP_PKEY_get0_RSA(pkey) == NULL) {
2919         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_RSA,
2920                  ERR_R_INTERNAL_ERROR);
2921         return 0;
2922     }
2923
2924     pmslen = SSL_MAX_MASTER_KEY_LENGTH;
2925     pms = OPENSSL_malloc(pmslen);
2926     if (pms == NULL) {
2927         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_RSA,
2928                  ERR_R_MALLOC_FAILURE);
2929         return 0;
2930     }
2931
2932     pms[0] = s->client_version >> 8;
2933     pms[1] = s->client_version & 0xff;
2934     /* TODO(size_t): Convert this function */
2935     if (RAND_bytes(pms + 2, (int)(pmslen - 2)) <= 0) {
2936         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_RSA,
2937                  ERR_R_MALLOC_FAILURE);
2938         goto err;
2939     }
2940
2941     /* Fix buf for TLS and beyond */
2942     if (s->version > SSL3_VERSION && !WPACKET_start_sub_packet_u16(pkt)) {
2943         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_RSA,
2944                  ERR_R_INTERNAL_ERROR);
2945         goto err;
2946     }
2947     pctx = EVP_PKEY_CTX_new(pkey, NULL);
2948     if (pctx == NULL || EVP_PKEY_encrypt_init(pctx) <= 0
2949         || EVP_PKEY_encrypt(pctx, NULL, &enclen, pms, pmslen) <= 0) {
2950         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_RSA,
2951                  ERR_R_EVP_LIB);
2952         goto err;
2953     }
2954     if (!WPACKET_allocate_bytes(pkt, enclen, &encdata)
2955             || EVP_PKEY_encrypt(pctx, encdata, &enclen, pms, pmslen) <= 0) {
2956         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_RSA,
2957                  SSL_R_BAD_RSA_ENCRYPT);
2958         goto err;
2959     }
2960     EVP_PKEY_CTX_free(pctx);
2961     pctx = NULL;
2962
2963     /* Fix buf for TLS and beyond */
2964     if (s->version > SSL3_VERSION && !WPACKET_close(pkt)) {
2965         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_RSA,
2966                  ERR_R_INTERNAL_ERROR);
2967         goto err;
2968     }
2969
2970     /* Log the premaster secret, if logging is enabled. */
2971     if (!ssl_log_rsa_client_key_exchange(s, encdata, enclen, pms, pmslen)) {
2972         /* SSLfatal() already called */
2973         goto err;
2974     }
2975
2976     s->s3->tmp.pms = pms;
2977     s->s3->tmp.pmslen = pmslen;
2978
2979     return 1;
2980  err:
2981     OPENSSL_clear_free(pms, pmslen);
2982     EVP_PKEY_CTX_free(pctx);
2983
2984     return 0;
2985 #else
2986     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_RSA,
2987              ERR_R_INTERNAL_ERROR);
2988     return 0;
2989 #endif
2990 }
2991
2992 static int tls_construct_cke_dhe(SSL *s, WPACKET *pkt)
2993 {
2994 #ifndef OPENSSL_NO_DH
2995     DH *dh_clnt = NULL;
2996     const BIGNUM *pub_key;
2997     EVP_PKEY *ckey = NULL, *skey = NULL;
2998     unsigned char *keybytes = NULL;
2999
3000     skey = s->s3->peer_tmp;
3001     if (skey == NULL) {
3002         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_DHE,
3003                  ERR_R_INTERNAL_ERROR);
3004         goto err;
3005     }
3006
3007     ckey = ssl_generate_pkey(skey);
3008     if (ckey == NULL) {
3009         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_DHE,
3010                  ERR_R_INTERNAL_ERROR);
3011         goto err;
3012     }
3013
3014     dh_clnt = EVP_PKEY_get0_DH(ckey);
3015
3016     if (dh_clnt == 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     if (ssl_derive(s, ckey, skey, 0) == 0) {
3023         /* SSLfatal() already called */
3024         goto err;
3025     }
3026
3027     /* send off the data */
3028     DH_get0_key(dh_clnt, &pub_key, NULL);
3029     if (!WPACKET_sub_allocate_bytes_u16(pkt, BN_num_bytes(pub_key),
3030                                         &keybytes)) {
3031         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_DHE,
3032                  ERR_R_INTERNAL_ERROR);
3033         goto err;
3034     }
3035
3036     BN_bn2bin(pub_key, keybytes);
3037     EVP_PKEY_free(ckey);
3038
3039     return 1;
3040  err:
3041     EVP_PKEY_free(ckey);
3042     return 0;
3043 #else
3044     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_DHE,
3045              ERR_R_INTERNAL_ERROR);
3046     return 0;
3047 #endif
3048 }
3049
3050 static int tls_construct_cke_ecdhe(SSL *s, WPACKET *pkt)
3051 {
3052 #ifndef OPENSSL_NO_EC
3053     unsigned char *encodedPoint = NULL;
3054     size_t encoded_pt_len = 0;
3055     EVP_PKEY *ckey = NULL, *skey = NULL;
3056     int ret = 0;
3057
3058     skey = s->s3->peer_tmp;
3059     if (skey == NULL) {
3060         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_ECDHE,
3061                  ERR_R_INTERNAL_ERROR);
3062         return 0;
3063     }
3064
3065     ckey = ssl_generate_pkey(skey);
3066     if (ckey == NULL) {
3067         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_ECDHE,
3068                  ERR_R_MALLOC_FAILURE);
3069         goto err;
3070     }
3071
3072     if (ssl_derive(s, ckey, skey, 0) == 0) {
3073         /* SSLfatal() already called */
3074         goto err;
3075     }
3076
3077     /* Generate encoding of client key */
3078     encoded_pt_len = EVP_PKEY_get1_tls_encodedpoint(ckey, &encodedPoint);
3079
3080     if (encoded_pt_len == 0) {
3081         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_ECDHE,
3082                  ERR_R_EC_LIB);
3083         goto err;
3084     }
3085
3086     if (!WPACKET_sub_memcpy_u8(pkt, encodedPoint, encoded_pt_len)) {
3087         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_ECDHE,
3088                  ERR_R_INTERNAL_ERROR);
3089         goto err;
3090     }
3091
3092     ret = 1;
3093  err:
3094     OPENSSL_free(encodedPoint);
3095     EVP_PKEY_free(ckey);
3096     return ret;
3097 #else
3098     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_ECDHE,
3099              ERR_R_INTERNAL_ERROR);
3100     return 0;
3101 #endif
3102 }
3103
3104 static int tls_construct_cke_gost(SSL *s, WPACKET *pkt)
3105 {
3106 #ifndef OPENSSL_NO_GOST
3107     /* GOST key exchange message creation */
3108     EVP_PKEY_CTX *pkey_ctx = NULL;
3109     X509 *peer_cert;
3110     size_t msglen;
3111     unsigned int md_len;
3112     unsigned char shared_ukm[32], tmp[256];
3113     EVP_MD_CTX *ukm_hash = NULL;
3114     int dgst_nid = NID_id_GostR3411_94;
3115     unsigned char *pms = NULL;
3116     size_t pmslen = 0;
3117
3118     if ((s->s3->tmp.new_cipher->algorithm_auth & SSL_aGOST12) != 0)
3119         dgst_nid = NID_id_GostR3411_2012_256;
3120
3121     /*
3122      * Get server certificate PKEY and create ctx from it
3123      */
3124     peer_cert = s->session->peer;
3125     if (!peer_cert) {
3126         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_F_TLS_CONSTRUCT_CKE_GOST,
3127                SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER);
3128         return 0;
3129     }
3130
3131     pkey_ctx = EVP_PKEY_CTX_new(X509_get0_pubkey(peer_cert), NULL);
3132     if (pkey_ctx == NULL) {
3133         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_GOST,
3134                  ERR_R_MALLOC_FAILURE);
3135         return 0;
3136     }
3137     /*
3138      * If we have send a certificate, and certificate key
3139      * parameters match those of server certificate, use
3140      * certificate key for key exchange
3141      */
3142
3143     /* Otherwise, generate ephemeral key pair */
3144     pmslen = 32;
3145     pms = OPENSSL_malloc(pmslen);
3146     if (pms == NULL) {
3147         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_GOST,
3148                  ERR_R_MALLOC_FAILURE);
3149         goto err;
3150     }
3151
3152     if (EVP_PKEY_encrypt_init(pkey_ctx) <= 0
3153         /* Generate session key
3154          * TODO(size_t): Convert this function
3155          */
3156         || RAND_bytes(pms, (int)pmslen) <= 0) {
3157         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_GOST,
3158                  ERR_R_INTERNAL_ERROR);
3159         goto err;
3160     };
3161     /*
3162      * Compute shared IV and store it in algorithm-specific context
3163      * data
3164      */
3165     ukm_hash = EVP_MD_CTX_new();
3166     if (ukm_hash == NULL
3167         || EVP_DigestInit(ukm_hash, EVP_get_digestbynid(dgst_nid)) <= 0
3168         || EVP_DigestUpdate(ukm_hash, s->s3->client_random,
3169                             SSL3_RANDOM_SIZE) <= 0
3170         || EVP_DigestUpdate(ukm_hash, s->s3->server_random,
3171                             SSL3_RANDOM_SIZE) <= 0
3172         || EVP_DigestFinal_ex(ukm_hash, shared_ukm, &md_len) <= 0) {
3173         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_GOST,
3174                  ERR_R_INTERNAL_ERROR);
3175         goto err;
3176     }
3177     EVP_MD_CTX_free(ukm_hash);
3178     ukm_hash = NULL;
3179     if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_ENCRYPT,
3180                           EVP_PKEY_CTRL_SET_IV, 8, shared_ukm) < 0) {
3181         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_GOST,
3182                  SSL_R_LIBRARY_BUG);
3183         goto err;
3184     }
3185     /* Make GOST keytransport blob message */
3186     /*
3187      * Encapsulate it into sequence
3188      */
3189     msglen = 255;
3190     if (EVP_PKEY_encrypt(pkey_ctx, tmp, &msglen, pms, pmslen) <= 0) {
3191         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_GOST,
3192                  SSL_R_LIBRARY_BUG);
3193         goto err;
3194     }
3195
3196     if (!WPACKET_put_bytes_u8(pkt, V_ASN1_SEQUENCE | V_ASN1_CONSTRUCTED)
3197             || (msglen >= 0x80 && !WPACKET_put_bytes_u8(pkt, 0x81))
3198             || !WPACKET_sub_memcpy_u8(pkt, tmp, msglen)) {
3199         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_GOST,
3200                  ERR_R_INTERNAL_ERROR);
3201         goto err;
3202     }
3203
3204     EVP_PKEY_CTX_free(pkey_ctx);
3205     s->s3->tmp.pms = pms;
3206     s->s3->tmp.pmslen = pmslen;
3207
3208     return 1;
3209  err:
3210     EVP_PKEY_CTX_free(pkey_ctx);
3211     OPENSSL_clear_free(pms, pmslen);
3212     EVP_MD_CTX_free(ukm_hash);
3213     return 0;
3214 #else
3215     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_GOST,
3216              ERR_R_INTERNAL_ERROR);
3217     return 0;
3218 #endif
3219 }
3220
3221 static int tls_construct_cke_srp(SSL *s, WPACKET *pkt)
3222 {
3223 #ifndef OPENSSL_NO_SRP
3224     unsigned char *abytes = NULL;
3225
3226     if (s->srp_ctx.A == NULL
3227             || !WPACKET_sub_allocate_bytes_u16(pkt, BN_num_bytes(s->srp_ctx.A),
3228                                                &abytes)) {
3229         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_SRP,
3230                  ERR_R_INTERNAL_ERROR);
3231         return 0;
3232     }
3233     BN_bn2bin(s->srp_ctx.A, abytes);
3234
3235     OPENSSL_free(s->session->srp_username);
3236     s->session->srp_username = OPENSSL_strdup(s->srp_ctx.login);
3237     if (s->session->srp_username == NULL) {
3238         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_SRP,
3239                  ERR_R_MALLOC_FAILURE);
3240         return 0;
3241     }
3242
3243     return 1;
3244 #else
3245     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CKE_SRP,
3246              ERR_R_INTERNAL_ERROR);
3247     return 0;
3248 #endif
3249 }
3250
3251 int tls_construct_client_key_exchange(SSL *s, WPACKET *pkt)
3252 {
3253     unsigned long alg_k;
3254
3255     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
3256
3257     /*
3258      * All of the construct functions below call SSLfatal() if necessary so
3259      * no need to do so here.
3260      */
3261     if ((alg_k & SSL_PSK)
3262         && !tls_construct_cke_psk_preamble(s, pkt))
3263         goto err;
3264
3265     if (alg_k & (SSL_kRSA | SSL_kRSAPSK)) {
3266         if (!tls_construct_cke_rsa(s, pkt))
3267             goto err;
3268     } else if (alg_k & (SSL_kDHE | SSL_kDHEPSK)) {
3269         if (!tls_construct_cke_dhe(s, pkt))
3270             goto err;
3271     } else if (alg_k & (SSL_kECDHE | SSL_kECDHEPSK)) {
3272         if (!tls_construct_cke_ecdhe(s, pkt))
3273             goto err;
3274     } else if (alg_k & SSL_kGOST) {
3275         if (!tls_construct_cke_gost(s, pkt))
3276             goto err;
3277     } else if (alg_k & SSL_kSRP) {
3278         if (!tls_construct_cke_srp(s, pkt))
3279             goto err;
3280     } else if (!(alg_k & SSL_kPSK)) {
3281         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
3282                  SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
3283         goto err;
3284     }
3285
3286     return 1;
3287  err:
3288     OPENSSL_clear_free(s->s3->tmp.pms, s->s3->tmp.pmslen);
3289     s->s3->tmp.pms = NULL;
3290 #ifndef OPENSSL_NO_PSK
3291     OPENSSL_clear_free(s->s3->tmp.psk, s->s3->tmp.psklen);
3292     s->s3->tmp.psk = NULL;
3293 #endif
3294     return 0;
3295 }
3296
3297 int tls_client_key_exchange_post_work(SSL *s)
3298 {
3299     unsigned char *pms = NULL;
3300     size_t pmslen = 0;
3301
3302     pms = s->s3->tmp.pms;
3303     pmslen = s->s3->tmp.pmslen;
3304
3305 #ifndef OPENSSL_NO_SRP
3306     /* Check for SRP */
3307     if (s->s3->tmp.new_cipher->algorithm_mkey & SSL_kSRP) {
3308         if (!srp_generate_client_master_secret(s)) {
3309             /* SSLfatal() already called */
3310             goto err;
3311         }
3312         return 1;
3313     }
3314 #endif
3315
3316     if (pms == NULL && !(s->s3->tmp.new_cipher->algorithm_mkey & SSL_kPSK)) {
3317         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
3318                  SSL_F_TLS_CLIENT_KEY_EXCHANGE_POST_WORK, ERR_R_MALLOC_FAILURE);
3319         goto err;
3320     }
3321     if (!ssl_generate_master_secret(s, pms, pmslen, 1)) {
3322         /* SSLfatal() already called */
3323         /* ssl_generate_master_secret frees the pms even on error */
3324         pms = NULL;
3325         pmslen = 0;
3326         goto err;
3327     }
3328     pms = NULL;
3329     pmslen = 0;
3330
3331 #ifndef OPENSSL_NO_SCTP
3332     if (SSL_IS_DTLS(s)) {
3333         unsigned char sctpauthkey[64];
3334         char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)];
3335
3336         /*
3337          * Add new shared key for SCTP-Auth, will be ignored if no SCTP
3338          * used.
3339          */
3340         memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL,
3341                sizeof(DTLS1_SCTP_AUTH_LABEL));
3342
3343         if (SSL_export_keying_material(s, sctpauthkey,
3344                                        sizeof(sctpauthkey), labelbuffer,
3345                                        sizeof(labelbuffer), NULL, 0, 0) <= 0) {
3346             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
3347                      SSL_F_TLS_CLIENT_KEY_EXCHANGE_POST_WORK,
3348                      ERR_R_INTERNAL_ERROR);
3349             goto err;
3350         }
3351
3352         BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
3353                  sizeof(sctpauthkey), sctpauthkey);
3354     }
3355 #endif
3356
3357     return 1;
3358  err:
3359     OPENSSL_clear_free(pms, pmslen);
3360     s->s3->tmp.pms = NULL;
3361     return 0;
3362 }
3363
3364 /*
3365  * Check a certificate can be used for client authentication. Currently check
3366  * cert exists, if we have a suitable digest for TLS 1.2 if static DH client
3367  * certificates can be used and optionally checks suitability for Suite B.
3368  */
3369 static int ssl3_check_client_certificate(SSL *s)
3370 {
3371     /* If no suitable signature algorithm can't use certificate */
3372     if (!tls_choose_sigalg(s, 0) || s->s3->tmp.sigalg == NULL)
3373         return 0;
3374     /*
3375      * If strict mode check suitability of chain before using it. This also
3376      * adjusts suite B digest if necessary.
3377      */
3378     if (s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT &&
3379         !tls1_check_chain(s, NULL, NULL, NULL, -2))
3380         return 0;
3381     return 1;
3382 }
3383
3384 WORK_STATE tls_prepare_client_certificate(SSL *s, WORK_STATE wst)
3385 {
3386     X509 *x509 = NULL;
3387     EVP_PKEY *pkey = NULL;
3388     int i;
3389
3390     if (wst == WORK_MORE_A) {
3391         /* Let cert callback update client certificates if required */
3392         if (s->cert->cert_cb) {
3393             i = s->cert->cert_cb(s, s->cert->cert_cb_arg);
3394             if (i < 0) {
3395                 s->rwstate = SSL_X509_LOOKUP;
3396                 return WORK_MORE_A;
3397             }
3398             if (i == 0) {
3399                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
3400                          SSL_F_TLS_PREPARE_CLIENT_CERTIFICATE,
3401                          SSL_R_CALLBACK_FAILED);
3402                 return WORK_ERROR;
3403             }
3404             s->rwstate = SSL_NOTHING;
3405         }
3406         if (ssl3_check_client_certificate(s)) {
3407             if (s->post_handshake_auth == SSL_PHA_REQUESTED) {
3408                 return WORK_FINISHED_STOP;
3409             }
3410             return WORK_FINISHED_CONTINUE;
3411         }
3412
3413         /* Fall through to WORK_MORE_B */
3414         wst = WORK_MORE_B;
3415     }
3416
3417     /* We need to get a client cert */
3418     if (wst == WORK_MORE_B) {
3419         /*
3420          * If we get an error, we need to ssl->rwstate=SSL_X509_LOOKUP;
3421          * return(-1); We then get retied later
3422          */
3423         i = ssl_do_client_cert_cb(s, &x509, &pkey);
3424         if (i < 0) {
3425             s->rwstate = SSL_X509_LOOKUP;
3426             return WORK_MORE_B;
3427         }
3428         s->rwstate = SSL_NOTHING;
3429         if ((i == 1) && (pkey != NULL) && (x509 != NULL)) {
3430             if (!SSL_use_certificate(s, x509) || !SSL_use_PrivateKey(s, pkey))
3431                 i = 0;
3432         } else if (i == 1) {
3433             i = 0;
3434             SSLerr(SSL_F_TLS_PREPARE_CLIENT_CERTIFICATE,
3435                    SSL_R_BAD_DATA_RETURNED_BY_CALLBACK);
3436         }
3437
3438         X509_free(x509);
3439         EVP_PKEY_free(pkey);
3440         if (i && !ssl3_check_client_certificate(s))
3441             i = 0;
3442         if (i == 0) {
3443             if (s->version == SSL3_VERSION) {
3444                 s->s3->tmp.cert_req = 0;
3445                 ssl3_send_alert(s, SSL3_AL_WARNING, SSL_AD_NO_CERTIFICATE);
3446                 return WORK_FINISHED_CONTINUE;
3447             } else {
3448                 s->s3->tmp.cert_req = 2;
3449                 if (!ssl3_digest_cached_records(s, 0)) {
3450                     /* SSLfatal() already called */
3451                     return WORK_ERROR;
3452                 }
3453             }
3454         }
3455
3456         if (s->post_handshake_auth == SSL_PHA_REQUESTED)
3457             return WORK_FINISHED_STOP;
3458         return WORK_FINISHED_CONTINUE;
3459     }
3460
3461     /* Shouldn't ever get here */
3462     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PREPARE_CLIENT_CERTIFICATE,
3463              ERR_R_INTERNAL_ERROR);
3464     return WORK_ERROR;
3465 }
3466
3467 int tls_construct_client_certificate(SSL *s, WPACKET *pkt)
3468 {
3469     if (SSL_IS_TLS13(s)) {
3470         if (s->pha_context == NULL) {
3471             /* no context available, add 0-length context */
3472             if (!WPACKET_put_bytes_u8(pkt, 0)) {
3473                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
3474                          SSL_F_TLS_CONSTRUCT_CLIENT_CERTIFICATE, ERR_R_INTERNAL_ERROR);
3475                 return 0;
3476             }
3477         } else if (!WPACKET_sub_memcpy_u8(pkt, s->pha_context, s->pha_context_len)) {
3478             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
3479                      SSL_F_TLS_CONSTRUCT_CLIENT_CERTIFICATE, ERR_R_INTERNAL_ERROR);
3480             return 0;
3481         }
3482     }
3483     if (!ssl3_output_cert_chain(s, pkt,
3484                                 (s->s3->tmp.cert_req == 2) ? NULL
3485                                                            : s->cert->key)) {
3486         /* SSLfatal() already called */
3487         return 0;
3488     }
3489
3490     if (SSL_IS_TLS13(s)
3491             && SSL_IS_FIRST_HANDSHAKE(s)
3492             && (!s->method->ssl3_enc->change_cipher_state(s,
3493                     SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_WRITE))) {
3494         /*
3495          * This is a fatal error, which leaves enc_write_ctx in an inconsistent
3496          * state and thus ssl3_send_alert may crash.
3497          */
3498         SSLfatal(s, SSL_AD_NO_ALERT, SSL_F_TLS_CONSTRUCT_CLIENT_CERTIFICATE,
3499                  SSL_R_CANNOT_CHANGE_CIPHER);
3500         return 0;
3501     }
3502
3503     return 1;
3504 }
3505
3506 int ssl3_check_cert_and_algorithm(SSL *s)
3507 {
3508     const SSL_CERT_LOOKUP *clu;
3509     size_t idx;
3510     long alg_k, alg_a;
3511
3512     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
3513     alg_a = s->s3->tmp.new_cipher->algorithm_auth;
3514
3515     /* we don't have a certificate */
3516     if (!(alg_a & SSL_aCERT))
3517         return 1;
3518
3519     /* This is the passed certificate */
3520     clu = ssl_cert_lookup_by_pkey(X509_get0_pubkey(s->session->peer), &idx);
3521
3522     /* Check certificate is recognised and suitable for cipher */
3523     if (clu == NULL || (alg_a & clu->amask) == 0) {
3524         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
3525                  SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3526                  SSL_R_MISSING_SIGNING_CERT);
3527         return 0;
3528     }
3529
3530 #ifndef OPENSSL_NO_EC
3531     if (clu->amask & SSL_aECDSA) {
3532         if (ssl_check_srvr_ecc_cert_and_alg(s->session->peer, s))
3533             return 1;
3534         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
3535                  SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM, SSL_R_BAD_ECC_CERT);
3536         return 0;
3537     }
3538 #endif
3539 #ifndef OPENSSL_NO_RSA
3540     if (alg_k & (SSL_kRSA | SSL_kRSAPSK) && idx != SSL_PKEY_RSA) {
3541         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
3542                  SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3543                  SSL_R_MISSING_RSA_ENCRYPTING_CERT);
3544         return 0;
3545     }
3546 #endif
3547 #ifndef OPENSSL_NO_DH
3548     if ((alg_k & SSL_kDHE) && (s->s3->peer_tmp == NULL)) {
3549         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3550                  ERR_R_INTERNAL_ERROR);
3551         return 0;
3552     }
3553 #endif
3554
3555     return 1;
3556 }
3557
3558 #ifndef OPENSSL_NO_NEXTPROTONEG
3559 int tls_construct_next_proto(SSL *s, WPACKET *pkt)
3560 {
3561     size_t len, padding_len;
3562     unsigned char *padding = NULL;
3563
3564     len = s->ext.npn_len;
3565     padding_len = 32 - ((len + 2) % 32);
3566
3567     if (!WPACKET_sub_memcpy_u8(pkt, s->ext.npn, len)
3568             || !WPACKET_sub_allocate_bytes_u8(pkt, padding_len, &padding)) {
3569         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_NEXT_PROTO,
3570                  ERR_R_INTERNAL_ERROR);
3571         return 0;
3572     }
3573
3574     memset(padding, 0, padding_len);
3575
3576     return 1;
3577 }
3578 #endif
3579
3580 MSG_PROCESS_RETURN tls_process_hello_req(SSL *s, PACKET *pkt)
3581 {
3582     if (PACKET_remaining(pkt) > 0) {
3583         /* should contain no data */
3584         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_HELLO_REQ,
3585                  SSL_R_LENGTH_MISMATCH);
3586         return MSG_PROCESS_ERROR;
3587     }
3588
3589     if ((s->options & SSL_OP_NO_RENEGOTIATION)) {
3590         ssl3_send_alert(s, SSL3_AL_WARNING, SSL_AD_NO_RENEGOTIATION);
3591         return MSG_PROCESS_FINISHED_READING;
3592     }
3593
3594     /*
3595      * This is a historical discrepancy (not in the RFC) maintained for
3596      * compatibility reasons. If a TLS client receives a HelloRequest it will
3597      * attempt an abbreviated handshake. However if a DTLS client receives a
3598      * HelloRequest it will do a full handshake. Either behaviour is reasonable
3599      * but doing one for TLS and another for DTLS is odd.
3600      */
3601     if (SSL_IS_DTLS(s))
3602         SSL_renegotiate(s);
3603     else
3604         SSL_renegotiate_abbreviated(s);
3605
3606     return MSG_PROCESS_FINISHED_READING;
3607 }
3608
3609 static MSG_PROCESS_RETURN tls_process_encrypted_extensions(SSL *s, PACKET *pkt)
3610 {
3611     PACKET extensions;
3612     RAW_EXTENSION *rawexts = NULL;
3613
3614     if (!PACKET_as_length_prefixed_2(pkt, &extensions)
3615             || PACKET_remaining(pkt) != 0) {
3616         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_ENCRYPTED_EXTENSIONS,
3617                  SSL_R_LENGTH_MISMATCH);
3618         goto err;
3619     }
3620
3621     if (!tls_collect_extensions(s, &extensions,
3622                                 SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS, &rawexts,
3623                                 NULL, 1)
3624             || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
3625                                          rawexts, NULL, 0, 1)) {
3626         /* SSLfatal() already called */
3627         goto err;
3628     }
3629
3630     OPENSSL_free(rawexts);
3631     return MSG_PROCESS_CONTINUE_READING;
3632
3633  err:
3634     OPENSSL_free(rawexts);
3635     return MSG_PROCESS_ERROR;
3636 }
3637
3638 int ssl_do_client_cert_cb(SSL *s, X509 **px509, EVP_PKEY **ppkey)
3639 {
3640     int i = 0;
3641 #ifndef OPENSSL_NO_ENGINE
3642     if (s->ctx->client_cert_engine) {
3643         i = ENGINE_load_ssl_client_cert(s->ctx->client_cert_engine, s,
3644                                         SSL_get_client_CA_list(s),
3645                                         px509, ppkey, NULL, NULL, NULL);
3646         if (i != 0)
3647             return i;
3648     }
3649 #endif
3650     if (s->ctx->client_cert_cb)
3651         i = s->ctx->client_cert_cb(s, px509, ppkey);
3652     return i;
3653 }
3654
3655 int ssl_cipher_list_to_bytes(SSL *s, STACK_OF(SSL_CIPHER) *sk, WPACKET *pkt)
3656 {
3657     int i;
3658     size_t totlen = 0, len, maxlen, maxverok = 0;
3659     int empty_reneg_info_scsv = !s->renegotiate;
3660
3661     /* Set disabled masks for this session */
3662     if (!ssl_set_client_disabled(s)) {
3663         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL_CIPHER_LIST_TO_BYTES,
3664                  SSL_R_NO_PROTOCOLS_AVAILABLE);
3665         return 0;
3666     }
3667
3668     if (sk == NULL) {
3669         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL_CIPHER_LIST_TO_BYTES,
3670                  ERR_R_INTERNAL_ERROR);
3671         return 0;
3672     }
3673
3674 #ifdef OPENSSL_MAX_TLS1_2_CIPHER_LENGTH
3675 # if OPENSSL_MAX_TLS1_2_CIPHER_LENGTH < 6
3676 #  error Max cipher length too short
3677 # endif
3678     /*
3679      * Some servers hang if client hello > 256 bytes as hack workaround
3680      * chop number of supported ciphers to keep it well below this if we
3681      * use TLS v1.2
3682      */
3683     if (TLS1_get_version(s) >= TLS1_2_VERSION)
3684         maxlen = OPENSSL_MAX_TLS1_2_CIPHER_LENGTH & ~1;
3685     else
3686 #endif
3687         /* Maximum length that can be stored in 2 bytes. Length must be even */
3688         maxlen = 0xfffe;
3689
3690     if (empty_reneg_info_scsv)
3691         maxlen -= 2;
3692     if (s->mode & SSL_MODE_SEND_FALLBACK_SCSV)
3693         maxlen -= 2;
3694
3695     for (i = 0; i < sk_SSL_CIPHER_num(sk) && totlen < maxlen; i++) {
3696         const SSL_CIPHER *c;
3697
3698         c = sk_SSL_CIPHER_value(sk, i);
3699         /* Skip disabled ciphers */
3700         if (ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_SUPPORTED, 0))
3701             continue;
3702
3703         if (!s->method->put_cipher_by_char(c, pkt, &len)) {
3704             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL_CIPHER_LIST_TO_BYTES,
3705                      ERR_R_INTERNAL_ERROR);
3706             return 0;
3707         }
3708
3709         /* Sanity check that the maximum version we offer has ciphers enabled */
3710         if (!maxverok) {
3711             if (SSL_IS_DTLS(s)) {
3712                 if (DTLS_VERSION_GE(c->max_dtls, s->s3->tmp.max_ver)
3713                         && DTLS_VERSION_LE(c->min_dtls, s->s3->tmp.max_ver))
3714                     maxverok = 1;
3715             } else {
3716                 if (c->max_tls >= s->s3->tmp.max_ver
3717                         && c->min_tls <= s->s3->tmp.max_ver)
3718                     maxverok = 1;
3719             }
3720         }
3721
3722         totlen += len;
3723     }
3724
3725     if (totlen == 0 || !maxverok) {
3726         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL_CIPHER_LIST_TO_BYTES,
3727                  SSL_R_NO_CIPHERS_AVAILABLE);
3728
3729         if (!maxverok)
3730             ERR_add_error_data(1, "No ciphers enabled for max supported "
3731                                   "SSL/TLS version");
3732
3733         return 0;
3734     }
3735
3736     if (totlen != 0) {
3737         if (empty_reneg_info_scsv) {
3738             static SSL_CIPHER scsv = {
3739                 0, NULL, NULL, SSL3_CK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0
3740             };
3741             if (!s->method->put_cipher_by_char(&scsv, pkt, &len)) {
3742                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
3743                          SSL_F_SSL_CIPHER_LIST_TO_BYTES, ERR_R_INTERNAL_ERROR);
3744                 return 0;
3745             }
3746         }
3747         if (s->mode & SSL_MODE_SEND_FALLBACK_SCSV) {
3748             static SSL_CIPHER scsv = {
3749                 0, NULL, NULL, SSL3_CK_FALLBACK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0
3750             };
3751             if (!s->method->put_cipher_by_char(&scsv, pkt, &len)) {
3752                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
3753                          SSL_F_SSL_CIPHER_LIST_TO_BYTES, ERR_R_INTERNAL_ERROR);
3754                 return 0;
3755             }
3756         }
3757     }
3758
3759     return 1;
3760 }
3761
3762 int tls_construct_end_of_early_data(SSL *s, WPACKET *pkt)
3763 {
3764     if (s->early_data_state != SSL_EARLY_DATA_WRITE_RETRY
3765             && s->early_data_state != SSL_EARLY_DATA_FINISHED_WRITING) {
3766         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
3767                  SSL_F_TLS_CONSTRUCT_END_OF_EARLY_DATA,
3768                  ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
3769         return 0;
3770     }
3771
3772     s->early_data_state = SSL_EARLY_DATA_FINISHED_WRITING;
3773     return 1;
3774 }