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