VERY experimental Nintendo Switch 2 emulator
C++
[hle/services/ssl] Remove deprecated SecureTransport and SChannel backends (#4392)
lizzieee73920d2885
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txtindex 508ace3501..5c31ebb70e 100644--- a/src/core/CMakeLists.txt+++ b/src/core/CMakeLists.txt@@ -1261,23 +1261,11 @@ if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64 OR ARCHITECTURE_riscv64 OR ARCHITEtarget_link_libraries(core PRIVATE dynarmic::dynarmic)endif()-target_sources(core PRIVATE hle/service/ssl/ssl_backend_openssl.cpp)--target_link_libraries(core PRIVATE OpenSSL::SSL OpenSSL::Crypto)--# TODO--# elseif (APPLE)-# target_sources(core PRIVATE-# hle/service/ssl/ssl_backend_securetransport.cpp)-# target_link_libraries(core PRIVATE "-framework Security")-# elseif (WIN32)-# target_sources(core PRIVATE-# hle/service/ssl/ssl_backend_schannel.cpp)-# target_link_libraries(core PRIVATE crypt32 secur32)-# else()-# target_sources(core PRIVATE-# hle/service/ssl/ssl_backend_none.cpp)-# endif()+if (TARGET OpenSSL::SSL)+ target_sources(core PRIVATE hle/service/ssl/ssl_backend_openssl.cpp)+ target_link_libraries(core PRIVATE OpenSSL::SSL OpenSSL::Crypto)+else()+ target_sources(core PRIVATE hle/service/ssl/ssl_backend_none.cpp)+endif()create_target_directory_groups(core)diff --git a/src/core/hle/service/ssl/ssl_backend_schannel.cpp b/src/core/hle/service/ssl/ssl_backend_schannel.cppdeleted file mode 100644index 2b68f29eaf..0000000000--- a/src/core/hle/service/ssl/ssl_backend_schannel.cpp+++ /dev/null@@ -1,563 +0,0 @@-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project-// SPDX-License-Identifier: GPL-3.0-or-later--// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project-// SPDX-License-Identifier: GPL-2.0-or-later--#include <mutex>--#include "common/error.h"-#include "common/fs/file.h"-#include "common/hex_util.h"-#include "common/string_util.h"--#include "core/hle/service/ssl/ssl_backend.h"-#include "core/internal_network/network.h"-#include "core/internal_network/sockets.h"--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>-#include <wincrypt.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_NO_SERVERNAME_CHECK | // don't validate server names- 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;- }-- void SetVerifyOption(u32 option) override {- skip_cert_verification = (option == 0);- LOG_WARNING(Service_SSL, "option={} skip_verification={}", option,- skip_cert_verification);- }-- 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() {- 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;-- if (skip_cert_verification) {- req |= ISC_REQ_MANUAL_CRED_VALIDATION;- }-- 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());- }-- char* hostname_ptr = hostname ? const_cast<char*>(hostname->c_str()) : nullptr;- const SECURITY_STATUS ret = InitializeSecurityContextA(- &cred_handle, initial_call_done ? &ctxt : nullptr, hostname_ptr, 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;- }-- Result Read(size_t* out_size, std::span<u8> data) override {- *out_size = 0;- 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 ResultSuccess;- }- while (1) {- if (!cleartext_read_buf.empty()) {- *out_size = (std::min)(cleartext_read_buf.size(), data.size());- std::memcpy(data.data(), cleartext_read_buf.data(), *out_size);- cleartext_read_buf.erase(cleartext_read_buf.begin(),- cleartext_read_buf.begin() + *out_size);- return ResultSuccess;- }- 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;- *out_size = 0;- return ResultSuccess;- 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;- *out_size = 0;- return ResultSuccess;- }- }- }-- Result Write(size_t* out_size, std::span<const u8> data) override {- *out_size = 0;-- if (handshake_state != HandshakeState::Connected) {- LOG_ERROR(Service_SSL, "Called Write but we did not successfully handshake");- return ResultInternalError;- }- if (data.size() == 0) {- return ResultSuccess;- }- 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(out_size);- } 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(out_size);- }-- Result WriteAlreadyEncryptedData(size_t* out_size) {- const Result r = FlushCiphertextWriteBuf();- if (r != ResultSuccess) {- return r;- }- // write buf is empty- *out_size = cleartext_write_buf.size();- cleartext_write_buf.clear();- return ResultSuccess;- }-- Result GetServerCerts(std::vector<std::vector<u8>>* out_certs) 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;- while ((some_cert = CertEnumCertificatesInStore(returned_cert->hCertStore, some_cert)) !=- nullptr) {- out_certs->emplace_back(static_cast<u8*>(some_cert->pbCertEncoded),- static_cast<u8*>(some_cert->pbCertEncoded) +- some_cert->cbCertEncoded);- }- std::reverse(out_certs->begin(),- out_certs->end()); // Windows returns certs in reverse order from what we want- CertFreeCertificateContext(returned_cert);- return ResultSuccess;- }-- ~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;- bool skip_cert_verification = false;- size_t read_buf_fill_size = 0;-};--Result CreateSSLConnectionBackend(std::unique_ptr<SSLConnectionBackend>* out_backend) {- auto conn = std::make_unique<SSLConnectionBackendSchannel>();-- R_TRY(conn->Init());-- *out_backend = std::move(conn);- return ResultSuccess;-}--} // namespace Service::SSLdiff --git a/src/core/hle/service/ssl/ssl_backend_securetransport.cpp b/src/core/hle/service/ssl/ssl_backend_securetransport.cppdeleted file mode 100644index 65f81be631..0000000000--- a/src/core/hle/service/ssl/ssl_backend_securetransport.cpp+++ /dev/null@@ -1,236 +0,0 @@-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project-// SPDX-License-Identifier: GPL-3.0-or-later--// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project-// SPDX-License-Identifier: GPL-2.0-or-later--#include <mutex>--// 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.-#if defined(__GNUC__) || defined(__clang__)-#pragma GCC diagnostic push-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"-#include <Security/SecureTransport.h>-#pragma GCC diagnostic pop-#endif--#include "core/hle/service/ssl/ssl_backend.h"-#include "core/internal_network/network.h"-#include "core/internal_network/sockets.h"--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;- }-- void SetVerifyOption(u32 option) override {- skip_cert_verification = (option == 0);- LOG_WARNING(Service_SSL, "option={} skip_verification={}", option,- skip_cert_verification);- if (skip_cert_verification) {- SSLSetSessionOption(context, kSSLSessionOptionBreakOnServerAuth, true);- }- }-- Result DoHandshake() override {- OSStatus status = SSLHandshake(context);-- if (skip_cert_verification && status == errSSLServerAuthCompleted) {- LOG_DEBUG(Service_SSL, "Skipping certificate verification as requested");- status = SSLHandshake(context);- }-- return HandleReturn("SSLHandshake", 0, status);- }-- Result Read(size_t* out_size, std::span<u8> data) override {- OSStatus status = SSLRead(context, data.data(), data.size(), out_size);- return HandleReturn("SSLRead", out_size, status);- }-- Result Write(size_t* out_size, std::span<const u8> data) override {- OSStatus status = SSLWrite(context, data.data(), data.size(), out_size);- return HandleReturn("SSLWrite", out_size, status);- }-- Result HandleReturn(const char* what, size_t* actual, OSStatus status) {- switch (status) {- case 0:- return ResultSuccess;- 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;- }- }- }-- Result GetServerCerts(std::vector<std::vector<u8>>* out_certs) override {- CFReleaser<SecTrustRef> trust;- OSStatus status = SSLCopyPeerTrust(context, &trust.ptr);- if (status) {- LOG_ERROR(Service_SSL, "SSLCopyPeerTrust failed: {}", OSStatusToString(status));- return ResultInternalError;- }- 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);- out_certs->emplace_back(ptr, ptr + CFDataGetLength(data));- }- return ResultSuccess;- }-- 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;- bool skip_cert_verification = false;-- std::shared_ptr<Network::SocketBase> socket;-};--Result CreateSSLConnectionBackend(std::unique_ptr<SSLConnectionBackend>* out_backend) {- auto conn = std::make_unique<SSLConnectionBackendSecureTransport>();-- R_TRY(conn->Init());-- *out_backend = std::move(conn);- return ResultSuccess;-}--} // namespace Service::SSL