ssl_server_socket_impl.cc | Explore in Territory

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40284755): Remove this and spanify to fix the errors.
#pragma allow_unsafe_buffers
#endif

#include "net/socket/ssl_server_socket_impl.h"

#include <memory>
#include <optional>
#include <string_view>
#include <utility>

#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/logging.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/strings/string_util.h"
#include "crypto/openssl_util.h"
#include "crypto/rsa_private_key.h"
#include "net/base/completion_once_callback.h"
#include "net/base/net_errors.h"
#include "net/cert/cert_verify_result.h"
#include "net/cert/client_cert_verifier.h"
#include "net/cert/x509_util.h"
#include "net/log/net_log_event_type.h"
#include "net/log/net_log_with_source.h"
#include "net/socket/socket_bio_adapter.h"
#include "net/ssl/openssl_ssl_util.h"
#include "net/ssl/ssl_connection_status_flags.h"
#include "net/ssl/ssl_info.h"
#include "net/ssl/ssl_private_key.h"
#include "net/traffic_annotation/network_traffic_annotation.h"
#include "third_party/boringssl/src/include/openssl/bytestring.h"
#include "third_party/boringssl/src/include/openssl/err.h"
#include "third_party/boringssl/src/include/openssl/pool.h"
#include "third_party/boringssl/src/include/openssl/ssl.h"

#define GotoState(s) …

