ssl/statem/statem_lib.c

   1 /*
   2  * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
   3  * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
   4  *
   5  * Licensed under the Apache License 2.0 (the "License").  You may not use
   6  * this file except in compliance with the License.  You can obtain a copy
   7  * in the file LICENSE in the source distribution or at
   8  * https://www.openssl.org/source/license.html
   9  */
  10
  11 #include <limits.h>
  12 #include <string.h>
  13 #include <stdio.h>
  14 #include "../ssl_local.h"
  15 #include "statem_local.h"
  16 #include "internal/cryptlib.h"
  17 #include "internal/evp.h"
  18 #include <openssl/buffer.h>
  19 #include <openssl/objects.h>
  20 #include <openssl/evp.h>
  21 #include <openssl/x509.h>
  22 #include <openssl/trace.h>
  23
  24 DEFINE_STACK_OF(X509)
  25 DEFINE_STACK_OF(X509_NAME)
  26 DEFINE_STACK_OF_CONST(SSL_CIPHER)
  27
  28 /*
  29  * Map error codes to TLS/SSL alart types.
  30  */
  31 typedef struct x509err2alert_st {
  32     int x509err;
  33     int alert;
  34 } X509ERR2ALERT;
  35
  36 /* Fixed value used in the ServerHello random field to identify an HRR */
  37 const unsigned char hrrrandom[] = {
  38     0xcf, 0x21, 0xad, 0x74, 0xe5, 0x9a, 0x61, 0x11, 0xbe, 0x1d, 0x8c, 0x02,
  39     0x1e, 0x65, 0xb8, 0x91, 0xc2, 0xa2, 0x11, 0x16, 0x7a, 0xbb, 0x8c, 0x5e,
  40     0x07, 0x9e, 0x09, 0xe2, 0xc8, 0xa8, 0x33, 0x9c
  41 };
  42
  43 /*
  44  * send s->init_buf in records of type 'type' (SSL3_RT_HANDSHAKE or
  45  * SSL3_RT_CHANGE_CIPHER_SPEC)
  46  */
  47 int ssl3_do_write(SSL *s, int type)
  48 {
  49     int ret;
  50     size_t written = 0;
  51
  52     ret = ssl3_write_bytes(s, type, &s->init_buf->data[s->init_off],
  53                            s->init_num, &written);
  54     if (ret < 0)
  55         return -1;
  56     if (type == SSL3_RT_HANDSHAKE)
  57         /*
  58          * should not be done for 'Hello Request's, but in that case we'll
  59          * ignore the result anyway
  60          * TLS1.3 KeyUpdate and NewSessionTicket do not need to be added
  61          */
  62         if (!SSL_IS_TLS13(s) || (s->statem.hand_state != TLS_ST_SW_SESSION_TICKET
  63                                  && s->statem.hand_state != TLS_ST_CW_KEY_UPDATE
  64                                  && s->statem.hand_state != TLS_ST_SW_KEY_UPDATE))
  65             if (!ssl3_finish_mac(s,
  66                                  (unsigned char *)&s->init_buf->data[s->init_off],
  67                                  written))
  68                 return -1;
  69     if (written == s->init_num) {
  70         if (s->msg_callback)
  71             s->msg_callback(1, s->version, type, s->init_buf->data,
  72                             (size_t)(s->init_off + s->init_num), s,
  73                             s->msg_callback_arg);
  74         return 1;
  75     }
  76     s->init_off += written;
  77     s->init_num -= written;
  78     return 0;
  79 }
  80
  81 int tls_close_construct_packet(SSL *s, WPACKET *pkt, int htype)
  82 {
  83     size_t msglen;
  84
  85     if ((htype != SSL3_MT_CHANGE_CIPHER_SPEC && !WPACKET_close(pkt))
  86             || !WPACKET_get_length(pkt, &msglen)
  87             || msglen > INT_MAX)
  88         return 0;
  89     s->init_num = (int)msglen;
  90     s->init_off = 0;
  91
  92     return 1;
  93 }
  94
  95 int tls_setup_handshake(SSL *s)
  96 {
  97     if (!ssl3_init_finished_mac(s)) {
  98         /* SSLfatal() already called */
  99         return 0;
 100     }
 101
 102     /* Reset any extension flags */
 103     memset(s->ext.extflags, 0, sizeof(s->ext.extflags));
 104
 105     if (s->server) {
 106         STACK_OF(SSL_CIPHER) *ciphers = SSL_get_ciphers(s);
 107         int i, ver_min, ver_max, ok = 0;
 108
 109         /*
 110          * Sanity check that the maximum version we accept has ciphers
 111          * enabled. For clients we do this check during construction of the
 112          * ClientHello.
 113          */
 114         if (ssl_get_min_max_version(s, &ver_min, &ver_max, NULL) != 0) {
 115             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_SETUP_HANDSHAKE,
 116                      ERR_R_INTERNAL_ERROR);
 117             return 0;
 118         }
 119         for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
 120             const SSL_CIPHER *c = sk_SSL_CIPHER_value(ciphers, i);
 121
 122             if (SSL_IS_DTLS(s)) {
 123                 if (DTLS_VERSION_GE(ver_max, c->min_dtls) &&
 124                         DTLS_VERSION_LE(ver_max, c->max_dtls))
 125                     ok = 1;
 126             } else if (ver_max >= c->min_tls && ver_max <= c->max_tls) {
 127                 ok = 1;
 128             }
 129             if (ok)
 130                 break;
 131         }
 132         if (!ok) {
 133             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_F_TLS_SETUP_HANDSHAKE,
 134                      SSL_R_NO_CIPHERS_AVAILABLE);
 135             ERR_add_error_data(1, "No ciphers enabled for max supported "
 136                                   "SSL/TLS version");
 137             return 0;
 138         }
 139         if (SSL_IS_FIRST_HANDSHAKE(s)) {
 140             /* N.B. s->session_ctx == s->ctx here */
 141             tsan_counter(&s->session_ctx->stats.sess_accept);
 142         } else {
 143             /* N.B. s->ctx may not equal s->session_ctx */
 144             tsan_counter(&s->ctx->stats.sess_accept_renegotiate);
 145
 146             s->s3.tmp.cert_request = 0;
 147         }
 148     } else {
 149         if (SSL_IS_FIRST_HANDSHAKE(s))
 150             tsan_counter(&s->session_ctx->stats.sess_connect);
 151         else
 152             tsan_counter(&s->session_ctx->stats.sess_connect_renegotiate);
 153
 154         /* mark client_random uninitialized */
 155         memset(s->s3.client_random, 0, sizeof(s->s3.client_random));
 156         s->hit = 0;
 157
 158         s->s3.tmp.cert_req = 0;
 159
 160         if (SSL_IS_DTLS(s))
 161             s->statem.use_timer = 1;
 162     }
 163
 164     return 1;
 165 }
 166
 167 /*
 168  * Size of the to-be-signed TLS13 data, without the hash size itself:
 169  * 64 bytes of value 32, 33 context bytes, 1 byte separator
 170  */
 171 #define TLS13_TBS_START_SIZE            64
 172 #define TLS13_TBS_PREAMBLE_SIZE         (TLS13_TBS_START_SIZE + 33 + 1)
 173
 174 static int get_cert_verify_tbs_data(SSL *s, unsigned char *tls13tbs,
 175                                     void **hdata, size_t *hdatalen)
 176 {
 177 #ifdef CHARSET_EBCDIC
 178     static const char servercontext[] = { 0x54, 0x4c, 0x53, 0x20, 0x31, 0x2e,
 179      0x33, 0x2c, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x43, 0x65,
 180      0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72,
 181      0x69, 0x66, 0x79, 0x00 };
 182     static const char clientcontext[] = { 0x54, 0x4c, 0x53, 0x20, 0x31, 0x2e,
 183      0x33, 0x2c, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x43, 0x65,
 184      0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72,
 185      0x69, 0x66, 0x79, 0x00 };
 186 #else
 187     static const char servercontext[] = "TLS 1.3, server CertificateVerify";
 188     static const char clientcontext[] = "TLS 1.3, client CertificateVerify";
 189 #endif
 190     if (SSL_IS_TLS13(s)) {
 191         size_t hashlen;
 192
 193         /* Set the first 64 bytes of to-be-signed data to octet 32 */
 194         memset(tls13tbs, 32, TLS13_TBS_START_SIZE);
 195         /* This copies the 33 bytes of context plus the 0 separator byte */
 196         if (s->statem.hand_state == TLS_ST_CR_CERT_VRFY
 197                  || s->statem.hand_state == TLS_ST_SW_CERT_VRFY)
 198             strcpy((char *)tls13tbs + TLS13_TBS_START_SIZE, servercontext);
 199         else
 200             strcpy((char *)tls13tbs + TLS13_TBS_START_SIZE, clientcontext);
 201
 202         /*
 203          * If we're currently reading then we need to use the saved handshake
 204          * hash value. We can't use the current handshake hash state because
 205          * that includes the CertVerify itself.
 206          */
 207         if (s->statem.hand_state == TLS_ST_CR_CERT_VRFY
 208                 || s->statem.hand_state == TLS_ST_SR_CERT_VRFY) {
 209             memcpy(tls13tbs + TLS13_TBS_PREAMBLE_SIZE, s->cert_verify_hash,
 210                    s->cert_verify_hash_len);
 211             hashlen = s->cert_verify_hash_len;
 212         } else if (!ssl_handshake_hash(s, tls13tbs + TLS13_TBS_PREAMBLE_SIZE,
 213                                        EVP_MAX_MD_SIZE, &hashlen)) {
 214             /* SSLfatal() already called */
 215             return 0;
 216         }
 217
 218         *hdata = tls13tbs;
 219         *hdatalen = TLS13_TBS_PREAMBLE_SIZE + hashlen;
 220     } else {
 221         size_t retlen;
 222         long retlen_l;
 223
 224         retlen = retlen_l = BIO_get_mem_data(s->s3.handshake_buffer, hdata);
 225         if (retlen_l <= 0) {
 226             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_GET_CERT_VERIFY_TBS_DATA,
 227                      ERR_R_INTERNAL_ERROR);
 228             return 0;
 229         }
 230         *hdatalen = retlen;
 231     }
 232
 233     return 1;
 234 }
 235
 236 int tls_construct_cert_verify(SSL *s, WPACKET *pkt)
 237 {
 238     EVP_PKEY *pkey = NULL;
 239     const EVP_MD *md = NULL;
 240     EVP_MD_CTX *mctx = NULL;
 241     EVP_PKEY_CTX *pctx = NULL;
 242     size_t hdatalen = 0, siglen = 0;
 243     void *hdata;
 244     unsigned char *sig = NULL;
 245     unsigned char tls13tbs[TLS13_TBS_PREAMBLE_SIZE + EVP_MAX_MD_SIZE];
 246     const SIGALG_LOOKUP *lu = s->s3.tmp.sigalg;
 247
 248     if (lu == NULL || s->s3.tmp.cert == NULL) {
 249         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CERT_VERIFY,
 250                  ERR_R_INTERNAL_ERROR);
 251         goto err;
 252     }
 253     pkey = s->s3.tmp.cert->privatekey;
 254
 255     if (pkey == NULL || !tls1_lookup_md(s->ctx, lu, &md)) {
 256         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CERT_VERIFY,
 257                  ERR_R_INTERNAL_ERROR);
 258         goto err;
 259     }
 260
 261     mctx = EVP_MD_CTX_new();
 262     if (mctx == NULL) {
 263         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CERT_VERIFY,
 264                  ERR_R_MALLOC_FAILURE);
 265         goto err;
 266     }
 267
 268     /* Get the data to be signed */
 269     if (!get_cert_verify_tbs_data(s, tls13tbs, &hdata, &hdatalen)) {
 270         /* SSLfatal() already called */
 271         goto err;
 272     }
 273
 274     if (SSL_USE_SIGALGS(s) && !WPACKET_put_bytes_u16(pkt, lu->sigalg)) {
 275         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CERT_VERIFY,
 276                  ERR_R_INTERNAL_ERROR);
 277         goto err;
 278     }
 279
 280     if (EVP_DigestSignInit_ex(mctx, &pctx,
 281                               md == NULL ? NULL : EVP_MD_name(md),
 282                               s->ctx->propq, pkey, s->ctx->libctx) <= 0) {
 283         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CERT_VERIFY,
 284                  ERR_R_EVP_LIB);
 285         goto err;
 286     }
 287
 288     if (lu->sig == EVP_PKEY_RSA_PSS) {
 289         if (EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) <= 0
 290             || EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx,
 291                                                 RSA_PSS_SALTLEN_DIGEST) <= 0) {
 292             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CERT_VERIFY,
 293                      ERR_R_EVP_LIB);
 294             goto err;
 295         }
 296     }
 297     if (s->version == SSL3_VERSION) {
 298         /*
 299          * Here we use EVP_DigestSignUpdate followed by EVP_DigestSignFinal
 300          * in order to add the EVP_CTRL_SSL3_MASTER_SECRET call between them.
 301          */
 302         if (EVP_DigestSignUpdate(mctx, hdata, hdatalen) <= 0
 303             /*
 304              * TODO(3.0) Replace this when EVP_MD_CTX_ctrl() is deprecated
 305              * with a call to ssl3_digest_master_key_set_params()
 306              */
 307             || EVP_MD_CTX_ctrl(mctx, EVP_CTRL_SSL3_MASTER_SECRET,
 308                                (int)s->session->master_key_length,
 309                                s->session->master_key) <= 0
 310             || EVP_DigestSignFinal(mctx, NULL, &siglen) <= 0) {
 311
 312             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CERT_VERIFY,
 313                      ERR_R_EVP_LIB);
 314             goto err;
 315         }
 316         sig = OPENSSL_malloc(siglen);
 317         if (sig == NULL
 318                 || EVP_DigestSignFinal(mctx, sig, &siglen) <= 0) {
 319             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CERT_VERIFY,
 320                      ERR_R_EVP_LIB);
 321             goto err;
 322         }
 323     } else {
 324         /*
 325          * Here we *must* use EVP_DigestSign() because Ed25519/Ed448 does not
 326          * support streaming via EVP_DigestSignUpdate/EVP_DigestSignFinal
 327          */
 328         if (EVP_DigestSign(mctx, NULL, &siglen, hdata, hdatalen) <= 0) {
 329             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CERT_VERIFY,
 330                      ERR_R_EVP_LIB);
 331             goto err;
 332         }
 333         sig = OPENSSL_malloc(siglen);
 334         if (sig == NULL
 335                 || EVP_DigestSign(mctx, sig, &siglen, hdata, hdatalen) <= 0) {
 336             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CERT_VERIFY,
 337                      ERR_R_EVP_LIB);
 338             goto err;
 339         }
 340     }
 341
 342 #ifndef OPENSSL_NO_GOST
 343     {
 344         int pktype = lu->sig;
 345
 346         if (pktype == NID_id_GostR3410_2001
 347             || pktype == NID_id_GostR3410_2012_256
 348             || pktype == NID_id_GostR3410_2012_512)
 349             BUF_reverse(sig, NULL, siglen);
 350     }
 351 #endif
 352
 353     if (!WPACKET_sub_memcpy_u16(pkt, sig, siglen)) {
 354         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CERT_VERIFY,
 355                  ERR_R_INTERNAL_ERROR);
 356         goto err;
 357     }
 358
 359     /* Digest cached records and discard handshake buffer */
 360     if (!ssl3_digest_cached_records(s, 0)) {
 361         /* SSLfatal() already called */
 362         goto err;
 363     }
 364
 365     OPENSSL_free(sig);
 366     EVP_MD_CTX_free(mctx);
 367     return 1;
 368  err:
 369     OPENSSL_free(sig);
 370     EVP_MD_CTX_free(mctx);
 371     return 0;
 372 }
 373
 374 MSG_PROCESS_RETURN tls_process_cert_verify(SSL *s, PACKET *pkt)
 375 {
 376     EVP_PKEY *pkey = NULL;
 377     const unsigned char *data;
 378 #ifndef OPENSSL_NO_GOST
 379     unsigned char *gost_data = NULL;
 380 #endif
 381     MSG_PROCESS_RETURN ret = MSG_PROCESS_ERROR;
 382     int j;
 383     unsigned int len;
 384     X509 *peer;
 385     const EVP_MD *md = NULL;
 386     size_t hdatalen = 0;
 387     void *hdata;
 388     unsigned char tls13tbs[TLS13_TBS_PREAMBLE_SIZE + EVP_MAX_MD_SIZE];
 389     EVP_MD_CTX *mctx = EVP_MD_CTX_new();
 390     EVP_PKEY_CTX *pctx = NULL;
 391
 392     if (mctx == NULL) {
 393         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CERT_VERIFY,
 394                  ERR_R_MALLOC_FAILURE);
 395         goto err;
 396     }
 397
 398     peer = s->session->peer;
 399     pkey = X509_get0_pubkey(peer);
 400     if (pkey == NULL) {
 401         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CERT_VERIFY,
 402                  ERR_R_INTERNAL_ERROR);
 403         goto err;
 404     }
 405
 406     if (ssl_cert_lookup_by_pkey(pkey, NULL) == NULL) {
 407         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_PROCESS_CERT_VERIFY,
 408                  SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE);
 409         goto err;
 410     }
 411
 412     if (SSL_USE_SIGALGS(s)) {
 413         unsigned int sigalg;
 414
 415         if (!PACKET_get_net_2(pkt, &sigalg)) {
 416             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CERT_VERIFY,
 417                      SSL_R_BAD_PACKET);
 418             goto err;
 419         }
 420         if (tls12_check_peer_sigalg(s, sigalg, pkey) <= 0) {
 421             /* SSLfatal() already called */
 422             goto err;
 423         }
 424     } else if (!tls1_set_peer_legacy_sigalg(s, pkey)) {
 425             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CERT_VERIFY,
 426                      ERR_R_INTERNAL_ERROR);
 427             goto err;
 428     }
 429
 430     if (!tls1_lookup_md(s->ctx, s->s3.tmp.peer_sigalg, &md)) {
 431         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CERT_VERIFY,
 432                  ERR_R_INTERNAL_ERROR);
 433         goto err;
 434     }
 435
 436     if (SSL_USE_SIGALGS(s))
 437         OSSL_TRACE1(TLS, "USING TLSv1.2 HASH %s\n",
 438                     md == NULL ? "n/a" : EVP_MD_name(md));
 439
 440     /* Check for broken implementations of GOST ciphersuites */
 441     /*
 442      * If key is GOST and len is exactly 64 or 128, it is signature without
 443      * length field (CryptoPro implementations at least till TLS 1.2)
 444      */
 445 #ifndef OPENSSL_NO_GOST
 446     if (!SSL_USE_SIGALGS(s)
 447         && ((PACKET_remaining(pkt) == 64
 448              && (EVP_PKEY_id(pkey) == NID_id_GostR3410_2001
 449                  || EVP_PKEY_id(pkey) == NID_id_GostR3410_2012_256))
 450             || (PACKET_remaining(pkt) == 128
 451                 && EVP_PKEY_id(pkey) == NID_id_GostR3410_2012_512))) {
 452         len = PACKET_remaining(pkt);
 453     } else
 454 #endif
 455     if (!PACKET_get_net_2(pkt, &len)) {
 456         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CERT_VERIFY,
 457                  SSL_R_LENGTH_MISMATCH);
 458         goto err;
 459     }
 460
 461     if (!PACKET_get_bytes(pkt, &data, len)) {
 462         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CERT_VERIFY,
 463                  SSL_R_LENGTH_MISMATCH);
 464         goto err;
 465     }
 466
 467     if (!get_cert_verify_tbs_data(s, tls13tbs, &hdata, &hdatalen)) {
 468         /* SSLfatal() already called */
 469         goto err;
 470     }
 471
 472     OSSL_TRACE1(TLS, "Using client verify alg %s\n",
 473                 md == NULL ? "n/a" : EVP_MD_name(md));
 474
 475     if (EVP_DigestVerifyInit_ex(mctx, &pctx,
 476                                 md == NULL ? NULL : EVP_MD_name(md),
 477                                 s->ctx->propq, pkey, s->ctx->libctx) <= 0) {
 478         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CERT_VERIFY,
 479                  ERR_R_EVP_LIB);
 480         goto err;
 481     }
 482 #ifndef OPENSSL_NO_GOST
 483     {
 484         int pktype = EVP_PKEY_id(pkey);
 485         if (pktype == NID_id_GostR3410_2001
 486             || pktype == NID_id_GostR3410_2012_256
 487             || pktype == NID_id_GostR3410_2012_512) {
 488             if ((gost_data = OPENSSL_malloc(len)) == NULL) {
 489                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
 490                          SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_MALLOC_FAILURE);
 491                 goto err;
 492             }
 493             BUF_reverse(gost_data, data, len);
 494             data = gost_data;
 495         }
 496     }
 497 #endif
 498
 499     if (SSL_USE_PSS(s)) {
 500         if (EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) <= 0
 501             || EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx,
 502                                                 RSA_PSS_SALTLEN_DIGEST) <= 0) {
 503             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CERT_VERIFY,
 504                      ERR_R_EVP_LIB);
 505             goto err;
 506         }
 507     }
 508     if (s->version == SSL3_VERSION) {
 509         /*
 510          * TODO(3.0) Replace this when EVP_MD_CTX_ctrl() is deprecated
 511          * with a call to ssl3_digest_master_key_set_params()
 512          */
 513         if (EVP_DigestVerifyUpdate(mctx, hdata, hdatalen) <= 0
 514                 || EVP_MD_CTX_ctrl(mctx, EVP_CTRL_SSL3_MASTER_SECRET,
 515                                    (int)s->session->master_key_length,
 516                                     s->session->master_key) <= 0) {
 517             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CERT_VERIFY,
 518                      ERR_R_EVP_LIB);
 519             goto err;
 520         }
 521         if (EVP_DigestVerifyFinal(mctx, data, len) <= 0) {
 522             SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_F_TLS_PROCESS_CERT_VERIFY,
 523                      SSL_R_BAD_SIGNATURE);
 524             goto err;
 525         }
 526     } else {
 527         j = EVP_DigestVerify(mctx, data, len, hdata, hdatalen);
 528         if (j <= 0) {
 529             SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_F_TLS_PROCESS_CERT_VERIFY,
 530                      SSL_R_BAD_SIGNATURE);
 531             goto err;
 532         }
 533     }
 534
 535     /*
 536      * In TLSv1.3 on the client side we make sure we prepare the client
 537      * certificate after the CertVerify instead of when we get the
 538      * CertificateRequest. This is because in TLSv1.3 the CertificateRequest
 539      * comes *before* the Certificate message. In TLSv1.2 it comes after. We
 540      * want to make sure that SSL_get1_peer_certificate() will return the actual
 541      * server certificate from the client_cert_cb callback.
 542      */
 543     if (!s->server && SSL_IS_TLS13(s) && s->s3.tmp.cert_req == 1)
 544         ret = MSG_PROCESS_CONTINUE_PROCESSING;
 545     else
 546         ret = MSG_PROCESS_CONTINUE_READING;
 547  err:
 548     BIO_free(s->s3.handshake_buffer);
 549     s->s3.handshake_buffer = NULL;
 550     EVP_MD_CTX_free(mctx);
 551 #ifndef OPENSSL_NO_GOST
 552     OPENSSL_free(gost_data);
 553 #endif
 554     return ret;
 555 }
 556
 557 int tls_construct_finished(SSL *s, WPACKET *pkt)
 558 {
 559     size_t finish_md_len;
 560     const char *sender;
 561     size_t slen;
 562
 563     /* This is a real handshake so make sure we clean it up at the end */
 564     if (!s->server && s->post_handshake_auth != SSL_PHA_REQUESTED)
 565         s->statem.cleanuphand = 1;
 566
 567     /*
 568      * We only change the keys if we didn't already do this when we sent the
 569      * client certificate
 570      */
 571     if (SSL_IS_TLS13(s)
 572             && !s->server
 573             && s->s3.tmp.cert_req == 0
 574             && (!s->method->ssl3_enc->change_cipher_state(s,
 575                     SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_WRITE))) {;
 576         /* SSLfatal() already called */
 577         return 0;
 578     }
 579
 580     if (s->server) {
 581         sender = s->method->ssl3_enc->server_finished_label;
 582         slen = s->method->ssl3_enc->server_finished_label_len;
 583     } else {
 584         sender = s->method->ssl3_enc->client_finished_label;
 585         slen = s->method->ssl3_enc->client_finished_label_len;
 586     }
 587
 588     finish_md_len = s->method->ssl3_enc->final_finish_mac(s,
 589                                                           sender, slen,
 590                                                           s->s3.tmp.finish_md);
 591     if (finish_md_len == 0) {
 592         /* SSLfatal() already called */
 593         return 0;
 594     }
 595
 596     s->s3.tmp.finish_md_len = finish_md_len;
 597
 598     if (!WPACKET_memcpy(pkt, s->s3.tmp.finish_md, finish_md_len)) {
 599         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_FINISHED,
 600                  ERR_R_INTERNAL_ERROR);
 601         return 0;
 602     }
 603
 604     /*
 605      * Log the master secret, if logging is enabled. We don't log it for
 606      * TLSv1.3: there's a different key schedule for that.
 607      */
 608     if (!SSL_IS_TLS13(s) && !ssl_log_secret(s, MASTER_SECRET_LABEL,
 609                                             s->session->master_key,
 610                                             s->session->master_key_length)) {
 611         /* SSLfatal() already called */
 612         return 0;
 613     }
 614
 615     /*
 616      * Copy the finished so we can use it for renegotiation checks
 617      */
 618     if (!ossl_assert(finish_md_len <= EVP_MAX_MD_SIZE)) {
 619         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_FINISHED,
 620                  ERR_R_INTERNAL_ERROR);
 621         return 0;
 622     }
 623     if (!s->server) {
 624         memcpy(s->s3.previous_client_finished, s->s3.tmp.finish_md,
 625                finish_md_len);
 626         s->s3.previous_client_finished_len = finish_md_len;
 627     } else {
 628         memcpy(s->s3.previous_server_finished, s->s3.tmp.finish_md,
 629                finish_md_len);
 630         s->s3.previous_server_finished_len = finish_md_len;
 631     }
 632
 633     return 1;
 634 }
 635
 636 int tls_construct_key_update(SSL *s, WPACKET *pkt)
 637 {
 638     if (!WPACKET_put_bytes_u8(pkt, s->key_update)) {
 639         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_KEY_UPDATE,
 640                  ERR_R_INTERNAL_ERROR);
 641         return 0;
 642     }
 643
 644     s->key_update = SSL_KEY_UPDATE_NONE;
 645     return 1;
 646 }
 647
 648 MSG_PROCESS_RETURN tls_process_key_update(SSL *s, PACKET *pkt)
 649 {
 650     unsigned int updatetype;
 651
 652     /*
 653      * A KeyUpdate message signals a key change so the end of the message must
 654      * be on a record boundary.
 655      */
 656     if (RECORD_LAYER_processed_read_pending(&s->rlayer)) {
 657         SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_F_TLS_PROCESS_KEY_UPDATE,
 658                  SSL_R_NOT_ON_RECORD_BOUNDARY);
 659         return MSG_PROCESS_ERROR;
 660     }
 661
 662     if (!PACKET_get_1(pkt, &updatetype)
 663             || PACKET_remaining(pkt) != 0) {
 664         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_KEY_UPDATE,
 665                  SSL_R_BAD_KEY_UPDATE);
 666         return MSG_PROCESS_ERROR;
 667     }
 668
 669     /*
 670      * There are only two defined key update types. Fail if we get a value we
 671      * didn't recognise.
 672      */
 673     if (updatetype != SSL_KEY_UPDATE_NOT_REQUESTED
 674             && updatetype != SSL_KEY_UPDATE_REQUESTED) {
 675         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_PROCESS_KEY_UPDATE,
 676                  SSL_R_BAD_KEY_UPDATE);
 677         return MSG_PROCESS_ERROR;
 678     }
 679
 680     /*
 681      * If we get a request for us to update our sending keys too then, we need
 682      * to additionally send a KeyUpdate message. However that message should
 683      * not also request an update (otherwise we get into an infinite loop).
 684      */
 685     if (updatetype == SSL_KEY_UPDATE_REQUESTED)
 686         s->key_update = SSL_KEY_UPDATE_NOT_REQUESTED;
 687
 688     if (!tls13_update_key(s, 0)) {
 689         /* SSLfatal() already called */
 690         return MSG_PROCESS_ERROR;
 691     }
 692
 693     return MSG_PROCESS_FINISHED_READING;
 694 }
 695
 696 /*
 697  * ssl3_take_mac calculates the Finished MAC for the handshakes messages seen
 698  * to far.
 699  */
 700 int ssl3_take_mac(SSL *s)
 701 {
 702     const char *sender;
 703     size_t slen;
 704
 705     if (!s->server) {
 706         sender = s->method->ssl3_enc->server_finished_label;
 707         slen = s->method->ssl3_enc->server_finished_label_len;
 708     } else {
 709         sender = s->method->ssl3_enc->client_finished_label;
 710         slen = s->method->ssl3_enc->client_finished_label_len;
 711     }
 712
 713     s->s3.tmp.peer_finish_md_len =
 714         s->method->ssl3_enc->final_finish_mac(s, sender, slen,
 715                                               s->s3.tmp.peer_finish_md);
 716
 717     if (s->s3.tmp.peer_finish_md_len == 0) {
 718         /* SSLfatal() already called */
 719         return 0;
 720     }
 721
 722     return 1;
 723 }
 724
 725 MSG_PROCESS_RETURN tls_process_change_cipher_spec(SSL *s, PACKET *pkt)
 726 {
 727     size_t remain;
 728
 729     remain = PACKET_remaining(pkt);
 730     /*
 731      * 'Change Cipher Spec' is just a single byte, which should already have
 732      * been consumed by ssl_get_message() so there should be no bytes left,
 733      * unless we're using DTLS1_BAD_VER, which has an extra 2 bytes
 734      */
 735     if (SSL_IS_DTLS(s)) {
 736         if ((s->version == DTLS1_BAD_VER
 737              && remain != DTLS1_CCS_HEADER_LENGTH + 1)
 738             || (s->version != DTLS1_BAD_VER
 739                 && remain != DTLS1_CCS_HEADER_LENGTH - 1)) {
 740             SSLfatal(s, SSL_AD_DECODE_ERROR,
 741                      SSL_F_TLS_PROCESS_CHANGE_CIPHER_SPEC,
 742                     SSL_R_BAD_CHANGE_CIPHER_SPEC);
 743             return MSG_PROCESS_ERROR;
 744         }
 745     } else {
 746         if (remain != 0) {
 747             SSLfatal(s, SSL_AD_DECODE_ERROR,
 748                      SSL_F_TLS_PROCESS_CHANGE_CIPHER_SPEC,
 749                      SSL_R_BAD_CHANGE_CIPHER_SPEC);
 750             return MSG_PROCESS_ERROR;
 751         }
 752     }
 753
 754     /* Check we have a cipher to change to */
 755     if (s->s3.tmp.new_cipher == NULL) {
 756         SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE,
 757                  SSL_F_TLS_PROCESS_CHANGE_CIPHER_SPEC, SSL_R_CCS_RECEIVED_EARLY);
 758         return MSG_PROCESS_ERROR;
 759     }
 760
 761     s->s3.change_cipher_spec = 1;
 762     if (!ssl3_do_change_cipher_spec(s)) {
 763         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CHANGE_CIPHER_SPEC,
 764                  ERR_R_INTERNAL_ERROR);
 765         return MSG_PROCESS_ERROR;
 766     }
 767
 768     if (SSL_IS_DTLS(s)) {
 769         dtls1_reset_seq_numbers(s, SSL3_CC_READ);
 770
 771         if (s->version == DTLS1_BAD_VER)
 772             s->d1->handshake_read_seq++;
 773
 774 #ifndef OPENSSL_NO_SCTP
 775         /*
 776          * Remember that a CCS has been received, so that an old key of
 777          * SCTP-Auth can be deleted when a CCS is sent. Will be ignored if no
 778          * SCTP is used
 779          */
 780         BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD, 1, NULL);
 781 #endif
 782     }
 783
 784     return MSG_PROCESS_CONTINUE_READING;
 785 }
 786
 787 MSG_PROCESS_RETURN tls_process_finished(SSL *s, PACKET *pkt)
 788 {
 789     size_t md_len;
 790
 791
 792     /* This is a real handshake so make sure we clean it up at the end */
 793     if (s->server) {
 794         /*
 795         * To get this far we must have read encrypted data from the client. We
 796         * no longer tolerate unencrypted alerts. This value is ignored if less
 797         * than TLSv1.3
 798         */
 799         s->statem.enc_read_state = ENC_READ_STATE_VALID;
 800         if (s->post_handshake_auth != SSL_PHA_REQUESTED)
 801             s->statem.cleanuphand = 1;
 802         if (SSL_IS_TLS13(s) && !tls13_save_handshake_digest_for_pha(s)) {
 803                 /* SSLfatal() already called */
 804                 return MSG_PROCESS_ERROR;
 805         }
 806     }
 807
 808     /*
 809      * In TLSv1.3 a Finished message signals a key change so the end of the
 810      * message must be on a record boundary.
 811      */
 812     if (SSL_IS_TLS13(s) && RECORD_LAYER_processed_read_pending(&s->rlayer)) {
 813         SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_F_TLS_PROCESS_FINISHED,
 814                  SSL_R_NOT_ON_RECORD_BOUNDARY);
 815         return MSG_PROCESS_ERROR;
 816     }
 817
 818     /* If this occurs, we have missed a message */
 819     if (!SSL_IS_TLS13(s) && !s->s3.change_cipher_spec) {
 820         SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_F_TLS_PROCESS_FINISHED,
 821                  SSL_R_GOT_A_FIN_BEFORE_A_CCS);
 822         return MSG_PROCESS_ERROR;
 823     }
 824     s->s3.change_cipher_spec = 0;
 825
 826     md_len = s->s3.tmp.peer_finish_md_len;
 827
 828     if (md_len != PACKET_remaining(pkt)) {
 829         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_FINISHED,
 830                  SSL_R_BAD_DIGEST_LENGTH);
 831         return MSG_PROCESS_ERROR;
 832     }
 833
 834     if (CRYPTO_memcmp(PACKET_data(pkt), s->s3.tmp.peer_finish_md,
 835                       md_len) != 0) {
 836         SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_F_TLS_PROCESS_FINISHED,
 837                  SSL_R_DIGEST_CHECK_FAILED);
 838         return MSG_PROCESS_ERROR;
 839     }
 840
 841     /*
 842      * Copy the finished so we can use it for renegotiation checks
 843      */
 844     if (!ossl_assert(md_len <= EVP_MAX_MD_SIZE)) {
 845         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_FINISHED,
 846                  ERR_R_INTERNAL_ERROR);
 847         return MSG_PROCESS_ERROR;
 848     }
 849     if (s->server) {
 850         memcpy(s->s3.previous_client_finished, s->s3.tmp.peer_finish_md,
 851                md_len);
 852         s->s3.previous_client_finished_len = md_len;
 853     } else {
 854         memcpy(s->s3.previous_server_finished, s->s3.tmp.peer_finish_md,
 855                md_len);
 856         s->s3.previous_server_finished_len = md_len;
 857     }
 858
 859     /*
 860      * In TLS1.3 we also have to change cipher state and do any final processing
 861      * of the initial server flight (if we are a client)
 862      */
 863     if (SSL_IS_TLS13(s)) {
 864         if (s->server) {
 865             if (s->post_handshake_auth != SSL_PHA_REQUESTED &&
 866                     !s->method->ssl3_enc->change_cipher_state(s,
 867                     SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_SERVER_READ)) {
 868                 /* SSLfatal() already called */
 869                 return MSG_PROCESS_ERROR;
 870             }
 871         } else {
 872             /* TLS 1.3 gets the secret size from the handshake md */
 873             size_t dummy;
 874             if (!s->method->ssl3_enc->generate_master_secret(s,
 875                     s->master_secret, s->handshake_secret, 0,
 876                     &dummy)) {
 877                 /* SSLfatal() already called */
 878                 return MSG_PROCESS_ERROR;
 879             }
 880             if (!s->method->ssl3_enc->change_cipher_state(s,
 881                     SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_CLIENT_READ)) {
 882                 /* SSLfatal() already called */
 883                 return MSG_PROCESS_ERROR;
 884             }
 885             if (!tls_process_initial_server_flight(s)) {
 886                 /* SSLfatal() already called */
 887                 return MSG_PROCESS_ERROR;
 888             }
 889         }
 890     }
 891
 892     return MSG_PROCESS_FINISHED_READING;
 893 }
 894
 895 int tls_construct_change_cipher_spec(SSL *s, WPACKET *pkt)
 896 {
 897     if (!WPACKET_put_bytes_u8(pkt, SSL3_MT_CCS)) {
 898         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
 899                  SSL_F_TLS_CONSTRUCT_CHANGE_CIPHER_SPEC, ERR_R_INTERNAL_ERROR);
 900         return 0;
 901     }
 902
 903     return 1;
 904 }
 905
 906 /* Add a certificate to the WPACKET */
 907 static int ssl_add_cert_to_wpacket(SSL *s, WPACKET *pkt, X509 *x, int chain)
 908 {
 909     int len;
 910     unsigned char *outbytes;
 911
 912     len = i2d_X509(x, NULL);
 913     if (len < 0) {
 914         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL_ADD_CERT_TO_WPACKET,
 915                  ERR_R_BUF_LIB);
 916         return 0;
 917     }
 918     if (!WPACKET_sub_allocate_bytes_u24(pkt, len, &outbytes)
 919             || i2d_X509(x, &outbytes) != len) {
 920         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL_ADD_CERT_TO_WPACKET,
 921                  ERR_R_INTERNAL_ERROR);
 922         return 0;
 923     }
 924
 925     if (SSL_IS_TLS13(s)
 926             && !tls_construct_extensions(s, pkt, SSL_EXT_TLS1_3_CERTIFICATE, x,
 927                                          chain)) {
 928         /* SSLfatal() already called */
 929         return 0;
 930     }
 931
 932     return 1;
 933 }
 934
 935 /* Add certificate chain to provided WPACKET */
 936 static int ssl_add_cert_chain(SSL *s, WPACKET *pkt, CERT_PKEY *cpk)
 937 {
 938     int i, chain_count;
 939     X509 *x;
 940     STACK_OF(X509) *extra_certs;
 941     STACK_OF(X509) *chain = NULL;
 942     X509_STORE *chain_store;
 943
 944     if (cpk == NULL || cpk->x509 == NULL)
 945         return 1;
 946
 947     x = cpk->x509;
 948
 949     /*
 950      * If we have a certificate specific chain use it, else use parent ctx.
 951      */
 952     if (cpk->chain != NULL)
 953         extra_certs = cpk->chain;
 954     else
 955         extra_certs = s->ctx->extra_certs;
 956
 957     if ((s->mode & SSL_MODE_NO_AUTO_CHAIN) || extra_certs)
 958         chain_store = NULL;
 959     else if (s->cert->chain_store)
 960         chain_store = s->cert->chain_store;
 961     else
 962         chain_store = s->ctx->cert_store;
 963
 964     if (chain_store != NULL) {
 965         X509_STORE_CTX *xs_ctx = X509_STORE_CTX_new_with_libctx(s->ctx->libctx,
 966                                                                 s->ctx->propq);
 967
 968         if (xs_ctx == NULL) {
 969             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL_ADD_CERT_CHAIN,
 970                      ERR_R_MALLOC_FAILURE);
 971             return 0;
 972         }
 973         if (!X509_STORE_CTX_init(xs_ctx, chain_store, x, NULL)) {
 974             X509_STORE_CTX_free(xs_ctx);
 975             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL_ADD_CERT_CHAIN,
 976                      ERR_R_X509_LIB);
 977             return 0;
 978         }
 979         /*
 980          * It is valid for the chain not to be complete (because normally we
 981          * don't include the root cert in the chain). Therefore we deliberately
 982          * ignore the error return from this call. We're not actually verifying
 983          * the cert - we're just building as much of the chain as we can
 984          */
 985         (void)X509_verify_cert(xs_ctx);
 986         /* Don't leave errors in the queue */
 987         ERR_clear_error();
 988         chain = X509_STORE_CTX_get0_chain(xs_ctx);
 989         i = ssl_security_cert_chain(s, chain, NULL, 0);
 990         if (i != 1) {
 991 #if 0
 992             /* Dummy error calls so mkerr generates them */
 993             SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, SSL_R_EE_KEY_TOO_SMALL);
 994             SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, SSL_R_CA_KEY_TOO_SMALL);
 995             SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, SSL_R_CA_MD_TOO_WEAK);
 996 #endif
 997             X509_STORE_CTX_free(xs_ctx);
 998             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL_ADD_CERT_CHAIN, i);
 999             return 0;
