ssl/statem/statem_clnt.c

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