namespace net {

namespace {

// This constant can be any non-negative/non-zero value (eg: it does not
// overlap with any value of the net::Error range, including net::OK).
const int kSSLServerSocketNoPendingResult = …;

}  // namespace

class SSLServerContextImpl::SocketImpl : public SSLServerSocket,
                                         public SocketBIOAdapter::Delegate { … };

SSLServerContextImpl::SocketImpl::SocketImpl(
    SSLServerContextImpl* context,
    std::unique_ptr<StreamSocket> transport_socket)
    : … { … }

SSLServerContextImpl::SocketImpl::~SocketImpl() { … }

// static
const SSL_PRIVATE_KEY_METHOD
    SSLServerContextImpl::SocketImpl::kPrivateKeyMethod = …;

// static
ssl_private_key_result_t
SSLServerContextImpl::SocketImpl::PrivateKeySignCallback(SSL* ssl,
                                                         uint8_t* out,
                                                         size_t* out_len,
                                                         size_t max_out,
                                                         uint16_t algorithm,
                                                         const uint8_t* in,
                                                         size_t in_len) { … }

// static
ssl_private_key_result_t
SSLServerContextImpl::SocketImpl::PrivateKeyDecryptCallback(SSL* ssl,
                                                            uint8_t* out,
                                                            size_t* out_len,
                                                            size_t max_out,
                                                            const uint8_t* in,
                                                            size_t in_len) { … }

// static
ssl_private_key_result_t
SSLServerContextImpl::SocketImpl::PrivateKeyCompleteCallback(SSL* ssl,
                                                             uint8_t* out,
                                                             size_t* out_len,
                                                             size_t max_out) { … }

ssl_private_key_result_t
SSLServerContextImpl::SocketImpl::PrivateKeySignCallback(uint8_t* out,
                                                         size_t* out_len,
                                                         size_t max_out,
                                                         uint16_t algorithm,
                                                         const uint8_t* in,
                                                         size_t in_len) { … }

ssl_private_key_result_t
SSLServerContextImpl::SocketImpl::PrivateKeyCompleteCallback(uint8_t* out,
                                                             size_t* out_len,
                                                             size_t max_out) { … }

void SSLServerContextImpl::SocketImpl::OnPrivateKeyComplete(
    Error error,
    const std::vector<uint8_t>& signature) { … }

// static
int SSLServerContextImpl::SocketImpl::ALPNSelectCallback(SSL* ssl,
                                                         const uint8_t** out,
                                                         uint8_t* out_len,
                                                         const uint8_t* in,
                                                         unsigned in_len,
                                                         void* arg) { … }

ssl_select_cert_result_t
SSLServerContextImpl::SocketImpl::SelectCertificateCallback(
    const SSL_CLIENT_HELLO* client_hello) { … }

int SSLServerContextImpl::SocketImpl::Handshake(
    CompletionOnceCallback callback) { … }

int SSLServerContextImpl::SocketImpl::ExportKeyingMaterial(
    std::string_view label,
    bool has_context,
    std::string_view context,
    unsigned char* out,
    unsigned int outlen) { … }

int SSLServerContextImpl::SocketImpl::Read(IOBuffer* buf,
                                           int buf_len,
                                           CompletionOnceCallback callback) { … }

int SSLServerContextImpl::SocketImpl::ReadIfReady(
    IOBuffer* buf,
    int buf_len,
    CompletionOnceCallback callback) { … }

int SSLServerContextImpl::SocketImpl::CancelReadIfReady() { … }

int SSLServerContextImpl::SocketImpl::Write(
    IOBuffer* buf,
    int buf_len,
    CompletionOnceCallback callback,
    const NetworkTrafficAnnotationTag& traffic_annotation) { … }

int SSLServerContextImpl::SocketImpl::SetReceiveBufferSize(int32_t size) { … }

int SSLServerContextImpl::SocketImpl::SetSendBufferSize(int32_t size) { … }

int SSLServerContextImpl::SocketImpl::Connect(CompletionOnceCallback callback) { … }

void SSLServerContextImpl::SocketImpl::Disconnect() { … }

bool SSLServerContextImpl::SocketImpl::IsConnected() const { … }

bool SSLServerContextImpl::SocketImpl::IsConnectedAndIdle() const { … }

int SSLServerContextImpl::SocketImpl::GetPeerAddress(
    IPEndPoint* address) const { … }

int SSLServerContextImpl::SocketImpl::GetLocalAddress(
    IPEndPoint* address) const { … }

const NetLogWithSource& SSLServerContextImpl::SocketImpl::NetLog() const { … }

bool SSLServerContextImpl::SocketImpl::WasEverUsed() const { … }

NextProto SSLServerContextImpl::SocketImpl::GetNegotiatedProtocol() const { … }

std::optional<std::string_view>
SSLServerContextImpl::SocketImpl::GetPeerApplicationSettings() const { … }

bool SSLServerContextImpl::SocketImpl::GetSSLInfo(SSLInfo* ssl_info) { … }

int64_t SSLServerContextImpl::SocketImpl::GetTotalReceivedBytes() const { … }

void SSLServerContextImpl::SocketImpl::ApplySocketTag(const SocketTag& tag) { … }

void SSLServerContextImpl::SocketImpl::OnReadReady() { … }

void SSLServerContextImpl::SocketImpl::OnWriteReady() { … }

void SSLServerContextImpl::SocketImpl::OnHandshakeIOComplete(int result) { … }

int SSLServerContextImpl::SocketImpl::DoPayloadRead(IOBuffer* buf,
                                                    int buf_len) { … }

int SSLServerContextImpl::SocketImpl::DoPayloadWrite() { … }

int SSLServerContextImpl::SocketImpl::DoHandshakeLoop(int last_io_result) { … }

int SSLServerContextImpl::SocketImpl::DoHandshake() { … }

void SSLServerContextImpl::SocketImpl::DoHandshakeCallback(int rv) { … }

void SSLServerContextImpl::SocketImpl::DoReadCallback(int rv) { … }

void SSLServerContextImpl::SocketImpl::DoWriteCallback(int rv) { … }

int SSLServerContextImpl::SocketImpl::Init() { … }

SSLServerContextImpl::SocketImpl* SSLServerContextImpl::SocketImpl::FromSSL(
    SSL* ssl) { … }

// static
ssl_verify_result_t SSLServerContextImpl::SocketImpl::CertVerifyCallback(
    SSL* ssl,
    uint8_t* out_alert) { … }

ssl_verify_result_t SSLServerContextImpl::SocketImpl::CertVerifyCallbackImpl(
    uint8_t* out_alert) { … }

std::unique_ptr<SSLServerContext> CreateSSLServerContext(
    X509Certificate* certificate,
    EVP_PKEY* pkey,
    const SSLServerConfig& ssl_server_config) { … }

std::unique_ptr<SSLServerContext> CreateSSLServerContext(
    X509Certificate* certificate,
    const crypto::RSAPrivateKey& key,
    const SSLServerConfig& ssl_server_config) { … }

std::unique_ptr<SSLServerContext> CreateSSLServerContext(
    X509Certificate* certificate,
    scoped_refptr<SSLPrivateKey> key,
    const SSLServerConfig& ssl_config) { … }

SSLServerContextImpl::SSLServerContextImpl(
    X509Certificate* certificate,
    scoped_refptr<net::SSLPrivateKey> key,
    const SSLServerConfig& ssl_server_config)
    : … { … }

SSLServerContextImpl::SSLServerContextImpl(
    X509Certificate* certificate,
    EVP_PKEY* pkey,
    const SSLServerConfig& ssl_server_config)
    : … { … }

void SSLServerContextImpl::Init() { … }

SSLServerContextImpl::~SSLServerContextImpl() = default;

std::unique_ptr<SSLServerSocket> SSLServerContextImpl::CreateSSLServerSocket(
    std::unique_ptr<StreamSocket> socket) { … }

}  // namespace net
chromium/net/socket/ssl_server_socket_impl.cc