1000         }
1001         chain_count = sk_X509_num(chain);
1002         for (i = 0; i < chain_count; i++) {
1003             x = sk_X509_value(chain, i);
1004
1005             if (!ssl_add_cert_to_wpacket(s, pkt, x, i)) {
1006                 /* SSLfatal() already called */
1007                 X509_STORE_CTX_free(xs_ctx);
1008                 return 0;
1009             }
1010         }
1011         X509_STORE_CTX_free(xs_ctx);
1012     } else {
1013         i = ssl_security_cert_chain(s, extra_certs, x, 0);
1014         if (i != 1) {
1015             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL_ADD_CERT_CHAIN, i);
1016             return 0;
1017         }
1018         if (!ssl_add_cert_to_wpacket(s, pkt, x, 0)) {
1019             /* SSLfatal() already called */
1020             return 0;
1021         }
1022         for (i = 0; i < sk_X509_num(extra_certs); i++) {
1023             x = sk_X509_value(extra_certs, i);
1024             if (!ssl_add_cert_to_wpacket(s, pkt, x, i + 1)) {
1025                 /* SSLfatal() already called */
1026                 return 0;
1027             }
1028         }
1029     }
1030     return 1;
1031 }
1032
1033 unsigned long ssl3_output_cert_chain(SSL *s, WPACKET *pkt, CERT_PKEY *cpk)
1034 {
1035     if (!WPACKET_start_sub_packet_u24(pkt)) {
1036         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL3_OUTPUT_CERT_CHAIN,
1037                  ERR_R_INTERNAL_ERROR);
1038         return 0;
1039     }
1040
1041     if (!ssl_add_cert_chain(s, pkt, cpk))
1042         return 0;
1043
1044     if (!WPACKET_close(pkt)) {
1045         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL3_OUTPUT_CERT_CHAIN,
1046                  ERR_R_INTERNAL_ERROR);
1047         return 0;
1048     }
1049
1050     return 1;
1051 }
1052
1053 /*
1054  * Tidy up after the end of a handshake. In the case of SCTP this may result
1055  * in NBIO events. If |clearbufs| is set then init_buf and the wbio buffer is
1056  * freed up as well.
1057  */
1058 WORK_STATE tls_finish_handshake(SSL *s, WORK_STATE wst, int clearbufs, int stop)
1059 {
1060     void (*cb) (const SSL *ssl, int type, int val) = NULL;
1061     int cleanuphand = s->statem.cleanuphand;
1062
1063     if (clearbufs) {
1064         if (!SSL_IS_DTLS(s)
1065 #ifndef OPENSSL_NO_SCTP
1066             /*
1067              * RFC6083: SCTP provides a reliable and in-sequence transport service for DTLS
1068              * messages that require it. Therefore, DTLS procedures for retransmissions
1069              * MUST NOT be used.
1070              * Hence the init_buf can be cleared when DTLS over SCTP as transport is used.
1071              */
1072             || BIO_dgram_is_sctp(SSL_get_wbio(s))
1073 #endif
1074             ) {
1075             /*
1076              * We don't do this in DTLS over UDP because we may still need the init_buf
1077              * in case there are any unexpected retransmits
1078              */
1079             BUF_MEM_free(s->init_buf);
1080             s->init_buf = NULL;
1081         }
1082
1083         if (!ssl_free_wbio_buffer(s)) {
1084             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_FINISH_HANDSHAKE,
1085                      ERR_R_INTERNAL_ERROR);
1086             return WORK_ERROR;
1087         }
1088         s->init_num = 0;
1089     }
1090
1091     if (SSL_IS_TLS13(s) && !s->server
1092             && s->post_handshake_auth == SSL_PHA_REQUESTED)
1093         s->post_handshake_auth = SSL_PHA_EXT_SENT;
1094
1095     /*
1096      * Only set if there was a Finished message and this isn't after a TLSv1.3
1097      * post handshake exchange
1098      */
1099     if (cleanuphand) {
1100         /* skipped if we just sent a HelloRequest */
1101         s->renegotiate = 0;
1102         s->new_session = 0;
1103         s->statem.cleanuphand = 0;
1104         s->ext.ticket_expected = 0;
1105
1106         ssl3_cleanup_key_block(s);
1107
1108         if (s->server) {
1109             /*
1110              * In TLSv1.3 we update the cache as part of constructing the
1111              * NewSessionTicket
1112              */
1113             if (!SSL_IS_TLS13(s))
1114                 ssl_update_cache(s, SSL_SESS_CACHE_SERVER);
1115
1116             /* N.B. s->ctx may not equal s->session_ctx */
1117             tsan_counter(&s->ctx->stats.sess_accept_good);
1118             s->handshake_func = ossl_statem_accept;
1119         } else {
1120             if (SSL_IS_TLS13(s)) {
1121                 /*
1122                  * We encourage applications to only use TLSv1.3 tickets once,
1123                  * so we remove this one from the cache.
1124                  */
1125                 if ((s->session_ctx->session_cache_mode
1126                      & SSL_SESS_CACHE_CLIENT) != 0)
1127                     SSL_CTX_remove_session(s->session_ctx, s->session);
1128             } else {
1129                 /*
1130                  * In TLSv1.3 we update the cache as part of processing the
1131                  * NewSessionTicket
1132                  */
1133                 ssl_update_cache(s, SSL_SESS_CACHE_CLIENT);
1134             }
1135             if (s->hit)
1136                 tsan_counter(&s->session_ctx->stats.sess_hit);
1137
1138             s->handshake_func = ossl_statem_connect;
1139             tsan_counter(&s->session_ctx->stats.sess_connect_good);
1140         }
1141
1142         if (SSL_IS_DTLS(s)) {
1143             /* done with handshaking */
1144             s->d1->handshake_read_seq = 0;
1145             s->d1->handshake_write_seq = 0;
1146             s->d1->next_handshake_write_seq = 0;
1147             dtls1_clear_received_buffer(s);
1148         }
1149     }
1150
1151     if (s->info_callback != NULL)
1152         cb = s->info_callback;
1153     else if (s->ctx->info_callback != NULL)
1154         cb = s->ctx->info_callback;
1155
1156     /* The callback may expect us to not be in init at handshake done */
1157     ossl_statem_set_in_init(s, 0);
1158
1159     if (cb != NULL) {
1160         if (cleanuphand
1161                 || !SSL_IS_TLS13(s)
1162                 || SSL_IS_FIRST_HANDSHAKE(s))
1163             cb(s, SSL_CB_HANDSHAKE_DONE, 1);
1164     }
1165
1166     if (!stop) {
1167         /* If we've got more work to do we go back into init */
1168         ossl_statem_set_in_init(s, 1);
1169         return WORK_FINISHED_CONTINUE;
1170     }
1171
1172     return WORK_FINISHED_STOP;
1173 }
1174
1175 int tls_get_message_header(SSL *s, int *mt)
1176 {
1177     /* s->init_num < SSL3_HM_HEADER_LENGTH */
1178     int skip_message, i, recvd_type;
1179     unsigned char *p;
1180     size_t l, readbytes;
1181
1182     p = (unsigned char *)s->init_buf->data;
1183
1184     do {
1185         while (s->init_num < SSL3_HM_HEADER_LENGTH) {
1186             i = s->method->ssl_read_bytes(s, SSL3_RT_HANDSHAKE, &recvd_type,
1187                                           &p[s->init_num],
1188                                           SSL3_HM_HEADER_LENGTH - s->init_num,
1189                                           0, &readbytes);
1190             if (i <= 0) {
1191                 s->rwstate = SSL_READING;
1192                 return 0;
1193             }
1194             if (recvd_type == SSL3_RT_CHANGE_CIPHER_SPEC) {
1195                 /*
1196                  * A ChangeCipherSpec must be a single byte and may not occur
1197                  * in the middle of a handshake message.
1198                  */
1199                 if (s->init_num != 0 || readbytes != 1 || p[0] != SSL3_MT_CCS) {
1200                     SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE,
1201                              SSL_F_TLS_GET_MESSAGE_HEADER,
1202                              SSL_R_BAD_CHANGE_CIPHER_SPEC);
1203                     return 0;
1204                 }
1205                 if (s->statem.hand_state == TLS_ST_BEFORE
1206                         && (s->s3.flags & TLS1_FLAGS_STATELESS) != 0) {
1207                     /*
1208                      * We are stateless and we received a CCS. Probably this is
1209                      * from a client between the first and second ClientHellos.
1210                      * We should ignore this, but return an error because we do
1211                      * not return success until we see the second ClientHello
1212                      * with a valid cookie.
1213                      */
1214                     return 0;
1215                 }
1216                 s->s3.tmp.message_type = *mt = SSL3_MT_CHANGE_CIPHER_SPEC;
1217                 s->init_num = readbytes - 1;
1218                 s->init_msg = s->init_buf->data;
1219                 s->s3.tmp.message_size = readbytes;
1220                 return 1;
1221             } else if (recvd_type != SSL3_RT_HANDSHAKE) {
1222                 SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE,
1223                          SSL_F_TLS_GET_MESSAGE_HEADER,
1224                          SSL_R_CCS_RECEIVED_EARLY);
1225                 return 0;
1226             }
1227             s->init_num += readbytes;
1228         }
1229
1230         skip_message = 0;
1231         if (!s->server)
1232             if (s->statem.hand_state != TLS_ST_OK
1233                     && p[0] == SSL3_MT_HELLO_REQUEST)
1234                 /*
1235                  * The server may always send 'Hello Request' messages --
1236                  * we are doing a handshake anyway now, so ignore them if
1237                  * their format is correct. Does not count for 'Finished'
1238                  * MAC.
1239                  */
1240                 if (p[1] == 0 && p[2] == 0 && p[3] == 0) {
1241                     s->init_num = 0;
1242                     skip_message = 1;
1243
1244                     if (s->msg_callback)
1245                         s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE,
1246                                         p, SSL3_HM_HEADER_LENGTH, s,
1247                                         s->msg_callback_arg);
1248                 }
1249     } while (skip_message);
1250     /* s->init_num == SSL3_HM_HEADER_LENGTH */
1251
1252     *mt = *p;
1253     s->s3.tmp.message_type = *(p++);
1254
1255     if (RECORD_LAYER_is_sslv2_record(&s->rlayer)) {
1256         /*
1257          * Only happens with SSLv3+ in an SSLv2 backward compatible
1258          * ClientHello
1259          *
1260          * Total message size is the remaining record bytes to read
1261          * plus the SSL3_HM_HEADER_LENGTH bytes that we already read
1262          */
1263         l = RECORD_LAYER_get_rrec_length(&s->rlayer)
1264             + SSL3_HM_HEADER_LENGTH;
1265         s->s3.tmp.message_size = l;
1266
1267         s->init_msg = s->init_buf->data;
1268         s->init_num = SSL3_HM_HEADER_LENGTH;
1269     } else {
1270         n2l3(p, l);
1271         /* BUF_MEM_grow takes an 'int' parameter */
1272         if (l > (INT_MAX - SSL3_HM_HEADER_LENGTH)) {
1273             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_GET_MESSAGE_HEADER,
1274                      SSL_R_EXCESSIVE_MESSAGE_SIZE);
1275             return 0;
1276         }
1277         s->s3.tmp.message_size = l;
1278
1279         s->init_msg = s->init_buf->data + SSL3_HM_HEADER_LENGTH;
1280         s->init_num = 0;
1281     }
1282
1283     return 1;
1284 }
1285
1286 int tls_get_message_body(SSL *s, size_t *len)
1287 {
1288     size_t n, readbytes;
1289     unsigned char *p;
1290     int i;
1291
1292     if (s->s3.tmp.message_type == SSL3_MT_CHANGE_CIPHER_SPEC) {
1293         /* We've already read everything in */
1294         *len = (unsigned long)s->init_num;
1295         return 1;
1296     }
1297
1298     p = s->init_msg;
1299     n = s->s3.tmp.message_size - s->init_num;
1300     while (n > 0) {
1301         i = s->method->ssl_read_bytes(s, SSL3_RT_HANDSHAKE, NULL,
1302                                       &p[s->init_num], n, 0, &readbytes);
1303         if (i <= 0) {
1304             s->rwstate = SSL_READING;
1305             *len = 0;
1306             return 0;
1307         }
1308         s->init_num += readbytes;
1309         n -= readbytes;
1310     }
1311
1312     /*
1313      * If receiving Finished, record MAC of prior handshake messages for
1314      * Finished verification.
1315      */
1316     if (*(s->init_buf->data) == SSL3_MT_FINISHED && !ssl3_take_mac(s)) {
1317         /* SSLfatal() already called */
1318         *len = 0;
1319         return 0;
1320     }
1321
1322     /* Feed this message into MAC computation. */
1323     if (RECORD_LAYER_is_sslv2_record(&s->rlayer)) {
1324         if (!ssl3_finish_mac(s, (unsigned char *)s->init_buf->data,
1325                              s->init_num)) {
1326             /* SSLfatal() already called */
1327             *len = 0;
1328             return 0;
1329         }
1330         if (s->msg_callback)
1331             s->msg_callback(0, SSL2_VERSION, 0, s->init_buf->data,
1332                             (size_t)s->init_num, s, s->msg_callback_arg);
1333     } else {
1334         /*
1335          * We defer feeding in the HRR until later. We'll do it as part of
1336          * processing the message
1337          * The TLsv1.3 handshake transcript stops at the ClientFinished
1338          * message.
1339          */
1340 #define SERVER_HELLO_RANDOM_OFFSET  (SSL3_HM_HEADER_LENGTH + 2)
1341         /* KeyUpdate and NewSessionTicket do not need to be added */
1342         if (!SSL_IS_TLS13(s) || (s->s3.tmp.message_type != SSL3_MT_NEWSESSION_TICKET
1343                                  && s->s3.tmp.message_type != SSL3_MT_KEY_UPDATE)) {
1344             if (s->s3.tmp.message_type != SSL3_MT_SERVER_HELLO
1345                     || s->init_num < SERVER_HELLO_RANDOM_OFFSET + SSL3_RANDOM_SIZE
1346                     || memcmp(hrrrandom,
1347                               s->init_buf->data + SERVER_HELLO_RANDOM_OFFSET,
1348                               SSL3_RANDOM_SIZE) != 0) {
1349                 if (!ssl3_finish_mac(s, (unsigned char *)s->init_buf->data,
1350                                      s->init_num + SSL3_HM_HEADER_LENGTH)) {
1351                     /* SSLfatal() already called */
1352                     *len = 0;
1353                     return 0;
1354                 }
1355             }
1356         }
1357         if (s->msg_callback)
1358             s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, s->init_buf->data,
1359                             (size_t)s->init_num + SSL3_HM_HEADER_LENGTH, s,
1360                             s->msg_callback_arg);
1361     }
1362
1363     *len = s->init_num;
1364     return 1;
1365 }
1366
1367 static const X509ERR2ALERT x509table[] = {
1368     {X509_V_ERR_APPLICATION_VERIFICATION, SSL_AD_HANDSHAKE_FAILURE},
1369     {X509_V_ERR_CA_KEY_TOO_SMALL, SSL_AD_BAD_CERTIFICATE},
1370     {X509_V_ERR_CA_MD_TOO_WEAK, SSL_AD_BAD_CERTIFICATE},
1371     {X509_V_ERR_CERT_CHAIN_TOO_LONG, SSL_AD_UNKNOWN_CA},
1372     {X509_V_ERR_CERT_HAS_EXPIRED, SSL_AD_CERTIFICATE_EXPIRED},
1373     {X509_V_ERR_CERT_NOT_YET_VALID, SSL_AD_BAD_CERTIFICATE},
1374     {X509_V_ERR_CERT_REJECTED, SSL_AD_BAD_CERTIFICATE},
1375     {X509_V_ERR_CERT_REVOKED, SSL_AD_CERTIFICATE_REVOKED},
1376     {X509_V_ERR_CERT_SIGNATURE_FAILURE, SSL_AD_DECRYPT_ERROR},
1377     {X509_V_ERR_CERT_UNTRUSTED, SSL_AD_BAD_CERTIFICATE},
1378     {X509_V_ERR_CRL_HAS_EXPIRED, SSL_AD_CERTIFICATE_EXPIRED},
1379     {X509_V_ERR_CRL_NOT_YET_VALID, SSL_AD_BAD_CERTIFICATE},
1380     {X509_V_ERR_CRL_SIGNATURE_FAILURE, SSL_AD_DECRYPT_ERROR},
1381     {X509_V_ERR_DANE_NO_MATCH, SSL_AD_BAD_CERTIFICATE},
1382     {X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT, SSL_AD_UNKNOWN_CA},
1383     {X509_V_ERR_EE_KEY_TOO_SMALL, SSL_AD_BAD_CERTIFICATE},
1384     {X509_V_ERR_EMAIL_MISMATCH, SSL_AD_BAD_CERTIFICATE},
1385     {X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD, SSL_AD_BAD_CERTIFICATE},
1386     {X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD, SSL_AD_BAD_CERTIFICATE},
1387     {X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD, SSL_AD_BAD_CERTIFICATE},
1388     {X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD, SSL_AD_BAD_CERTIFICATE},
1389     {X509_V_ERR_HOSTNAME_MISMATCH, SSL_AD_BAD_CERTIFICATE},
1390     {X509_V_ERR_INVALID_CA, SSL_AD_UNKNOWN_CA},
1391     {X509_V_ERR_INVALID_CALL, SSL_AD_INTERNAL_ERROR},
1392     {X509_V_ERR_INVALID_PURPOSE, SSL_AD_UNSUPPORTED_CERTIFICATE},
1393     {X509_V_ERR_IP_ADDRESS_MISMATCH, SSL_AD_BAD_CERTIFICATE},
1394     {X509_V_ERR_OUT_OF_MEM, SSL_AD_INTERNAL_ERROR},
1395     {X509_V_ERR_PATH_LENGTH_EXCEEDED, SSL_AD_UNKNOWN_CA},
1396     {X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN, SSL_AD_UNKNOWN_CA},
1397     {X509_V_ERR_STORE_LOOKUP, SSL_AD_INTERNAL_ERROR},
1398     {X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY, SSL_AD_BAD_CERTIFICATE},
1399     {X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE, SSL_AD_BAD_CERTIFICATE},
1400     {X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE, SSL_AD_BAD_CERTIFICATE},
1401     {X509_V_ERR_UNABLE_TO_GET_CRL, SSL_AD_UNKNOWN_CA},
1402     {X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER, SSL_AD_UNKNOWN_CA},
1403     {X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT, SSL_AD_UNKNOWN_CA},
1404     {X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY, SSL_AD_UNKNOWN_CA},
1405     {X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE, SSL_AD_UNKNOWN_CA},
1406     {X509_V_ERR_UNSPECIFIED, SSL_AD_INTERNAL_ERROR},
1407
1408     /* Last entry; return this if we don't find the value above. */
1409     {X509_V_OK, SSL_AD_CERTIFICATE_UNKNOWN}
1410 };
1411
1412 int ssl_x509err2alert(int x509err)
1413 {
1414     const X509ERR2ALERT *tp;
1415
1416     for (tp = x509table; tp->x509err != X509_V_OK; ++tp)
1417         if (tp->x509err == x509err)
1418             break;
1419     return tp->alert;
1420 }
1421
1422 int ssl_allow_compression(SSL *s)
1423 {
1424     if (s->options & SSL_OP_NO_COMPRESSION)
1425         return 0;
1426     return ssl_security(s, SSL_SECOP_COMPRESSION, 0, 0, NULL);
1427 }
1428
1429 static int version_cmp(const SSL *s, int a, int b)
1430 {
1431     int dtls = SSL_IS_DTLS(s);
1432
1433     if (a == b)
1434         return 0;
1435     if (!dtls)
1436         return a < b ? -1 : 1;
1437     return DTLS_VERSION_LT(a, b) ? -1 : 1;
1438 }
1439
1440 typedef struct {
1441     int version;
1442     const SSL_METHOD *(*cmeth) (void);
1443     const SSL_METHOD *(*smeth) (void);
1444 } version_info;
1445
1446 #if TLS_MAX_VERSION_INTERNAL != TLS1_3_VERSION
1447 # error Code needs update for TLS_method() support beyond TLS1_3_VERSION.
1448 #endif
1449
1450 /* Must be in order high to low */
1451 static const version_info tls_version_table[] = {
1452 #ifndef OPENSSL_NO_TLS1_3
1453     {TLS1_3_VERSION, tlsv1_3_client_method, tlsv1_3_server_method},
1454 #else
1455     {TLS1_3_VERSION, NULL, NULL},
1456 #endif
1457 #ifndef OPENSSL_NO_TLS1_2
1458     {TLS1_2_VERSION, tlsv1_2_client_method, tlsv1_2_server_method},
1459 #else
1460     {TLS1_2_VERSION, NULL, NULL},
1461 #endif
1462 #ifndef OPENSSL_NO_TLS1_1
1463     {TLS1_1_VERSION, tlsv1_1_client_method, tlsv1_1_server_method},
1464 #else
1465     {TLS1_1_VERSION, NULL, NULL},
1466 #endif
1467 #ifndef OPENSSL_NO_TLS1
1468     {TLS1_VERSION, tlsv1_client_method, tlsv1_server_method},
1469 #else
1470     {TLS1_VERSION, NULL, NULL},
1471 #endif
1472 #ifndef OPENSSL_NO_SSL3
1473     {SSL3_VERSION, sslv3_client_method, sslv3_server_method},
1474 #else
1475     {SSL3_VERSION, NULL, NULL},
1476 #endif
1477     {0, NULL, NULL},
1478 };
1479
1480 #if DTLS_MAX_VERSION_INTERNAL != DTLS1_2_VERSION
1481 # error Code needs update for DTLS_method() support beyond DTLS1_2_VERSION.
1482 #endif
1483
1484 /* Must be in order high to low */
1485 static const version_info dtls_version_table[] = {
1486 #ifndef OPENSSL_NO_DTLS1_2
1487     {DTLS1_2_VERSION, dtlsv1_2_client_method, dtlsv1_2_server_method},
1488 #else
1489     {DTLS1_2_VERSION, NULL, NULL},
1490 #endif
1491 #ifndef OPENSSL_NO_DTLS1
1492     {DTLS1_VERSION, dtlsv1_client_method, dtlsv1_server_method},
1493     {DTLS1_BAD_VER, dtls_bad_ver_client_method, NULL},
1494 #else
1495     {DTLS1_VERSION, NULL, NULL},
1496     {DTLS1_BAD_VER, NULL, NULL},
1497 #endif
1498     {0, NULL, NULL},
1499 };
1500
1501 /*
1502  * ssl_method_error - Check whether an SSL_METHOD is enabled.
1503  *
1504  * @s: The SSL handle for the candidate method
1505  * @method: the intended method.
1506  *
1507  * Returns 0 on success, or an SSL error reason on failure.
1508  */
1509 static int ssl_method_error(const SSL *s, const SSL_METHOD *method)
1510 {
1511     int version = method->version;
1512
1513     if ((s->min_proto_version != 0 &&
1514          version_cmp(s, version, s->min_proto_version) < 0) ||
1515         ssl_security(s, SSL_SECOP_VERSION, 0, version, NULL) == 0)
1516         return SSL_R_VERSION_TOO_LOW;
1517
1518     if (s->max_proto_version != 0 &&
1519         version_cmp(s, version, s->max_proto_version) > 0)
1520         return SSL_R_VERSION_TOO_HIGH;
1521
1522     if ((s->options & method->mask) != 0)
1523         return SSL_R_UNSUPPORTED_PROTOCOL;
1524     if ((method->flags & SSL_METHOD_NO_SUITEB) != 0 && tls1_suiteb(s))
1525         return SSL_R_AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE;
1526
1527     return 0;
1528 }
1529
1530 /*
1531  * Only called by servers. Returns 1 if the server has a TLSv1.3 capable
1532  * certificate type, or has PSK or a certificate callback configured. Otherwise
1533  * returns 0.
1534  */
1535 static int is_tls13_capable(const SSL *s)
1536 {
1537     int i;
1538 #ifndef OPENSSL_NO_EC
1539     int curve;
1540 #endif
1541
1542 #ifndef OPENSSL_NO_PSK
1543     if (s->psk_server_callback != NULL)
1544         return 1;
1545 #endif
1546
1547     if (s->psk_find_session_cb != NULL || s->cert->cert_cb != NULL)
1548         return 1;
1549
1550     for (i = 0; i < SSL_PKEY_NUM; i++) {
1551         /* Skip over certs disallowed for TLSv1.3 */
1552         switch (i) {
1553         case SSL_PKEY_DSA_SIGN:
1554         case SSL_PKEY_GOST01:
1555         case SSL_PKEY_GOST12_256:
1556         case SSL_PKEY_GOST12_512:
1557             continue;
1558         default:
1559             break;
1560         }
1561         if (!ssl_has_cert(s, i))
1562             continue;
1563 #ifndef OPENSSL_NO_EC
1564         if (i != SSL_PKEY_ECC)
1565             return 1;
1566         /*
1567          * Prior to TLSv1.3 sig algs allowed any curve to be used. TLSv1.3 is
1568          * more restrictive so check that our sig algs are consistent with this
1569          * EC cert. See section 4.2.3 of RFC8446.
1570          */
1571         curve = evp_pkey_get_EC_KEY_curve_nid(s->cert->pkeys[SSL_PKEY_ECC]
1572                                               .privatekey);
1573         if (tls_check_sigalg_curve(s, curve))
1574             return 1;
1575 #else
1576         return 1;
1577 #endif
1578     }
1579
1580     return 0;
1581 }
1582
1583 /*
1584  * ssl_version_supported - Check that the specified `version` is supported by
1585  * `SSL *` instance
1586  *
1587  * @s: The SSL handle for the candidate method
1588  * @version: Protocol version to test against
1589  *
1590  * Returns 1 when supported, otherwise 0
1591  */
1592 int ssl_version_supported(const SSL *s, int version, const SSL_METHOD **meth)
1593 {
1594     const version_info *vent;
1595     const version_info *table;
1596
1597     switch (s->method->version) {
1598     default:
1599         /* Version should match method version for non-ANY method */
1600         return version_cmp(s, version, s->version) == 0;
1601     case TLS_ANY_VERSION:
1602         table = tls_version_table;
1603         break;
1604     case DTLS_ANY_VERSION:
1605         table = dtls_version_table;
1606         break;
1607     }
1608
1609     for (vent = table;
1610          vent->version != 0 && version_cmp(s, version, vent->version) <= 0;
1611          ++vent) {
1612         if (vent->cmeth != NULL
1613                 && version_cmp(s, version, vent->version) == 0
1614                 && ssl_method_error(s, vent->cmeth()) == 0
1615                 && (!s->server
1616                     || version != TLS1_3_VERSION
1617                     || is_tls13_capable(s))) {
1618             if (meth != NULL)
1619                 *meth = vent->cmeth();
1620             return 1;
1621         }
1622     }
1623     return 0;
1624 }
1625
1626 /*
1627  * ssl_check_version_downgrade - In response to RFC7507 SCSV version
1628  * fallback indication from a client check whether we're using the highest
1629  * supported protocol version.
1630  *
1631  * @s server SSL handle.
1632  *
1633  * Returns 1 when using the highest enabled version, 0 otherwise.
1634  */
1635 int ssl_check_version_downgrade(SSL *s)
1636 {
1637     const version_info *vent;
1638     const version_info *table;
1639
1640     /*
1641      * Check that the current protocol is the highest enabled version
1642      * (according to s->ctx->method, as version negotiation may have changed
1643      * s->method).
1644      */
1645     if (s->version == s->ctx->method->version)
1646         return 1;
1647
1648     /*
1649      * Apparently we're using a version-flexible SSL_METHOD (not at its
1650      * highest protocol version).
1651      */
1652     if (s->ctx->method->version == TLS_method()->version)
1653         table = tls_version_table;
1654     else if (s->ctx->method->version == DTLS_method()->version)
1655         table = dtls_version_table;
1656     else {
1657         /* Unexpected state; fail closed. */
1658         return 0;
1659     }
1660
1661     for (vent = table; vent->version != 0; ++vent) {
1662         if (vent->smeth != NULL && ssl_method_error(s, vent->smeth()) == 0)
1663             return s->version == vent->version;
1664     }
1665     return 0;
1666 }
1667
1668 /*
1669  * ssl_set_version_bound - set an upper or lower bound on the supported (D)TLS
1670  * protocols, provided the initial (D)TLS method is version-flexible.  This
1671  * function sanity-checks the proposed value and makes sure the method is
1672  * version-flexible, then sets the limit if all is well.
1673  *
1674  * @method_version: The version of the current SSL_METHOD.
1675  * @version: the intended limit.
1676  * @bound: pointer to limit to be updated.
1677  *
1678  * Returns 1 on success, 0 on failure.
1679  */
1680 int ssl_set_version_bound(int method_version, int version, int *bound)
1681 {
1682     int valid_tls;
1683     int valid_dtls;
1684
1685     if (version == 0) {
1686         *bound = version;
1687         return 1;
1688     }
1689
1690     valid_tls = version >= SSL3_VERSION && version <= TLS_MAX_VERSION_INTERNAL;
1691     valid_dtls =
1692         DTLS_VERSION_LE(version, DTLS_MAX_VERSION_INTERNAL) &&
1693         DTLS_VERSION_GE(version, DTLS1_BAD_VER);
1694
1695     if (!valid_tls && !valid_dtls)
1696         return 0;
1697
1698     /*-
1699      * Restrict TLS methods to TLS protocol versions.
1700      * Restrict DTLS methods to DTLS protocol versions.
1701      * Note, DTLS version numbers are decreasing, use comparison macros.
1702      *
1703      * Note that for both lower-bounds we use explicit versions, not
1704      * (D)TLS_MIN_VERSION.  This is because we don't want to break user
1705      * configurations.  If the MIN (supported) version ever rises, the user's
1706      * "floor" remains valid even if no longer available.  We don't expect the
1707      * MAX ceiling to ever get lower, so making that variable makes sense.
1708      *
1709      * We ignore attempts to set bounds on version-inflexible methods,
1710      * returning success.
1711      */
1712     switch (method_version) {
1713     default:
1714         break;
1715
1716     case TLS_ANY_VERSION:
1717         if (valid_tls)
1718             *bound = version;
1719         break;
1720
1721     case DTLS_ANY_VERSION:
1722         if (valid_dtls)
1723             *bound = version;
1724         break;
1725     }
1726     return 1;
1727 }
1728
1729 static void check_for_downgrade(SSL *s, int vers, DOWNGRADE *dgrd)
1730 {
1731     if (vers == TLS1_2_VERSION
1732             && ssl_version_supported(s, TLS1_3_VERSION, NULL)) {
1733         *dgrd = DOWNGRADE_TO_1_2;
1734     } else if (!SSL_IS_DTLS(s)
1735             && vers < TLS1_2_VERSION
1736                /*
1737                 * We need to ensure that a server that disables TLSv1.2
1738                 * (creating a hole between TLSv1.3 and TLSv1.1) can still
1739                 * complete handshakes with clients that support TLSv1.2 and
1740                 * below. Therefore we do not enable the sentinel if TLSv1.3 is
1741                 * enabled and TLSv1.2 is not.
1742                 */
1743             && ssl_version_supported(s, TLS1_2_VERSION, NULL)) {
1744         *dgrd = DOWNGRADE_TO_1_1;
1745     } else {
1746         *dgrd = DOWNGRADE_NONE;
1747     }
1748 }
1749
1750 /*
1751  * ssl_choose_server_version - Choose server (D)TLS version.  Called when the
1752  * client HELLO is received to select the final server protocol version and
1753  * the version specific method.
1754  *
1755  * @s: server SSL handle.
1756  *
1757  * Returns 0 on success or an SSL error reason number on failure.
1758  */
1759 int ssl_choose_server_version(SSL *s, CLIENTHELLO_MSG *hello, DOWNGRADE *dgrd)
1760 {
1761     /*-
1762      * With version-flexible methods we have an initial state with:
1763      *
1764      *   s->method->version == (D)TLS_ANY_VERSION,
1765      *   s->version == (D)TLS_MAX_VERSION_INTERNAL.
1766      *
1767      * So we detect version-flexible methods via the method version, not the
1768      * handle version.
1769      */
1770     int server_version = s->method->version;
1771     int client_version = hello->legacy_version;
1772     const version_info *vent;
1773     const version_info *table;
1774     int disabled = 0;
1775     RAW_EXTENSION *suppversions;
1776
1777     s->client_version = client_version;
1778
1779     switch (server_version) {
1780     default:
1781         if (!SSL_IS_TLS13(s)) {
1782             if (version_cmp(s, client_version, s->version) < 0)
1783                 return SSL_R_WRONG_SSL_VERSION;
1784             *dgrd = DOWNGRADE_NONE;
1785             /*
1786              * If this SSL handle is not from a version flexible method we don't
1787              * (and never did) check min/max FIPS or Suite B constraints.  Hope
1788              * that's OK.  It is up to the caller to not choose fixed protocol
1789              * versions they don't want.  If not, then easy to fix, just return
1790              * ssl_method_error(s, s->method)
1791              */
1792             return 0;
1793         }
1794         /*
1795          * Fall through if we are TLSv1.3 already (this means we must be after
1796          * a HelloRetryRequest
1797          */
1798         /* fall thru */
1799     case TLS_ANY_VERSION:
1800         table = tls_version_table;
1801         break;
1802     case DTLS_ANY_VERSION:
1803         table = dtls_version_table;
1804         break;
1805     }
1806
1807     suppversions = &hello->pre_proc_exts[TLSEXT_IDX_supported_versions];
1808
1809     /* If we did an HRR then supported versions is mandatory */
1810     if (!suppversions->present && s->hello_retry_request != SSL_HRR_NONE)
1811         return SSL_R_UNSUPPORTED_PROTOCOL;
1812
1813     if (suppversions->present && !SSL_IS_DTLS(s)) {
1814         unsigned int candidate_vers = 0;
1815         unsigned int best_vers = 0;
1816         const SSL_METHOD *best_method = NULL;
1817         PACKET versionslist;
1818
1819         suppversions->parsed = 1;
1820
1821         if (!PACKET_as_length_prefixed_1(&suppversions->data, &versionslist)) {
1822             /* Trailing or invalid data? */
1823             return SSL_R_LENGTH_MISMATCH;
1824         }
1825
1826         /*
1827          * The TLSv1.3 spec says the client MUST set this to TLS1_2_VERSION.
1828          * The spec only requires servers to check that it isn't SSLv3:
1829          * "Any endpoint receiving a Hello message with
1830          * ClientHello.legacy_version or ServerHello.legacy_version set to
1831          * 0x0300 MUST abort the handshake with a "protocol_version" alert."
1832          * We are slightly stricter and require that it isn't SSLv3 or lower.
1833          * We tolerate TLSv1 and TLSv1.1.
1834          */
1835         if (client_version <= SSL3_VERSION)
1836             return SSL_R_BAD_LEGACY_VERSION;
1837
1838         while (PACKET_get_net_2(&versionslist, &candidate_vers)) {
1839             if (version_cmp(s, candidate_vers, best_vers) <= 0)
1840                 continue;
1841             if (ssl_version_supported(s, candidate_vers, &best_method))
1842                 best_vers = candidate_vers;
1843         }
1844         if (PACKET_remaining(&versionslist) != 0) {
1845             /* Trailing data? */
1846             return SSL_R_LENGTH_MISMATCH;
1847         }
1848
1849         if (best_vers > 0) {
1850             if (s->hello_retry_request != SSL_HRR_NONE) {
1851                 /*
1852                  * This is after a HelloRetryRequest so we better check that we
1853                  * negotiated TLSv1.3
1854                  */
1855                 if (best_vers != TLS1_3_VERSION)
1856                     return SSL_R_UNSUPPORTED_PROTOCOL;
1857                 return 0;
1858             }
1859             check_for_downgrade(s, best_vers, dgrd);
1860             s->version = best_vers;
1861             s->method = best_method;
1862             return 0;
1863         }
1864         return SSL_R_UNSUPPORTED_PROTOCOL;
1865     }
1866
1867     /*
1868      * If the supported versions extension isn't present, then the highest
1869      * version we can negotiate is TLSv1.2
1870      */
1871     if (version_cmp(s, client_version, TLS1_3_VERSION) >= 0)
1872         client_version = TLS1_2_VERSION;
1873
1874     /*
1875      * No supported versions extension, so we just use the version supplied in
1876      * the ClientHello.
1877      */
1878     for (vent = table; vent->version != 0; ++vent) {
1879         const SSL_METHOD *method;
1880
1881         if (vent->smeth == NULL ||
1882             version_cmp(s, client_version, vent->version) < 0)
1883             continue;
1884         method = vent->smeth();
1885         if (ssl_method_error(s, method) == 0) {
1886             check_for_downgrade(s, vent->version, dgrd);
1887             s->version = vent->version;
1888             s->method = method;
1889             return 0;
1890         }
1891         disabled = 1;
1892     }
1893     return disabled ? SSL_R_UNSUPPORTED_PROTOCOL : SSL_R_VERSION_TOO_LOW;
1894 }
1895
1896 /*
1897  * ssl_choose_client_version - Choose client (D)TLS version.  Called when the
1898  * server HELLO is received to select the final client protocol version and
1899  * the version specific method.
1900  *
1901  * @s: client SSL handle.
1902  * @version: The proposed version from the server's HELLO.
1903  * @extensions: The extensions received
1904  *
1905  * Returns 1 on success or 0 on error.
1906  */
1907 int ssl_choose_client_version(SSL *s, int version, RAW_EXTENSION *extensions)
1908 {
1909     const version_info *vent;
1910     const version_info *table;
1911     int ret, ver_min, ver_max, real_max, origv;
1912
1913     origv = s->version;
1914     s->version = version;
1915
1916     /* This will overwrite s->version if the extension is present */
1917     if (!tls_parse_extension(s, TLSEXT_IDX_supported_versions,
1918                              SSL_EXT_TLS1_2_SERVER_HELLO
1919                              | SSL_EXT_TLS1_3_SERVER_HELLO, extensions,
1920                              NULL, 0)) {
1921         s->version = origv;
1922         return 0;
1923     }
1924
1925     if (s->hello_retry_request != SSL_HRR_NONE
1926             && s->version != TLS1_3_VERSION) {
1927         s->version = origv;
1928         SSLfatal(s, SSL_AD_PROTOCOL_VERSION, SSL_F_SSL_CHOOSE_CLIENT_VERSION,
1929                  SSL_R_WRONG_SSL_VERSION);
1930         return 0;
1931     }
1932
1933     switch (s->method->version) {
1934     default:
1935         if (s->version != s->method->version) {
1936             s->version = origv;
1937             SSLfatal(s, SSL_AD_PROTOCOL_VERSION,
1938                      SSL_F_SSL_CHOOSE_CLIENT_VERSION,
1939                      SSL_R_WRONG_SSL_VERSION);
1940             return 0;
1941         }
1942         /*
1943          * If this SSL handle is not from a version flexible method we don't
1944          * (and never did) check min/max, FIPS or Suite B constraints.  Hope
1945          * that's OK.  It is up to the caller to not choose fixed protocol
1946          * versions they don't want.  If not, then easy to fix, just return
1947          * ssl_method_error(s, s->method)
1948          */
1949         return 1;
1950     case TLS_ANY_VERSION:
1951         table = tls_version_table;
1952         break;
1953     case DTLS_ANY_VERSION:
1954         table = dtls_version_table;
1955         break;
1956     }
1957
1958     ret = ssl_get_min_max_version(s, &ver_min, &ver_max, &real_max);
1959     if (ret != 0) {
1960         s->version = origv;
1961         SSLfatal(s, SSL_AD_PROTOCOL_VERSION,
1962                  SSL_F_SSL_CHOOSE_CLIENT_VERSION, ret);
1963         return 0;
1964     }
1965     if (SSL_IS_DTLS(s) ? DTLS_VERSION_LT(s->version, ver_min)
1966                        : s->version < ver_min) {
1967         s->version = origv;
1968         SSLfatal(s, SSL_AD_PROTOCOL_VERSION,
1969                  SSL_F_SSL_CHOOSE_CLIENT_VERSION, SSL_R_UNSUPPORTED_PROTOCOL);
1970         return 0;
1971     } else if (SSL_IS_DTLS(s) ? DTLS_VERSION_GT(s->version, ver_max)
1972                               : s->version > ver_max) {
1973         s->version = origv;
1974         SSLfatal(s, SSL_AD_PROTOCOL_VERSION,
1975                  SSL_F_SSL_CHOOSE_CLIENT_VERSION, SSL_R_UNSUPPORTED_PROTOCOL);
1976         return 0;
1977     }
1978
1979     if ((s->mode & SSL_MODE_SEND_FALLBACK_SCSV) == 0)
1980         real_max = ver_max;
1981
1982     /* Check for downgrades */
1983     if (s->version == TLS1_2_VERSION && real_max > s->version) {
1984         if (memcmp(tls12downgrade,
1985                    s->s3.server_random + SSL3_RANDOM_SIZE
1986                                         - sizeof(tls12downgrade),
1987                    sizeof(tls12downgrade)) == 0) {
1988             s->version = origv;
1989             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
1990                      SSL_F_SSL_CHOOSE_CLIENT_VERSION,
1991                      SSL_R_INAPPROPRIATE_FALLBACK);
1992             return 0;
1993         }
1994     } else if (!SSL_IS_DTLS(s)
1995                && s->version < TLS1_2_VERSION
1996                && real_max > s->version) {
1997         if (memcmp(tls11downgrade,
1998                    s->s3.server_random + SSL3_RANDOM_SIZE
1999                                         - sizeof(tls11downgrade),
2000                    sizeof(tls11downgrade)) == 0) {
2001             s->version = origv;
2002             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
2003                      SSL_F_SSL_CHOOSE_CLIENT_VERSION,
2004                      SSL_R_INAPPROPRIATE_FALLBACK);
2005             return 0;
2006         }
2007     }
2008
2009     for (vent = table; vent->version != 0; ++vent) {
2010         if (vent->cmeth == NULL || s->version != vent->version)
2011             continue;
2012
2013         s->method = vent->cmeth();
2014         return 1;
2015     }
2016
2017     s->version = origv;
2018     SSLfatal(s, SSL_AD_PROTOCOL_VERSION, SSL_F_SSL_CHOOSE_CLIENT_VERSION,
2019              SSL_R_UNSUPPORTED_PROTOCOL);
2020     return 0;
2021 }
2022
2023 /*
2024  * ssl_get_min_max_version - get minimum and maximum protocol version
2025  * @s: The SSL connection
2026  * @min_version: The minimum supported version
2027  * @max_version: The maximum supported version
2028  * @real_max:    The highest version below the lowest compile time version hole
2029  *               where that hole lies above at least one run-time enabled
2030  *               protocol.
2031  *
2032  * Work out what version we should be using for the initial ClientHello if the
2033  * version is initially (D)TLS_ANY_VERSION.  We apply any explicit SSL_OP_NO_xxx
2034  * options, the MinProtocol and MaxProtocol configuration commands, any Suite B
2035  * constraints and any floor imposed by the security level here,
2036  * so we don't advertise the wrong protocol version to only reject the outcome later.
2037  *
2038  * Computing the right floor matters.  If, e.g., TLS 1.0 and 1.2 are enabled,
2039  * TLS 1.1 is disabled, but the security level, Suite-B  and/or MinProtocol
2040  * only allow TLS 1.2, we want to advertise TLS1.2, *not* TLS1.
2041  *
2042  * Returns 0 on success or an SSL error reason number on failure.  On failure
2043  * min_version and max_version will also be set to 0.
2044  */
2045 int ssl_get_min_max_version(const SSL *s, int *min_version, int *max_version,
2046                             int *real_max)
2047 {
2048     int version, tmp_real_max;
2049     int hole;
2050     const SSL_METHOD *single = NULL;
2051     const SSL_METHOD *method;
2052     const version_info *table;
2053     const version_info *vent;
2054
2055     switch (s->method->version) {
2056     default:
2057         /*
2058          * If this SSL handle is not from a version flexible method we don't
2059          * (and never did) check min/max FIPS or Suite B constraints.  Hope
2060          * that's OK.  It is up to the caller to not choose fixed protocol
2061          * versions they don't want.  If not, then easy to fix, just return
2062          * ssl_method_error(s, s->method)
2063          */
2064         *min_version = *max_version = s->version;
2065         /*
2066          * Providing a real_max only makes sense where we're using a version
2067          * flexible method.
2068          */
2069         if (!ossl_assert(real_max == NULL))
2070             return ERR_R_INTERNAL_ERROR;
2071         return 0;
2072     case TLS_ANY_VERSION:
2073         table = tls_version_table;
2074         break;
2075     case DTLS_ANY_VERSION:
2076         table = dtls_version_table;
2077         break;
2078     }
2079
2080     /*
2081      * SSL_OP_NO_X disables all protocols above X *if* there are some protocols
2082      * below X enabled. This is required in order to maintain the "version
2083      * capability" vector contiguous. Any versions with a NULL client method
2084      * (protocol version client is disabled at compile-time) is also a "hole".
2085      *
2086      * Our initial state is hole == 1, version == 0.  That is, versions above
2087      * the first version in the method table are disabled (a "hole" above
2088      * the valid protocol entries) and we don't have a selected version yet.
2089      *
2090      * Whenever "hole == 1", and we hit an enabled method, its version becomes
2091      * the selected version, and the method becomes a candidate "single"
2092      * method.  We're no longer in a hole, so "hole" becomes 0.
2093      *
2094      * If "hole == 0" and we hit an enabled method, then "single" is cleared,
2095      * as we support a contiguous range of at least two methods.  If we hit
2096      * a disabled method, then hole becomes true again, but nothing else
2097      * changes yet, because all the remaining methods may be disabled too.
2098      * If we again hit an enabled method after the new hole, it becomes
2099      * selected, as we start from scratch.
2100      */
2101     *min_version = version = 0;
2102     hole = 1;
2103     if (real_max != NULL)
2104         *real_max = 0;
2105     tmp_real_max = 0;
2106     for (vent = table; vent->version != 0; ++vent) {
2107         /*
2108          * A table entry with a NULL client method is still a hole in the
2109          * "version capability" vector.
2110          */
2111         if (vent->cmeth == NULL) {
2112             hole = 1;
2113             tmp_real_max = 0;
2114             continue;
2115         }
2116         method = vent->cmeth();
2117
2118         if (hole == 1 && tmp_real_max == 0)
2119             tmp_real_max = vent->version;
2120
2121         if (ssl_method_error(s, method) != 0) {
2122             hole = 1;
2123         } else if (!hole) {
2124             single = NULL;
2125             *min_version = method->version;
2126         } else {
2127             if (real_max != NULL && tmp_real_max != 0)
2128                 *real_max = tmp_real_max;
2129             version = (single = method)->version;
2130             *min_version = version;
2131             hole = 0;
2132         }
2133     }
2134
2135     *max_version = version;
2136
2137     /* Fail if everything is disabled */
2138     if (version == 0)
2139         return SSL_R_NO_PROTOCOLS_AVAILABLE;
2140
2141     return 0;
2142 }
2143
2144 /*
2145  * ssl_set_client_hello_version - Work out what version we should be using for
2146  * the initial ClientHello.legacy_version field.
2147  *
2148  * @s: client SSL handle.
2149  *
2150  * Returns 0 on success or an SSL error reason number on failure.
2151  */
2152 int ssl_set_client_hello_version(SSL *s)
2153 {
2154     int ver_min, ver_max, ret;
2155
2156     /*
2157      * In a renegotiation we always send the same client_version that we sent
2158      * last time, regardless of which version we eventually negotiated.
2159      */
2160     if (!SSL_IS_FIRST_HANDSHAKE(s))
2161         return 0;
2162
2163     ret = ssl_get_min_max_version(s, &ver_min, &ver_max, NULL);
2164
2165     if (ret != 0)
2166         return ret;
2167
2168     s->version = ver_max;
2169
2170     /* TLS1.3 always uses TLS1.2 in the legacy_version field */
2171     if (!SSL_IS_DTLS(s) && ver_max > TLS1_2_VERSION)
2172         ver_max = TLS1_2_VERSION;
2173
2174     s->client_version = ver_max;
2175     return 0;
2176 }
2177
2178 /*
2179  * Checks a list of |groups| to determine if the |group_id| is in it. If it is
2180  * and |checkallow| is 1 then additionally check if the group is allowed to be
2181  * used. Returns 1 if the group is in the list (and allowed if |checkallow| is
2182  * 1) or 0 otherwise.
2183  */
2184 int check_in_list(SSL *s, uint16_t group_id, const uint16_t *groups,
2185                   size_t num_groups, int checkallow)
2186 {
2187     size_t i;
2188
2189     if (groups == NULL || num_groups == 0)
2190         return 0;
2191
2192     for (i = 0; i < num_groups; i++) {
2193         uint16_t group = groups[i];
2194
2195         if (group_id == group
2196                 && (!checkallow
2197                     || tls_group_allowed(s, group, SSL_SECOP_CURVE_CHECK))) {
2198             return 1;
2199         }
2200     }
2201
2202     return 0;
2203 }
2204
2205 /* Replace ClientHello1 in the transcript hash with a synthetic message */
2206 int create_synthetic_message_hash(SSL *s, const unsigned char *hashval,
2207                                   size_t hashlen, const unsigned char *hrr,
2208                                   size_t hrrlen)
2209 {
2210     unsigned char hashvaltmp[EVP_MAX_MD_SIZE];
2211     unsigned char msghdr[SSL3_HM_HEADER_LENGTH];
2212
2213     memset(msghdr, 0, sizeof(msghdr));
2214
2215     if (hashval == NULL) {
2216         hashval = hashvaltmp;
2217         hashlen = 0;
2218         /* Get the hash of the initial ClientHello */
2219         if (!ssl3_digest_cached_records(s, 0)
2220                 || !ssl_handshake_hash(s, hashvaltmp, sizeof(hashvaltmp),
2221                                        &hashlen)) {
2222             /* SSLfatal() already called */
2223             return 0;
2224         }
2225     }
2226
2227     /* Reinitialise the transcript hash */
2228     if (!ssl3_init_finished_mac(s)) {
2229         /* SSLfatal() already called */
2230         return 0;
2231     }
2232
2233     /* Inject the synthetic message_hash message */
2234     msghdr[0] = SSL3_MT_MESSAGE_HASH;
2235     msghdr[SSL3_HM_HEADER_LENGTH - 1] = (unsigned char)hashlen;
2236     if (!ssl3_finish_mac(s, msghdr, SSL3_HM_HEADER_LENGTH)
2237             || !ssl3_finish_mac(s, hashval, hashlen)) {
2238         /* SSLfatal() already called */
2239         return 0;
2240     }
2241
2242     /*
2243      * Now re-inject the HRR and current message if appropriate (we just deleted
2244      * it when we reinitialised the transcript hash above). Only necessary after
2245      * receiving a ClientHello2 with a cookie.
2246      */
2247     if (hrr != NULL
2248             && (!ssl3_finish_mac(s, hrr, hrrlen)
2249                 || !ssl3_finish_mac(s, (unsigned char *)s->init_buf->data,
2250                                     s->s3.tmp.message_size
2251                                     + SSL3_HM_HEADER_LENGTH))) {
2252         /* SSLfatal() already called */
2253         return 0;
2254     }
2255
2256     return 1;
2257 }
2258
2259 static int ca_dn_cmp(const X509_NAME *const *a, const X509_NAME *const *b)
2260 {
2261     return X509_NAME_cmp(*a, *b);
2262 }
2263
2264 int parse_ca_names(SSL *s, PACKET *pkt)
2265 {
2266     STACK_OF(X509_NAME) *ca_sk = sk_X509_NAME_new(ca_dn_cmp);
2267     X509_NAME *xn = NULL;
2268     PACKET cadns;
2269
2270     if (ca_sk == NULL) {
2271         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_PARSE_CA_NAMES,
2272                  ERR_R_MALLOC_FAILURE);
2273         goto err;
2274     }
2275     /* get the CA RDNs */
2276     if (!PACKET_get_length_prefixed_2(pkt, &cadns)) {
2277         SSLfatal(s, SSL_AD_DECODE_ERROR,SSL_F_PARSE_CA_NAMES,
2278                  SSL_R_LENGTH_MISMATCH);
2279         goto err;
2280     }
2281
2282     while (PACKET_remaining(&cadns)) {
2283         const unsigned char *namestart, *namebytes;
2284         unsigned int name_len;
2285
2286         if (!PACKET_get_net_2(&cadns, &name_len)
2287             || !PACKET_get_bytes(&cadns, &namebytes, name_len)) {
2288             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_PARSE_CA_NAMES,
2289                      SSL_R_LENGTH_MISMATCH);
2290             goto err;
2291         }
2292
2293         namestart = namebytes;
2294         if ((xn = d2i_X509_NAME(NULL, &namebytes, name_len)) == NULL) {
2295             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_PARSE_CA_NAMES,
2296                      ERR_R_ASN1_LIB);
2297             goto err;
2298         }
2299         if (namebytes != (namestart + name_len)) {
2300             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_PARSE_CA_NAMES,
2301                      SSL_R_CA_DN_LENGTH_MISMATCH);
2302             goto err;
2303         }
2304
2305         if (!sk_X509_NAME_push(ca_sk, xn)) {
2306             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_PARSE_CA_NAMES,
2307                      ERR_R_MALLOC_FAILURE);
2308             goto err;
2309         }
2310         xn = NULL;
2311     }
2312
2313     sk_X509_NAME_pop_free(s->s3.tmp.peer_ca_names, X509_NAME_free);
2314     s->s3.tmp.peer_ca_names = ca_sk;
2315
2316     return 1;
2317
2318  err:
2319     sk_X509_NAME_pop_free(ca_sk, X509_NAME_free);
2320     X509_NAME_free(xn);
2321     return 0;
2322 }
2323
2324 const STACK_OF(X509_NAME) *get_ca_names(SSL *s)
2325 {
2326     const STACK_OF(X509_NAME) *ca_sk = NULL;;
2327
2328     if (s->server) {
2329         ca_sk = SSL_get_client_CA_list(s);
2330         if (ca_sk != NULL && sk_X509_NAME_num(ca_sk) == 0)
2331             ca_sk = NULL;
2332     }
2333
2334     if (ca_sk == NULL)
2335         ca_sk = SSL_get0_CA_list(s);
2336
2337     return ca_sk;
2338 }
2339
2340 int construct_ca_names(SSL *s, const STACK_OF(X509_NAME) *ca_sk, WPACKET *pkt)
2341 {
2342     /* Start sub-packet for client CA list */
2343     if (!WPACKET_start_sub_packet_u16(pkt)) {
2344         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_CONSTRUCT_CA_NAMES,
2345                  ERR_R_INTERNAL_ERROR);
2346         return 0;
2347     }
2348
2349     if ((ca_sk != NULL) && !(s->options & SSL_OP_DISABLE_TLSEXT_CA_NAMES)) {
2350         int i;
2351
2352         for (i = 0; i < sk_X509_NAME_num(ca_sk); i++) {
2353             unsigned char *namebytes;
2354             X509_NAME *name = sk_X509_NAME_value(ca_sk, i);
2355             int namelen;
2356
2357             if (name == NULL
2358                     || (namelen = i2d_X509_NAME(name, NULL)) < 0
2359                     || !WPACKET_sub_allocate_bytes_u16(pkt, namelen,
2360                                                        &namebytes)
2361                     || i2d_X509_NAME(name, &namebytes) != namelen) {
2362                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_CONSTRUCT_CA_NAMES,
2363                          ERR_R_INTERNAL_ERROR);
2364                 return 0;
2365             }
2366         }
2367     }
2368
2369     if (!WPACKET_close(pkt)) {
2370         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_CONSTRUCT_CA_NAMES,
2371                  ERR_R_INTERNAL_ERROR);
2372         return 0;
2373     }
2374
2375     return 1;
2376 }
2377
2378 /* Create a buffer containing data to be signed for server key exchange */
2379 size_t construct_key_exchange_tbs(SSL *s, unsigned char **ptbs,
2380                                   const void *param, size_t paramlen)
2381 {
2382     size_t tbslen = 2 * SSL3_RANDOM_SIZE + paramlen;
2383     unsigned char *tbs = OPENSSL_malloc(tbslen);
2384
2385     if (tbs == NULL) {
2386         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_CONSTRUCT_KEY_EXCHANGE_TBS,
2387                  ERR_R_MALLOC_FAILURE);
2388         return 0;
2389     }
2390     memcpy(tbs, s->s3.client_random, SSL3_RANDOM_SIZE);
2391     memcpy(tbs + SSL3_RANDOM_SIZE, s->s3.server_random, SSL3_RANDOM_SIZE);
2392
2393     memcpy(tbs + SSL3_RANDOM_SIZE * 2, param, paramlen);
2394
2395     *ptbs = tbs;
2396     return tbslen;
2397 }
2398
2399 /*
2400  * Saves the current handshake digest for Post-Handshake Auth,
2401  * Done after ClientFinished is processed, done exactly once
2402  */
2403 int tls13_save_handshake_digest_for_pha(SSL *s)
2404 {
2405     if (s->pha_dgst == NULL) {
2406         if (!ssl3_digest_cached_records(s, 1))
2407             /* SSLfatal() already called */
2408             return 0;
2409
2410         s->pha_dgst = EVP_MD_CTX_new();
2411         if (s->pha_dgst == NULL) {
2412             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2413                      SSL_F_TLS13_SAVE_HANDSHAKE_DIGEST_FOR_PHA,
2414                      ERR_R_INTERNAL_ERROR);
2415             return 0;
2416         }
2417         if (!EVP_MD_CTX_copy_ex(s->pha_dgst,
2418                                 s->s3.handshake_dgst)) {
2419             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2420                      SSL_F_TLS13_SAVE_HANDSHAKE_DIGEST_FOR_PHA,
2421                      ERR_R_INTERNAL_ERROR);
2422             return 0;
2423         }
2424     }
2425     return 1;
2426 }
2427
2428 /*
2429  * Restores the Post-Handshake Auth handshake digest
2430  * Done just before sending/processing the Cert Request
2431  */
2432 int tls13_restore_handshake_digest_for_pha(SSL *s)
2433 {
2434     if (s->pha_dgst == NULL) {
2435         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2436                  SSL_F_TLS13_RESTORE_HANDSHAKE_DIGEST_FOR_PHA,
2437                  ERR_R_INTERNAL_ERROR);
2438         return 0;
2439     }
2440     if (!EVP_MD_CTX_copy_ex(s->s3.handshake_dgst,
2441                             s->pha_dgst)) {
2442         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2443                  SSL_F_TLS13_RESTORE_HANDSHAKE_DIGEST_FOR_PHA,
2444                  ERR_R_INTERNAL_ERROR);
2445         return 0;
2446     }
2447     return 1;
2448 }