liamwhite
2 years ago
committed by
GitHub
GitHub
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
23 changed files with 2413 additions and 282 deletions
-
16CMakeLists.txt
-
16src/common/socket_types.h
-
18src/core/CMakeLists.txt
-
120src/core/hle/service/sockets/bsd.cpp
-
13src/core/hle/service/sockets/bsd.h
-
58src/core/hle/service/sockets/nsd.cpp
-
4src/core/hle/service/sockets/nsd.h
-
388src/core/hle/service/sockets/sfdnsres.cpp
-
3src/core/hle/service/sockets/sfdnsres.h
-
33src/core/hle/service/sockets/sockets.h
-
114src/core/hle/service/sockets/sockets_translate.cpp
-
17src/core/hle/service/sockets/sockets_translate.h
-
353src/core/hle/service/ssl/ssl.cpp
-
45src/core/hle/service/ssl/ssl_backend.h
-
16src/core/hle/service/ssl/ssl_backend_none.cpp
-
351src/core/hle/service/ssl/ssl_backend_openssl.cpp
-
543src/core/hle/service/ssl/ssl_backend_schannel.cpp
-
219src/core/hle/service/ssl/ssl_backend_securetransport.cpp
-
286src/core/internal_network/network.cpp
-
36src/core/internal_network/network.h
-
22src/core/internal_network/socket_proxy.cpp
-
8src/core/internal_network/socket_proxy.h
-
16src/core/internal_network/sockets.h
@ -0,0 +1,45 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project |
||||
|
// SPDX-License-Identifier: GPL-2.0-or-later |
||||
|
|
||||
|
#pragma once |
||||
|
|
||||
|
#include "core/hle/result.h" |
||||
|
|
||||
|
#include "common/common_types.h" |
||||
|
|
||||
|
#include <memory> |
||||
|
#include <span> |
||||
|
#include <string> |
||||
|
#include <vector> |
||||
|
|
||||
|
namespace Network { |
||||
|
class SocketBase; |
||||
|
} |
||||
|
|
||||
|
namespace Service::SSL { |
||||
|
|
||||
|
constexpr Result ResultNoSocket{ErrorModule::SSLSrv, 103}; |
||||
|
constexpr Result ResultInvalidSocket{ErrorModule::SSLSrv, 106}; |
||||
|
constexpr Result ResultTimeout{ErrorModule::SSLSrv, 205}; |
||||
|
constexpr Result ResultInternalError{ErrorModule::SSLSrv, 999}; // made up |
||||
|
|
||||
|
// ResultWouldBlock is returned from Read and Write, and oddly, DoHandshake, |
||||
|
// with no way in the latter case to distinguish whether the client should poll |
||||
|
// for read or write. The one official client I've seen handles this by always |
||||
|
// polling for read (with a timeout). |
||||
|
constexpr Result ResultWouldBlock{ErrorModule::SSLSrv, 204}; |
||||
|
|
||||
|
class SSLConnectionBackend { |
||||
|
public: |
||||
|
virtual ~SSLConnectionBackend() {} |
||||
|
virtual void SetSocket(std::shared_ptr<Network::SocketBase> socket) = 0; |
||||
|
virtual Result SetHostName(const std::string& hostname) = 0; |
||||
|
virtual Result DoHandshake() = 0; |
||||
|
virtual ResultVal<size_t> Read(std::span<u8> data) = 0; |
||||
|
virtual ResultVal<size_t> Write(std::span<const u8> data) = 0; |
||||
|
virtual ResultVal<std::vector<std::vector<u8>>> GetServerCerts() = 0; |
||||
|
}; |
||||
|
|
||||
|
ResultVal<std::unique_ptr<SSLConnectionBackend>> CreateSSLConnectionBackend(); |
||||
|
|
||||
|
} // namespace Service::SSL |
||||
@ -0,0 +1,16 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
|
||||
|
#include "core/hle/service/ssl/ssl_backend.h"
|
||||
|
|
||||
|
#include "common/logging/log.h"
|
||||
|
|
||||
|
namespace Service::SSL { |
||||
|
|
||||
|
ResultVal<std::unique_ptr<SSLConnectionBackend>> CreateSSLConnectionBackend() { |
||||
|
LOG_ERROR(Service_SSL, |
||||
|
"Can't create SSL connection because no SSL backend is available on this platform"); |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
|
||||
|
} // namespace Service::SSL
|
||||
@ -0,0 +1,351 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
|
||||
|
#include "core/hle/service/ssl/ssl_backend.h"
|
||||
|
#include "core/internal_network/network.h"
|
||||
|
#include "core/internal_network/sockets.h"
|
||||
|
|
||||
|
#include "common/fs/file.h"
|
||||
|
#include "common/hex_util.h"
|
||||
|
#include "common/string_util.h"
|
||||
|
|
||||
|
#include <mutex>
|
||||
|
|
||||
|
#include <openssl/bio.h>
|
||||
|
#include <openssl/err.h>
|
||||
|
#include <openssl/ssl.h>
|
||||
|
#include <openssl/x509.h>
|
||||
|
|
||||
|
using namespace Common::FS; |
||||
|
|
||||
|
namespace Service::SSL { |
||||
|
|
||||
|
// Import OpenSSL's `SSL` type into the namespace. This is needed because the
|
||||
|
// namespace is also named `SSL`.
|
||||
|
using ::SSL; |
||||
|
|
||||
|
namespace { |
||||
|
|
||||
|
std::once_flag one_time_init_flag; |
||||
|
bool one_time_init_success = false; |
||||
|
|
||||
|
SSL_CTX* ssl_ctx; |
||||
|
IOFile key_log_file; // only open if SSLKEYLOGFILE set in environment
|
||||
|
BIO_METHOD* bio_meth; |
||||
|
|
||||
|
Result CheckOpenSSLErrors(); |
||||
|
void OneTimeInit(); |
||||
|
void OneTimeInitLogFile(); |
||||
|
bool OneTimeInitBIO(); |
||||
|
|
||||
|
} // namespace
|
||||
|
|
||||
|
class SSLConnectionBackendOpenSSL final : public SSLConnectionBackend { |
||||
|
public: |
||||
|
Result Init() { |
||||
|
std::call_once(one_time_init_flag, OneTimeInit); |
||||
|
|
||||
|
if (!one_time_init_success) { |
||||
|
LOG_ERROR(Service_SSL, |
||||
|
"Can't create SSL connection because OpenSSL one-time initialization failed"); |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
|
||||
|
ssl = SSL_new(ssl_ctx); |
||||
|
if (!ssl) { |
||||
|
LOG_ERROR(Service_SSL, "SSL_new failed"); |
||||
|
return CheckOpenSSLErrors(); |
||||
|
} |
||||
|
|
||||
|
SSL_set_connect_state(ssl); |
||||
|
|
||||
|
bio = BIO_new(bio_meth); |
||||
|
if (!bio) { |
||||
|
LOG_ERROR(Service_SSL, "BIO_new failed"); |
||||
|
return CheckOpenSSLErrors(); |
||||
|
} |
||||
|
|
||||
|
BIO_set_data(bio, this); |
||||
|
BIO_set_init(bio, 1); |
||||
|
SSL_set_bio(ssl, bio, bio); |
||||
|
|
||||
|
return ResultSuccess; |
||||
|
} |
||||
|
|
||||
|
void SetSocket(std::shared_ptr<Network::SocketBase> socket_in) override { |
||||
|
socket = std::move(socket_in); |
||||
|
} |
||||
|
|
||||
|
Result SetHostName(const std::string& hostname) override { |
||||
|
if (!SSL_set1_host(ssl, hostname.c_str())) { // hostname for verification
|
||||
|
LOG_ERROR(Service_SSL, "SSL_set1_host({}) failed", hostname); |
||||
|
return CheckOpenSSLErrors(); |
||||
|
} |
||||
|
if (!SSL_set_tlsext_host_name(ssl, hostname.c_str())) { // hostname for SNI
|
||||
|
LOG_ERROR(Service_SSL, "SSL_set_tlsext_host_name({}) failed", hostname); |
||||
|
return CheckOpenSSLErrors(); |
||||
|
} |
||||
|
return ResultSuccess; |
||||
|
} |
||||
|
|
||||
|
Result DoHandshake() override { |
||||
|
SSL_set_verify_result(ssl, X509_V_OK); |
||||
|
const int ret = SSL_do_handshake(ssl); |
||||
|
const long verify_result = SSL_get_verify_result(ssl); |
||||
|
if (verify_result != X509_V_OK) { |
||||
|
LOG_ERROR(Service_SSL, "SSL cert verification failed because: {}", |
||||
|
X509_verify_cert_error_string(verify_result)); |
||||
|
return CheckOpenSSLErrors(); |
||||
|
} |
||||
|
if (ret <= 0) { |
||||
|
const int ssl_err = SSL_get_error(ssl, ret); |
||||
|
if (ssl_err == SSL_ERROR_ZERO_RETURN || |
||||
|
(ssl_err == SSL_ERROR_SYSCALL && got_read_eof)) { |
||||
|
LOG_ERROR(Service_SSL, "SSL handshake failed because server hung up"); |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
} |
||||
|
return HandleReturn("SSL_do_handshake", 0, ret).Code(); |
||||
|
} |
||||
|
|
||||
|
ResultVal<size_t> Read(std::span<u8> data) override { |
||||
|
size_t actual; |
||||
|
const int ret = SSL_read_ex(ssl, data.data(), data.size(), &actual); |
||||
|
return HandleReturn("SSL_read_ex", actual, ret); |
||||
|
} |
||||
|
|
||||
|
ResultVal<size_t> Write(std::span<const u8> data) override { |
||||
|
size_t actual; |
||||
|
const int ret = SSL_write_ex(ssl, data.data(), data.size(), &actual); |
||||
|
return HandleReturn("SSL_write_ex", actual, ret); |
||||
|
} |
||||
|
|
||||
|
ResultVal<size_t> HandleReturn(const char* what, size_t actual, int ret) { |
||||
|
const int ssl_err = SSL_get_error(ssl, ret); |
||||
|
CheckOpenSSLErrors(); |
||||
|
switch (ssl_err) { |
||||
|
case SSL_ERROR_NONE: |
||||
|
return actual; |
||||
|
case SSL_ERROR_ZERO_RETURN: |
||||
|
LOG_DEBUG(Service_SSL, "{} => SSL_ERROR_ZERO_RETURN", what); |
||||
|
// DoHandshake special-cases this, but for Read and Write:
|
||||
|
return size_t(0); |
||||
|
case SSL_ERROR_WANT_READ: |
||||
|
LOG_DEBUG(Service_SSL, "{} => SSL_ERROR_WANT_READ", what); |
||||
|
return ResultWouldBlock; |
||||
|
case SSL_ERROR_WANT_WRITE: |
||||
|
LOG_DEBUG(Service_SSL, "{} => SSL_ERROR_WANT_WRITE", what); |
||||
|
return ResultWouldBlock; |
||||
|
default: |
||||
|
if (ssl_err == SSL_ERROR_SYSCALL && got_read_eof) { |
||||
|
LOG_DEBUG(Service_SSL, "{} => SSL_ERROR_SYSCALL because server hung up", what); |
||||
|
return size_t(0); |
||||
|
} |
||||
|
LOG_ERROR(Service_SSL, "{} => other SSL_get_error return value {}", what, ssl_err); |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
ResultVal<std::vector<std::vector<u8>>> GetServerCerts() override { |
||||
|
STACK_OF(X509)* chain = SSL_get_peer_cert_chain(ssl); |
||||
|
if (!chain) { |
||||
|
LOG_ERROR(Service_SSL, "SSL_get_peer_cert_chain returned nullptr"); |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
std::vector<std::vector<u8>> ret; |
||||
|
int count = sk_X509_num(chain); |
||||
|
ASSERT(count >= 0); |
||||
|
for (int i = 0; i < count; i++) { |
||||
|
X509* x509 = sk_X509_value(chain, i); |
||||
|
ASSERT_OR_EXECUTE(x509 != nullptr, { continue; }); |
||||
|
unsigned char* buf = nullptr; |
||||
|
int len = i2d_X509(x509, &buf); |
||||
|
ASSERT_OR_EXECUTE(len >= 0 && buf, { continue; }); |
||||
|
ret.emplace_back(buf, buf + len); |
||||
|
OPENSSL_free(buf); |
||||
|
} |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
~SSLConnectionBackendOpenSSL() { |
||||
|
// these are null-tolerant:
|
||||
|
SSL_free(ssl); |
||||
|
BIO_free(bio); |
||||
|
} |
||||
|
|
||||
|
static void KeyLogCallback(const SSL* ssl, const char* line) { |
||||
|
std::string str(line); |
||||
|
str.push_back('\n'); |
||||
|
// Do this in a single WriteString for atomicity if multiple instances
|
||||
|
// are running on different threads (though that can't currently
|
||||
|
// happen).
|
||||
|
if (key_log_file.WriteString(str) != str.size() || !key_log_file.Flush()) { |
||||
|
LOG_CRITICAL(Service_SSL, "Failed to write to SSLKEYLOGFILE"); |
||||
|
} |
||||
|
LOG_DEBUG(Service_SSL, "Wrote to SSLKEYLOGFILE: {}", line); |
||||
|
} |
||||
|
|
||||
|
static int WriteCallback(BIO* bio, const char* buf, size_t len, size_t* actual_p) { |
||||
|
auto self = static_cast<SSLConnectionBackendOpenSSL*>(BIO_get_data(bio)); |
||||
|
ASSERT_OR_EXECUTE_MSG( |
||||
|
self->socket, { return 0; }, "OpenSSL asked to send but we have no socket"); |
||||
|
BIO_clear_retry_flags(bio); |
||||
|
auto [actual, err] = self->socket->Send({reinterpret_cast<const u8*>(buf), len}, 0); |
||||
|
switch (err) { |
||||
|
case Network::Errno::SUCCESS: |
||||
|
*actual_p = actual; |
||||
|
return 1; |
||||
|
case Network::Errno::AGAIN: |
||||
|
BIO_set_flags(bio, BIO_FLAGS_WRITE | BIO_FLAGS_SHOULD_RETRY); |
||||
|
return 0; |
||||
|
default: |
||||
|
LOG_ERROR(Service_SSL, "Socket send returned Network::Errno {}", err); |
||||
|
return -1; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
static int ReadCallback(BIO* bio, char* buf, size_t len, size_t* actual_p) { |
||||
|
auto self = static_cast<SSLConnectionBackendOpenSSL*>(BIO_get_data(bio)); |
||||
|
ASSERT_OR_EXECUTE_MSG( |
||||
|
self->socket, { return 0; }, "OpenSSL asked to recv but we have no socket"); |
||||
|
BIO_clear_retry_flags(bio); |
||||
|
auto [actual, err] = self->socket->Recv(0, {reinterpret_cast<u8*>(buf), len}); |
||||
|
switch (err) { |
||||
|
case Network::Errno::SUCCESS: |
||||
|
*actual_p = actual; |
||||
|
if (actual == 0) { |
||||
|
self->got_read_eof = true; |
||||
|
} |
||||
|
return actual ? 1 : 0; |
||||
|
case Network::Errno::AGAIN: |
||||
|
BIO_set_flags(bio, BIO_FLAGS_READ | BIO_FLAGS_SHOULD_RETRY); |
||||
|
return 0; |
||||
|
default: |
||||
|
LOG_ERROR(Service_SSL, "Socket recv returned Network::Errno {}", err); |
||||
|
return -1; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
static long CtrlCallback(BIO* bio, int cmd, long l_arg, void* p_arg) { |
||||
|
switch (cmd) { |
||||
|
case BIO_CTRL_FLUSH: |
||||
|
// Nothing to flush.
|
||||
|
return 1; |
||||
|
case BIO_CTRL_PUSH: |
||||
|
case BIO_CTRL_POP: |
||||
|
#ifdef BIO_CTRL_GET_KTLS_SEND
|
||||
|
case BIO_CTRL_GET_KTLS_SEND: |
||||
|
case BIO_CTRL_GET_KTLS_RECV: |
||||
|
#endif
|
||||
|
// We don't support these operations, but don't bother logging them
|
||||
|
// as they're nothing unusual.
|
||||
|
return 0; |
||||
|
default: |
||||
|
LOG_DEBUG(Service_SSL, "OpenSSL BIO got ctrl({}, {}, {})", cmd, l_arg, p_arg); |
||||
|
return 0; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
SSL* ssl = nullptr; |
||||
|
BIO* bio = nullptr; |
||||
|
bool got_read_eof = false; |
||||
|
|
||||
|
std::shared_ptr<Network::SocketBase> socket; |
||||
|
}; |
||||
|
|
||||
|
ResultVal<std::unique_ptr<SSLConnectionBackend>> CreateSSLConnectionBackend() { |
||||
|
auto conn = std::make_unique<SSLConnectionBackendOpenSSL>(); |
||||
|
const Result res = conn->Init(); |
||||
|
if (res.IsFailure()) { |
||||
|
return res; |
||||
|
} |
||||
|
return conn; |
||||
|
} |
||||
|
|
||||
|
namespace { |
||||
|
|
||||
|
Result CheckOpenSSLErrors() { |
||||
|
unsigned long rc; |
||||
|
const char* file; |
||||
|
int line; |
||||
|
const char* func; |
||||
|
const char* data; |
||||
|
int flags; |
||||
|
#if OPENSSL_VERSION_NUMBER >= 0x30000000L
|
||||
|
while ((rc = ERR_get_error_all(&file, &line, &func, &data, &flags))) |
||||
|
#else
|
||||
|
// Can't get function names from OpenSSL on this version, so use mine:
|
||||
|
func = __func__; |
||||
|
while ((rc = ERR_get_error_line_data(&file, &line, &data, &flags))) |
||||
|
#endif
|
||||
|
{ |
||||
|
std::string msg; |
||||
|
msg.resize(1024, '\0'); |
||||
|
ERR_error_string_n(rc, msg.data(), msg.size()); |
||||
|
msg.resize(strlen(msg.data()), '\0'); |
||||
|
if (flags & ERR_TXT_STRING) { |
||||
|
msg.append(" | "); |
||||
|
msg.append(data); |
||||
|
} |
||||
|
Common::Log::FmtLogMessage(Common::Log::Class::Service_SSL, Common::Log::Level::Error, |
||||
|
Common::Log::TrimSourcePath(file), line, func, "OpenSSL: {}", |
||||
|
msg); |
||||
|
} |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
|
||||
|
void OneTimeInit() { |
||||
|
ssl_ctx = SSL_CTX_new(TLS_client_method()); |
||||
|
if (!ssl_ctx) { |
||||
|
LOG_ERROR(Service_SSL, "SSL_CTX_new failed"); |
||||
|
CheckOpenSSLErrors(); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
SSL_CTX_set_verify(ssl_ctx, SSL_VERIFY_PEER, nullptr); |
||||
|
|
||||
|
if (!SSL_CTX_set_default_verify_paths(ssl_ctx)) { |
||||
|
LOG_ERROR(Service_SSL, "SSL_CTX_set_default_verify_paths failed"); |
||||
|
CheckOpenSSLErrors(); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
OneTimeInitLogFile(); |
||||
|
|
||||
|
if (!OneTimeInitBIO()) { |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
one_time_init_success = true; |
||||
|
} |
||||
|
|
||||
|
void OneTimeInitLogFile() { |
||||
|
const char* logfile = getenv("SSLKEYLOGFILE"); |
||||
|
if (logfile) { |
||||
|
key_log_file.Open(logfile, FileAccessMode::Append, FileType::TextFile, |
||||
|
FileShareFlag::ShareWriteOnly); |
||||
|
if (key_log_file.IsOpen()) { |
||||
|
SSL_CTX_set_keylog_callback(ssl_ctx, &SSLConnectionBackendOpenSSL::KeyLogCallback); |
||||
|
} else { |
||||
|
LOG_CRITICAL(Service_SSL, |
||||
|
"SSLKEYLOGFILE was set but file could not be opened; not logging keys!"); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
bool OneTimeInitBIO() { |
||||
|
bio_meth = |
||||
|
BIO_meth_new(BIO_get_new_index() | BIO_TYPE_SOURCE_SINK, "SSLConnectionBackendOpenSSL"); |
||||
|
if (!bio_meth || |
||||
|
!BIO_meth_set_write_ex(bio_meth, &SSLConnectionBackendOpenSSL::WriteCallback) || |
||||
|
!BIO_meth_set_read_ex(bio_meth, &SSLConnectionBackendOpenSSL::ReadCallback) || |
||||
|
!BIO_meth_set_ctrl(bio_meth, &SSLConnectionBackendOpenSSL::CtrlCallback)) { |
||||
|
LOG_ERROR(Service_SSL, "Failed to create BIO_METHOD"); |
||||
|
return false; |
||||
|
} |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
} // namespace
|
||||
|
|
||||
|
} // namespace Service::SSL
|
||||
@ -0,0 +1,543 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
|
||||
|
#include "core/hle/service/ssl/ssl_backend.h"
|
||||
|
#include "core/internal_network/network.h"
|
||||
|
#include "core/internal_network/sockets.h"
|
||||
|
|
||||
|
#include "common/error.h"
|
||||
|
#include "common/fs/file.h"
|
||||
|
#include "common/hex_util.h"
|
||||
|
#include "common/string_util.h"
|
||||
|
|
||||
|
#include <mutex>
|
||||
|
|
||||
|
namespace { |
||||
|
|
||||
|
// These includes are inside the namespace to avoid a conflict on MinGW where
|
||||
|
// the headers define an enum containing Network and Service as enumerators
|
||||
|
// (which clash with the correspondingly named namespaces).
|
||||
|
#define SECURITY_WIN32
|
||||
|
#include <schnlsp.h>
|
||||
|
#include <security.h>
|
||||
|
|
||||
|
std::once_flag one_time_init_flag; |
||||
|
bool one_time_init_success = false; |
||||
|
|
||||
|
SCHANNEL_CRED schannel_cred{}; |
||||
|
CredHandle cred_handle; |
||||
|
|
||||
|
static void OneTimeInit() { |
||||
|
schannel_cred.dwVersion = SCHANNEL_CRED_VERSION; |
||||
|
schannel_cred.dwFlags = |
||||
|
SCH_USE_STRONG_CRYPTO | // don't allow insecure protocols
|
||||
|
SCH_CRED_AUTO_CRED_VALIDATION | // validate certs
|
||||
|
SCH_CRED_NO_DEFAULT_CREDS; // don't automatically present a client certificate
|
||||
|
// ^ I'm assuming that nobody would want to connect Yuzu to a
|
||||
|
// service that requires some OS-provided corporate client
|
||||
|
// certificate, and presenting one to some arbitrary server
|
||||
|
// might be a privacy concern? Who knows, though.
|
||||
|
|
||||
|
const SECURITY_STATUS ret = |
||||
|
AcquireCredentialsHandle(nullptr, const_cast<LPTSTR>(UNISP_NAME), SECPKG_CRED_OUTBOUND, |
||||
|
nullptr, &schannel_cred, nullptr, nullptr, &cred_handle, nullptr); |
||||
|
if (ret != SEC_E_OK) { |
||||
|
// SECURITY_STATUS codes are a type of HRESULT and can be used with NativeErrorToString.
|
||||
|
LOG_ERROR(Service_SSL, "AcquireCredentialsHandle failed: {}", |
||||
|
Common::NativeErrorToString(ret)); |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
if (getenv("SSLKEYLOGFILE")) { |
||||
|
LOG_CRITICAL(Service_SSL, "SSLKEYLOGFILE was set but Schannel does not support exporting " |
||||
|
"keys; not logging keys!"); |
||||
|
// Not fatal.
|
||||
|
} |
||||
|
|
||||
|
one_time_init_success = true; |
||||
|
} |
||||
|
|
||||
|
} // namespace
|
||||
|
|
||||
|
namespace Service::SSL { |
||||
|
|
||||
|
class SSLConnectionBackendSchannel final : public SSLConnectionBackend { |
||||
|
public: |
||||
|
Result Init() { |
||||
|
std::call_once(one_time_init_flag, OneTimeInit); |
||||
|
|
||||
|
if (!one_time_init_success) { |
||||
|
LOG_ERROR( |
||||
|
Service_SSL, |
||||
|
"Can't create SSL connection because Schannel one-time initialization failed"); |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
|
||||
|
return ResultSuccess; |
||||
|
} |
||||
|
|
||||
|
void SetSocket(std::shared_ptr<Network::SocketBase> socket_in) override { |
||||
|
socket = std::move(socket_in); |
||||
|
} |
||||
|
|
||||
|
Result SetHostName(const std::string& hostname_in) override { |
||||
|
hostname = hostname_in; |
||||
|
return ResultSuccess; |
||||
|
} |
||||
|
|
||||
|
Result DoHandshake() override { |
||||
|
while (1) { |
||||
|
Result r; |
||||
|
switch (handshake_state) { |
||||
|
case HandshakeState::Initial: |
||||
|
if ((r = FlushCiphertextWriteBuf()) != ResultSuccess || |
||||
|
(r = CallInitializeSecurityContext()) != ResultSuccess) { |
||||
|
return r; |
||||
|
} |
||||
|
// CallInitializeSecurityContext updated `handshake_state`.
|
||||
|
continue; |
||||
|
case HandshakeState::ContinueNeeded: |
||||
|
case HandshakeState::IncompleteMessage: |
||||
|
if ((r = FlushCiphertextWriteBuf()) != ResultSuccess || |
||||
|
(r = FillCiphertextReadBuf()) != ResultSuccess) { |
||||
|
return r; |
||||
|
} |
||||
|
if (ciphertext_read_buf.empty()) { |
||||
|
LOG_ERROR(Service_SSL, "SSL handshake failed because server hung up"); |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
if ((r = CallInitializeSecurityContext()) != ResultSuccess) { |
||||
|
return r; |
||||
|
} |
||||
|
// CallInitializeSecurityContext updated `handshake_state`.
|
||||
|
continue; |
||||
|
case HandshakeState::DoneAfterFlush: |
||||
|
if ((r = FlushCiphertextWriteBuf()) != ResultSuccess) { |
||||
|
return r; |
||||
|
} |
||||
|
handshake_state = HandshakeState::Connected; |
||||
|
return ResultSuccess; |
||||
|
case HandshakeState::Connected: |
||||
|
LOG_ERROR(Service_SSL, "Called DoHandshake but we already handshook"); |
||||
|
return ResultInternalError; |
||||
|
case HandshakeState::Error: |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
Result FillCiphertextReadBuf() { |
||||
|
const size_t fill_size = read_buf_fill_size ? read_buf_fill_size : 4096; |
||||
|
read_buf_fill_size = 0; |
||||
|
// This unnecessarily zeroes the buffer; oh well.
|
||||
|
const size_t offset = ciphertext_read_buf.size(); |
||||
|
ASSERT_OR_EXECUTE(offset + fill_size >= offset, { return ResultInternalError; }); |
||||
|
ciphertext_read_buf.resize(offset + fill_size, 0); |
||||
|
const auto read_span = std::span(ciphertext_read_buf).subspan(offset, fill_size); |
||||
|
const auto [actual, err] = socket->Recv(0, read_span); |
||||
|
switch (err) { |
||||
|
case Network::Errno::SUCCESS: |
||||
|
ASSERT(static_cast<size_t>(actual) <= fill_size); |
||||
|
ciphertext_read_buf.resize(offset + actual); |
||||
|
return ResultSuccess; |
||||
|
case Network::Errno::AGAIN: |
||||
|
ciphertext_read_buf.resize(offset); |
||||
|
return ResultWouldBlock; |
||||
|
default: |
||||
|
ciphertext_read_buf.resize(offset); |
||||
|
LOG_ERROR(Service_SSL, "Socket recv returned Network::Errno {}", err); |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Returns success if the write buffer has been completely emptied.
|
||||
|
Result FlushCiphertextWriteBuf() { |
||||
|
while (!ciphertext_write_buf.empty()) { |
||||
|
const auto [actual, err] = socket->Send(ciphertext_write_buf, 0); |
||||
|
switch (err) { |
||||
|
case Network::Errno::SUCCESS: |
||||
|
ASSERT(static_cast<size_t>(actual) <= ciphertext_write_buf.size()); |
||||
|
ciphertext_write_buf.erase(ciphertext_write_buf.begin(), |
||||
|
ciphertext_write_buf.begin() + actual); |
||||
|
break; |
||||
|
case Network::Errno::AGAIN: |
||||
|
return ResultWouldBlock; |
||||
|
default: |
||||
|
LOG_ERROR(Service_SSL, "Socket send returned Network::Errno {}", err); |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
} |
||||
|
return ResultSuccess; |
||||
|
} |
||||
|
|
||||
|
Result CallInitializeSecurityContext() { |
||||
|
const unsigned long req = ISC_REQ_ALLOCATE_MEMORY | ISC_REQ_CONFIDENTIALITY | |
||||
|
ISC_REQ_INTEGRITY | ISC_REQ_REPLAY_DETECT | |
||||
|
ISC_REQ_SEQUENCE_DETECT | ISC_REQ_STREAM | |
||||
|
ISC_REQ_USE_SUPPLIED_CREDS; |
||||
|
unsigned long attr; |
||||
|
// https://learn.microsoft.com/en-us/windows/win32/secauthn/initializesecuritycontext--schannel
|
||||
|
std::array<SecBuffer, 2> input_buffers{{ |
||||
|
// only used if `initial_call_done`
|
||||
|
{ |
||||
|
// [0]
|
||||
|
.cbBuffer = static_cast<unsigned long>(ciphertext_read_buf.size()), |
||||
|
.BufferType = SECBUFFER_TOKEN, |
||||
|
.pvBuffer = ciphertext_read_buf.data(), |
||||
|
}, |
||||
|
{ |
||||
|
// [1] (will be replaced by SECBUFFER_MISSING when SEC_E_INCOMPLETE_MESSAGE is
|
||||
|
// returned, or SECBUFFER_EXTRA when SEC_E_CONTINUE_NEEDED is returned if the
|
||||
|
// whole buffer wasn't used)
|
||||
|
.cbBuffer = 0, |
||||
|
.BufferType = SECBUFFER_EMPTY, |
||||
|
.pvBuffer = nullptr, |
||||
|
}, |
||||
|
}}; |
||||
|
std::array<SecBuffer, 2> output_buffers{{ |
||||
|
{ |
||||
|
.cbBuffer = 0, |
||||
|
.BufferType = SECBUFFER_TOKEN, |
||||
|
.pvBuffer = nullptr, |
||||
|
}, // [0]
|
||||
|
{ |
||||
|
.cbBuffer = 0, |
||||
|
.BufferType = SECBUFFER_ALERT, |
||||
|
.pvBuffer = nullptr, |
||||
|
}, // [1]
|
||||
|
}}; |
||||
|
SecBufferDesc input_desc{ |
||||
|
.ulVersion = SECBUFFER_VERSION, |
||||
|
.cBuffers = static_cast<unsigned long>(input_buffers.size()), |
||||
|
.pBuffers = input_buffers.data(), |
||||
|
}; |
||||
|
SecBufferDesc output_desc{ |
||||
|
.ulVersion = SECBUFFER_VERSION, |
||||
|
.cBuffers = static_cast<unsigned long>(output_buffers.size()), |
||||
|
.pBuffers = output_buffers.data(), |
||||
|
}; |
||||
|
ASSERT_OR_EXECUTE_MSG( |
||||
|
input_buffers[0].cbBuffer == ciphertext_read_buf.size(), |
||||
|
{ return ResultInternalError; }, "read buffer too large"); |
||||
|
|
||||
|
bool initial_call_done = handshake_state != HandshakeState::Initial; |
||||
|
if (initial_call_done) { |
||||
|
LOG_DEBUG(Service_SSL, "Passing {} bytes into InitializeSecurityContext", |
||||
|
ciphertext_read_buf.size()); |
||||
|
} |
||||
|
|
||||
|
const SECURITY_STATUS ret = |
||||
|
InitializeSecurityContextA(&cred_handle, initial_call_done ? &ctxt : nullptr, |
||||
|
// Caller ensured we have set a hostname:
|
||||
|
const_cast<char*>(hostname.value().c_str()), req, |
||||
|
0, // Reserved1
|
||||
|
0, // TargetDataRep not used with Schannel
|
||||
|
initial_call_done ? &input_desc : nullptr, |
||||
|
0, // Reserved2
|
||||
|
initial_call_done ? nullptr : &ctxt, &output_desc, &attr, |
||||
|
nullptr); // ptsExpiry
|
||||
|
|
||||
|
if (output_buffers[0].pvBuffer) { |
||||
|
const std::span span(static_cast<u8*>(output_buffers[0].pvBuffer), |
||||
|
output_buffers[0].cbBuffer); |
||||
|
ciphertext_write_buf.insert(ciphertext_write_buf.end(), span.begin(), span.end()); |
||||
|
FreeContextBuffer(output_buffers[0].pvBuffer); |
||||
|
} |
||||
|
|
||||
|
if (output_buffers[1].pvBuffer) { |
||||
|
const std::span span(static_cast<u8*>(output_buffers[1].pvBuffer), |
||||
|
output_buffers[1].cbBuffer); |
||||
|
// The documentation doesn't explain what format this data is in.
|
||||
|
LOG_DEBUG(Service_SSL, "Got a {}-byte alert buffer: {}", span.size(), |
||||
|
Common::HexToString(span)); |
||||
|
} |
||||
|
|
||||
|
switch (ret) { |
||||
|
case SEC_I_CONTINUE_NEEDED: |
||||
|
LOG_DEBUG(Service_SSL, "InitializeSecurityContext => SEC_I_CONTINUE_NEEDED"); |
||||
|
if (input_buffers[1].BufferType == SECBUFFER_EXTRA) { |
||||
|
LOG_DEBUG(Service_SSL, "EXTRA of size {}", input_buffers[1].cbBuffer); |
||||
|
ASSERT(input_buffers[1].cbBuffer <= ciphertext_read_buf.size()); |
||||
|
ciphertext_read_buf.erase(ciphertext_read_buf.begin(), |
||||
|
ciphertext_read_buf.end() - input_buffers[1].cbBuffer); |
||||
|
} else { |
||||
|
ASSERT(input_buffers[1].BufferType == SECBUFFER_EMPTY); |
||||
|
ciphertext_read_buf.clear(); |
||||
|
} |
||||
|
handshake_state = HandshakeState::ContinueNeeded; |
||||
|
return ResultSuccess; |
||||
|
case SEC_E_INCOMPLETE_MESSAGE: |
||||
|
LOG_DEBUG(Service_SSL, "InitializeSecurityContext => SEC_E_INCOMPLETE_MESSAGE"); |
||||
|
ASSERT(input_buffers[1].BufferType == SECBUFFER_MISSING); |
||||
|
read_buf_fill_size = input_buffers[1].cbBuffer; |
||||
|
handshake_state = HandshakeState::IncompleteMessage; |
||||
|
return ResultSuccess; |
||||
|
case SEC_E_OK: |
||||
|
LOG_DEBUG(Service_SSL, "InitializeSecurityContext => SEC_E_OK"); |
||||
|
ciphertext_read_buf.clear(); |
||||
|
handshake_state = HandshakeState::DoneAfterFlush; |
||||
|
return GrabStreamSizes(); |
||||
|
default: |
||||
|
LOG_ERROR(Service_SSL, |
||||
|
"InitializeSecurityContext failed (probably certificate/protocol issue): {}", |
||||
|
Common::NativeErrorToString(ret)); |
||||
|
handshake_state = HandshakeState::Error; |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
Result GrabStreamSizes() { |
||||
|
const SECURITY_STATUS ret = |
||||
|
QueryContextAttributes(&ctxt, SECPKG_ATTR_STREAM_SIZES, &stream_sizes); |
||||
|
if (ret != SEC_E_OK) { |
||||
|
LOG_ERROR(Service_SSL, "QueryContextAttributes(SECPKG_ATTR_STREAM_SIZES) failed: {}", |
||||
|
Common::NativeErrorToString(ret)); |
||||
|
handshake_state = HandshakeState::Error; |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
return ResultSuccess; |
||||
|
} |
||||
|
|
||||
|
ResultVal<size_t> Read(std::span<u8> data) override { |
||||
|
if (handshake_state != HandshakeState::Connected) { |
||||
|
LOG_ERROR(Service_SSL, "Called Read but we did not successfully handshake"); |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
if (data.size() == 0 || got_read_eof) { |
||||
|
return size_t(0); |
||||
|
} |
||||
|
while (1) { |
||||
|
if (!cleartext_read_buf.empty()) { |
||||
|
const size_t read_size = std::min(cleartext_read_buf.size(), data.size()); |
||||
|
std::memcpy(data.data(), cleartext_read_buf.data(), read_size); |
||||
|
cleartext_read_buf.erase(cleartext_read_buf.begin(), |
||||
|
cleartext_read_buf.begin() + read_size); |
||||
|
return read_size; |
||||
|
} |
||||
|
if (!ciphertext_read_buf.empty()) { |
||||
|
SecBuffer empty{ |
||||
|
.cbBuffer = 0, |
||||
|
.BufferType = SECBUFFER_EMPTY, |
||||
|
.pvBuffer = nullptr, |
||||
|
}; |
||||
|
std::array<SecBuffer, 5> buffers{{ |
||||
|
{ |
||||
|
.cbBuffer = static_cast<unsigned long>(ciphertext_read_buf.size()), |
||||
|
.BufferType = SECBUFFER_DATA, |
||||
|
.pvBuffer = ciphertext_read_buf.data(), |
||||
|
}, |
||||
|
empty, |
||||
|
empty, |
||||
|
empty, |
||||
|
}}; |
||||
|
ASSERT_OR_EXECUTE_MSG( |
||||
|
buffers[0].cbBuffer == ciphertext_read_buf.size(), |
||||
|
{ return ResultInternalError; }, "read buffer too large"); |
||||
|
SecBufferDesc desc{ |
||||
|
.ulVersion = SECBUFFER_VERSION, |
||||
|
.cBuffers = static_cast<unsigned long>(buffers.size()), |
||||
|
.pBuffers = buffers.data(), |
||||
|
}; |
||||
|
SECURITY_STATUS ret = |
||||
|
DecryptMessage(&ctxt, &desc, /*MessageSeqNo*/ 0, /*pfQOP*/ nullptr); |
||||
|
switch (ret) { |
||||
|
case SEC_E_OK: |
||||
|
ASSERT_OR_EXECUTE(buffers[0].BufferType == SECBUFFER_STREAM_HEADER, |
||||
|
{ return ResultInternalError; }); |
||||
|
ASSERT_OR_EXECUTE(buffers[1].BufferType == SECBUFFER_DATA, |
||||
|
{ return ResultInternalError; }); |
||||
|
ASSERT_OR_EXECUTE(buffers[2].BufferType == SECBUFFER_STREAM_TRAILER, |
||||
|
{ return ResultInternalError; }); |
||||
|
cleartext_read_buf.assign(static_cast<u8*>(buffers[1].pvBuffer), |
||||
|
static_cast<u8*>(buffers[1].pvBuffer) + |
||||
|
buffers[1].cbBuffer); |
||||
|
if (buffers[3].BufferType == SECBUFFER_EXTRA) { |
||||
|
ASSERT(buffers[3].cbBuffer <= ciphertext_read_buf.size()); |
||||
|
ciphertext_read_buf.erase(ciphertext_read_buf.begin(), |
||||
|
ciphertext_read_buf.end() - buffers[3].cbBuffer); |
||||
|
} else { |
||||
|
ASSERT(buffers[3].BufferType == SECBUFFER_EMPTY); |
||||
|
ciphertext_read_buf.clear(); |
||||
|
} |
||||
|
continue; |
||||
|
case SEC_E_INCOMPLETE_MESSAGE: |
||||
|
break; |
||||
|
case SEC_I_CONTEXT_EXPIRED: |
||||
|
// Server hung up by sending close_notify.
|
||||
|
got_read_eof = true; |
||||
|
return size_t(0); |
||||
|
default: |
||||
|
LOG_ERROR(Service_SSL, "DecryptMessage failed: {}", |
||||
|
Common::NativeErrorToString(ret)); |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
} |
||||
|
const Result r = FillCiphertextReadBuf(); |
||||
|
if (r != ResultSuccess) { |
||||
|
return r; |
||||
|
} |
||||
|
if (ciphertext_read_buf.empty()) { |
||||
|
got_read_eof = true; |
||||
|
return size_t(0); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
ResultVal<size_t> Write(std::span<const u8> data) override { |
||||
|
if (handshake_state != HandshakeState::Connected) { |
||||
|
LOG_ERROR(Service_SSL, "Called Write but we did not successfully handshake"); |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
if (data.size() == 0) { |
||||
|
return size_t(0); |
||||
|
} |
||||
|
data = data.subspan(0, std::min<size_t>(data.size(), stream_sizes.cbMaximumMessage)); |
||||
|
if (!cleartext_write_buf.empty()) { |
||||
|
// Already in the middle of a write. It wouldn't make sense to not
|
||||
|
// finish sending the entire buffer since TLS has
|
||||
|
// header/MAC/padding/etc.
|
||||
|
if (data.size() != cleartext_write_buf.size() || |
||||
|
std::memcmp(data.data(), cleartext_write_buf.data(), data.size())) { |
||||
|
LOG_ERROR(Service_SSL, "Called Write but buffer does not match previous buffer"); |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
return WriteAlreadyEncryptedData(); |
||||
|
} else { |
||||
|
cleartext_write_buf.assign(data.begin(), data.end()); |
||||
|
} |
||||
|
|
||||
|
std::vector<u8> header_buf(stream_sizes.cbHeader, 0); |
||||
|
std::vector<u8> tmp_data_buf = cleartext_write_buf; |
||||
|
std::vector<u8> trailer_buf(stream_sizes.cbTrailer, 0); |
||||
|
|
||||
|
std::array<SecBuffer, 3> buffers{{ |
||||
|
{ |
||||
|
.cbBuffer = stream_sizes.cbHeader, |
||||
|
.BufferType = SECBUFFER_STREAM_HEADER, |
||||
|
.pvBuffer = header_buf.data(), |
||||
|
}, |
||||
|
{ |
||||
|
.cbBuffer = static_cast<unsigned long>(tmp_data_buf.size()), |
||||
|
.BufferType = SECBUFFER_DATA, |
||||
|
.pvBuffer = tmp_data_buf.data(), |
||||
|
}, |
||||
|
{ |
||||
|
.cbBuffer = stream_sizes.cbTrailer, |
||||
|
.BufferType = SECBUFFER_STREAM_TRAILER, |
||||
|
.pvBuffer = trailer_buf.data(), |
||||
|
}, |
||||
|
}}; |
||||
|
ASSERT_OR_EXECUTE_MSG( |
||||
|
buffers[1].cbBuffer == tmp_data_buf.size(), { return ResultInternalError; }, |
||||
|
"temp buffer too large"); |
||||
|
SecBufferDesc desc{ |
||||
|
.ulVersion = SECBUFFER_VERSION, |
||||
|
.cBuffers = static_cast<unsigned long>(buffers.size()), |
||||
|
.pBuffers = buffers.data(), |
||||
|
}; |
||||
|
|
||||
|
const SECURITY_STATUS ret = EncryptMessage(&ctxt, /*fQOP*/ 0, &desc, /*MessageSeqNo*/ 0); |
||||
|
if (ret != SEC_E_OK) { |
||||
|
LOG_ERROR(Service_SSL, "EncryptMessage failed: {}", Common::NativeErrorToString(ret)); |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
ciphertext_write_buf.insert(ciphertext_write_buf.end(), header_buf.begin(), |
||||
|
header_buf.end()); |
||||
|
ciphertext_write_buf.insert(ciphertext_write_buf.end(), tmp_data_buf.begin(), |
||||
|
tmp_data_buf.end()); |
||||
|
ciphertext_write_buf.insert(ciphertext_write_buf.end(), trailer_buf.begin(), |
||||
|
trailer_buf.end()); |
||||
|
return WriteAlreadyEncryptedData(); |
||||
|
} |
||||
|
|
||||
|
ResultVal<size_t> WriteAlreadyEncryptedData() { |
||||
|
const Result r = FlushCiphertextWriteBuf(); |
||||
|
if (r != ResultSuccess) { |
||||
|
return r; |
||||
|
} |
||||
|
// write buf is empty
|
||||
|
const size_t cleartext_bytes_written = cleartext_write_buf.size(); |
||||
|
cleartext_write_buf.clear(); |
||||
|
return cleartext_bytes_written; |
||||
|
} |
||||
|
|
||||
|
ResultVal<std::vector<std::vector<u8>>> GetServerCerts() override { |
||||
|
PCCERT_CONTEXT returned_cert = nullptr; |
||||
|
const SECURITY_STATUS ret = |
||||
|
QueryContextAttributes(&ctxt, SECPKG_ATTR_REMOTE_CERT_CONTEXT, &returned_cert); |
||||
|
if (ret != SEC_E_OK) { |
||||
|
LOG_ERROR(Service_SSL, |
||||
|
"QueryContextAttributes(SECPKG_ATTR_REMOTE_CERT_CONTEXT) failed: {}", |
||||
|
Common::NativeErrorToString(ret)); |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
PCCERT_CONTEXT some_cert = nullptr; |
||||
|
std::vector<std::vector<u8>> certs; |
||||
|
while ((some_cert = CertEnumCertificatesInStore(returned_cert->hCertStore, some_cert))) { |
||||
|
certs.emplace_back(static_cast<u8*>(some_cert->pbCertEncoded), |
||||
|
static_cast<u8*>(some_cert->pbCertEncoded) + |
||||
|
some_cert->cbCertEncoded); |
||||
|
} |
||||
|
std::reverse(certs.begin(), |
||||
|
certs.end()); // Windows returns certs in reverse order from what we want
|
||||
|
CertFreeCertificateContext(returned_cert); |
||||
|
return certs; |
||||
|
} |
||||
|
|
||||
|
~SSLConnectionBackendSchannel() { |
||||
|
if (handshake_state != HandshakeState::Initial) { |
||||
|
DeleteSecurityContext(&ctxt); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
enum class HandshakeState { |
||||
|
// Haven't called anything yet.
|
||||
|
Initial, |
||||
|
// `SEC_I_CONTINUE_NEEDED` was returned by
|
||||
|
// `InitializeSecurityContext`; must finish sending data (if any) in
|
||||
|
// the write buffer, then read at least one byte before calling
|
||||
|
// `InitializeSecurityContext` again.
|
||||
|
ContinueNeeded, |
||||
|
// `SEC_E_INCOMPLETE_MESSAGE` was returned by
|
||||
|
// `InitializeSecurityContext`; hopefully the write buffer is empty;
|
||||
|
// must read at least one byte before calling
|
||||
|
// `InitializeSecurityContext` again.
|
||||
|
IncompleteMessage, |
||||
|
// `SEC_E_OK` was returned by `InitializeSecurityContext`; must
|
||||
|
// finish sending data in the write buffer before having `DoHandshake`
|
||||
|
// report success.
|
||||
|
DoneAfterFlush, |
||||
|
// We finished the above and are now connected. At this point, writing
|
||||
|
// and reading are separate 'state machines' represented by the
|
||||
|
// nonemptiness of the ciphertext and cleartext read and write buffers.
|
||||
|
Connected, |
||||
|
// Another error was returned and we shouldn't allow initialization
|
||||
|
// to continue.
|
||||
|
Error, |
||||
|
} handshake_state = HandshakeState::Initial; |
||||
|
|
||||
|
CtxtHandle ctxt; |
||||
|
SecPkgContext_StreamSizes stream_sizes; |
||||
|
|
||||
|
std::shared_ptr<Network::SocketBase> socket; |
||||
|
std::optional<std::string> hostname; |
||||
|
|
||||
|
std::vector<u8> ciphertext_read_buf; |
||||
|
std::vector<u8> ciphertext_write_buf; |
||||
|
std::vector<u8> cleartext_read_buf; |
||||
|
std::vector<u8> cleartext_write_buf; |
||||
|
|
||||
|
bool got_read_eof = false; |
||||
|
size_t read_buf_fill_size = 0; |
||||
|
}; |
||||
|
|
||||
|
ResultVal<std::unique_ptr<SSLConnectionBackend>> CreateSSLConnectionBackend() { |
||||
|
auto conn = std::make_unique<SSLConnectionBackendSchannel>(); |
||||
|
const Result res = conn->Init(); |
||||
|
if (res.IsFailure()) { |
||||
|
return res; |
||||
|
} |
||||
|
return conn; |
||||
|
} |
||||
|
|
||||
|
} // namespace Service::SSL
|
||||
@ -0,0 +1,219 @@ |
|||||
|
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
|
||||
|
#include "core/hle/service/ssl/ssl_backend.h"
|
||||
|
#include "core/internal_network/network.h"
|
||||
|
#include "core/internal_network/sockets.h"
|
||||
|
|
||||
|
#include <mutex>
|
||||
|
|
||||
|
#include <Security/SecureTransport.h>
|
||||
|
|
||||
|
// SecureTransport has been deprecated in its entirety in favor of
|
||||
|
// Network.framework, but that does not allow layering TLS on top of an
|
||||
|
// arbitrary socket.
|
||||
|
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
|
||||
|
|
||||
|
namespace { |
||||
|
|
||||
|
template <typename T> |
||||
|
struct CFReleaser { |
||||
|
T ptr; |
||||
|
|
||||
|
YUZU_NON_COPYABLE(CFReleaser); |
||||
|
constexpr CFReleaser() : ptr(nullptr) {} |
||||
|
constexpr CFReleaser(T ptr) : ptr(ptr) {} |
||||
|
constexpr operator T() { |
||||
|
return ptr; |
||||
|
} |
||||
|
~CFReleaser() { |
||||
|
if (ptr) { |
||||
|
CFRelease(ptr); |
||||
|
} |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
std::string CFStringToString(CFStringRef cfstr) { |
||||
|
CFReleaser<CFDataRef> cfdata( |
||||
|
CFStringCreateExternalRepresentation(nullptr, cfstr, kCFStringEncodingUTF8, 0)); |
||||
|
ASSERT_OR_EXECUTE(cfdata, { return "???"; }); |
||||
|
return std::string(reinterpret_cast<const char*>(CFDataGetBytePtr(cfdata)), |
||||
|
CFDataGetLength(cfdata)); |
||||
|
} |
||||
|
|
||||
|
std::string OSStatusToString(OSStatus status) { |
||||
|
CFReleaser<CFStringRef> cfstr(SecCopyErrorMessageString(status, nullptr)); |
||||
|
if (!cfstr) { |
||||
|
return "[unknown error]"; |
||||
|
} |
||||
|
return CFStringToString(cfstr); |
||||
|
} |
||||
|
|
||||
|
} // namespace
|
||||
|
|
||||
|
namespace Service::SSL { |
||||
|
|
||||
|
class SSLConnectionBackendSecureTransport final : public SSLConnectionBackend { |
||||
|
public: |
||||
|
Result Init() { |
||||
|
static std::once_flag once_flag; |
||||
|
std::call_once(once_flag, []() { |
||||
|
if (getenv("SSLKEYLOGFILE")) { |
||||
|
LOG_CRITICAL(Service_SSL, "SSLKEYLOGFILE was set but SecureTransport does not " |
||||
|
"support exporting keys; not logging keys!"); |
||||
|
// Not fatal.
|
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
context.ptr = SSLCreateContext(nullptr, kSSLClientSide, kSSLStreamType); |
||||
|
if (!context) { |
||||
|
LOG_ERROR(Service_SSL, "SSLCreateContext failed"); |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
|
||||
|
OSStatus status; |
||||
|
if ((status = SSLSetIOFuncs(context, ReadCallback, WriteCallback)) || |
||||
|
(status = SSLSetConnection(context, this))) { |
||||
|
LOG_ERROR(Service_SSL, "SSLContext initialization failed: {}", |
||||
|
OSStatusToString(status)); |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
|
||||
|
return ResultSuccess; |
||||
|
} |
||||
|
|
||||
|
void SetSocket(std::shared_ptr<Network::SocketBase> in_socket) override { |
||||
|
socket = std::move(in_socket); |
||||
|
} |
||||
|
|
||||
|
Result SetHostName(const std::string& hostname) override { |
||||
|
OSStatus status = SSLSetPeerDomainName(context, hostname.c_str(), hostname.size()); |
||||
|
if (status) { |
||||
|
LOG_ERROR(Service_SSL, "SSLSetPeerDomainName failed: {}", OSStatusToString(status)); |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
return ResultSuccess; |
||||
|
} |
||||
|
|
||||
|
Result DoHandshake() override { |
||||
|
OSStatus status = SSLHandshake(context); |
||||
|
return HandleReturn("SSLHandshake", 0, status).Code(); |
||||
|
} |
||||
|
|
||||
|
ResultVal<size_t> Read(std::span<u8> data) override { |
||||
|
size_t actual; |
||||
|
OSStatus status = SSLRead(context, data.data(), data.size(), &actual); |
||||
|
; |
||||
|
return HandleReturn("SSLRead", actual, status); |
||||
|
} |
||||
|
|
||||
|
ResultVal<size_t> Write(std::span<const u8> data) override { |
||||
|
size_t actual; |
||||
|
OSStatus status = SSLWrite(context, data.data(), data.size(), &actual); |
||||
|
; |
||||
|
return HandleReturn("SSLWrite", actual, status); |
||||
|
} |
||||
|
|
||||
|
ResultVal<size_t> HandleReturn(const char* what, size_t actual, OSStatus status) { |
||||
|
switch (status) { |
||||
|
case 0: |
||||
|
return actual; |
||||
|
case errSSLWouldBlock: |
||||
|
return ResultWouldBlock; |
||||
|
default: { |
||||
|
std::string reason; |
||||
|
if (got_read_eof) { |
||||
|
reason = "server hung up"; |
||||
|
} else { |
||||
|
reason = OSStatusToString(status); |
||||
|
} |
||||
|
LOG_ERROR(Service_SSL, "{} failed: {}", what, reason); |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
ResultVal<std::vector<std::vector<u8>>> GetServerCerts() override { |
||||
|
CFReleaser<SecTrustRef> trust; |
||||
|
OSStatus status = SSLCopyPeerTrust(context, &trust.ptr); |
||||
|
if (status) { |
||||
|
LOG_ERROR(Service_SSL, "SSLCopyPeerTrust failed: {}", OSStatusToString(status)); |
||||
|
return ResultInternalError; |
||||
|
} |
||||
|
std::vector<std::vector<u8>> ret; |
||||
|
for (CFIndex i = 0, count = SecTrustGetCertificateCount(trust); i < count; i++) { |
||||
|
SecCertificateRef cert = SecTrustGetCertificateAtIndex(trust, i); |
||||
|
CFReleaser<CFDataRef> data(SecCertificateCopyData(cert)); |
||||
|
ASSERT_OR_EXECUTE(data, { return ResultInternalError; }); |
||||
|
const u8* ptr = CFDataGetBytePtr(data); |
||||
|
ret.emplace_back(ptr, ptr + CFDataGetLength(data)); |
||||
|
} |
||||
|
return ret; |
||||
|
} |
||||
|
|
||||
|
static OSStatus ReadCallback(SSLConnectionRef connection, void* data, size_t* dataLength) { |
||||
|
return ReadOrWriteCallback(connection, data, dataLength, true); |
||||
|
} |
||||
|
|
||||
|
static OSStatus WriteCallback(SSLConnectionRef connection, const void* data, |
||||
|
size_t* dataLength) { |
||||
|
return ReadOrWriteCallback(connection, const_cast<void*>(data), dataLength, false); |
||||
|
} |
||||
|
|
||||
|
static OSStatus ReadOrWriteCallback(SSLConnectionRef connection, void* data, size_t* dataLength, |
||||
|
bool is_read) { |
||||
|
auto self = |
||||
|
static_cast<SSLConnectionBackendSecureTransport*>(const_cast<void*>(connection)); |
||||
|
ASSERT_OR_EXECUTE_MSG( |
||||
|
self->socket, { return 0; }, "SecureTransport asked to {} but we have no socket", |
||||
|
is_read ? "read" : "write"); |
||||
|
|
||||
|
// SecureTransport callbacks (unlike OpenSSL BIO callbacks) are
|
||||
|
// expected to read/write the full requested dataLength or return an
|
||||
|
// error, so we have to add a loop ourselves.
|
||||
|
size_t requested_len = *dataLength; |
||||
|
size_t offset = 0; |
||||
|
while (offset < requested_len) { |
||||
|
std::span cur(reinterpret_cast<u8*>(data) + offset, requested_len - offset); |
||||
|
auto [actual, err] = is_read ? self->socket->Recv(0, cur) : self->socket->Send(cur, 0); |
||||
|
LOG_CRITICAL(Service_SSL, "op={}, offset={} actual={}/{} err={}", is_read, offset, |
||||
|
actual, cur.size(), static_cast<s32>(err)); |
||||
|
switch (err) { |
||||
|
case Network::Errno::SUCCESS: |
||||
|
offset += actual; |
||||
|
if (actual == 0) { |
||||
|
ASSERT(is_read); |
||||
|
self->got_read_eof = true; |
||||
|
return errSecEndOfData; |
||||
|
} |
||||
|
break; |
||||
|
case Network::Errno::AGAIN: |
||||
|
*dataLength = offset; |
||||
|
return errSSLWouldBlock; |
||||
|
default: |
||||
|
LOG_ERROR(Service_SSL, "Socket {} returned Network::Errno {}", |
||||
|
is_read ? "recv" : "send", err); |
||||
|
return errSecIO; |
||||
|
} |
||||
|
} |
||||
|
ASSERT(offset == requested_len); |
||||
|
return 0; |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
CFReleaser<SSLContextRef> context = nullptr; |
||||
|
bool got_read_eof = false; |
||||
|
|
||||
|
std::shared_ptr<Network::SocketBase> socket; |
||||
|
}; |
||||
|
|
||||
|
ResultVal<std::unique_ptr<SSLConnectionBackend>> CreateSSLConnectionBackend() { |
||||
|
auto conn = std::make_unique<SSLConnectionBackendSecureTransport>(); |
||||
|
const Result res = conn->Init(); |
||||
|
if (res.IsFailure()) { |
||||
|
return res; |
||||
|
} |
||||
|
return conn; |
||||
|
} |
||||
|
|
||||
|
} // namespace Service::SSL
|
||||
Write
Preview
Loading…
Cancel
Save
Reference in new issue