tls13_client.cc | Explore in Territory

/* Copyright (c) 2016, Google Inc.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */

#include <openssl/ssl.h>

#include <assert.h>
#include <limits.h>
#include <string.h>

#include <utility>

#include <openssl/bytestring.h>
#include <openssl/digest.h>
#include <openssl/err.h>
#include <openssl/mem.h>
#include <openssl/sha.h>
#include <openssl/stack.h>

#include "../crypto/internal.h"
#include "internal.h"


BSSL_NAMESPACE_BEGIN

enum client_hs_state_t { … };

static const uint8_t kZeroes[EVP_MAX_MD_SIZE] = …;

// end_of_early_data closes the early data stream for |hs| and switches the
// encryption level to |level|. It returns true on success and false on error.
static bool close_early_data(SSL_HANDSHAKE *hs, ssl_encryption_level_t level) { … }

static bool parse_server_hello_tls13(const SSL_HANDSHAKE *hs,
                                     ParsedServerHello *out, uint8_t *out_alert,
                                     const SSLMessage &msg) { … }

static bool is_hello_retry_request(const ParsedServerHello &server_hello) { … }

static bool check_ech_confirmation(const SSL_HANDSHAKE *hs, bool *out_accepted,
                                   uint8_t *out_alert,
                                   const ParsedServerHello &server_hello) { … }

static enum ssl_hs_wait_t do_read_hello_retry_request(SSL_HANDSHAKE *hs) { … }

static enum ssl_hs_wait_t do_send_second_client_hello(SSL_HANDSHAKE *hs) { … }

static enum ssl_hs_wait_t do_read_server_hello(SSL_HANDSHAKE *hs) { … }

static enum ssl_hs_wait_t do_read_encrypted_extensions(SSL_HANDSHAKE *hs) { … }

static enum ssl_hs_wait_t do_read_certificate_request(SSL_HANDSHAKE *hs) { … }

static enum ssl_hs_wait_t do_read_server_certificate(SSL_HANDSHAKE *hs) { … }

static enum ssl_hs_wait_t do_read_server_certificate_verify(SSL_HANDSHAKE *hs) { … }

static enum ssl_hs_wait_t do_server_certificate_reverify(SSL_HANDSHAKE *hs) { … }

static enum ssl_hs_wait_t do_read_server_finished(SSL_HANDSHAKE *hs) { … }

static enum ssl_hs_wait_t do_send_end_of_early_data(SSL_HANDSHAKE *hs) { … }

static enum ssl_hs_wait_t do_send_client_encrypted_extensions(
    SSL_HANDSHAKE *hs) { … }

static bool check_credential(SSL_HANDSHAKE *hs, const SSL_CREDENTIAL *cred,
                             uint16_t *out_sigalg) { … }

static enum ssl_hs_wait_t do_send_client_certificate(SSL_HANDSHAKE *hs) { … }

static enum ssl_hs_wait_t do_send_client_certificate_verify(SSL_HANDSHAKE *hs) { … }

static enum ssl_hs_wait_t do_complete_second_flight(SSL_HANDSHAKE *hs) { … }

enum ssl_hs_wait_t tls13_client_handshake(SSL_HANDSHAKE *hs) { … }

const char *tls13_client_handshake_state(SSL_HANDSHAKE *hs) { … }

bool tls13_process_new_session_ticket(SSL *ssl, const SSLMessage &msg) { … }

UniquePtr<SSL_SESSION> tls13_create_session_with_ticket(SSL *ssl, CBS *body) { … }

BSSL_NAMESPACE_END
chromium/third_party/boringssl/src/ssl/tls13_client.cc
