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