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