ssl/statem/statem_lib.c

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