ssl/statem/statem_clnt.c

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