rcpp_framework/libs/brynet/net/SSLHelper.hpp

#pragma once

#include <brynet/base/Noexcept.hpp>
#include <brynet/base/NonCopyable.hpp>
#include <brynet/base/Platform.hpp>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <unordered_map>

#ifdef BRYNET_USE_OPENSSL

#ifdef __cplusplus
extern "C" {
#endif
#include <openssl/err.h>
#include <openssl/ssl.h>
#ifdef __cplusplus
}
#endif

#endif

namespace brynet { namespace net {

#ifdef BRYNET_USE_OPENSSL

#ifndef CRYPTO_THREADID_set_callback
static void cryptoSetThreadIDCallback(CRYPTO_THREADID* id)
{
#ifdef BRYNET_PLATFORM_WINDOWS
    CRYPTO_THREADID_set_numeric(id,
                                static_cast<unsigned long>(GetCurrentThreadId()));
#elif defined BRYNET_PLATFORM_LINUX || defined BRYNET_PLATFORM_DARWIN
    CRYPTO_THREADID_set_numeric(id,
                                static_cast<unsigned long>(pthread_self()));
#endif
}
#endif

#ifndef CRYPTO_set_locking_callback
static std::unordered_map<int, std::shared_ptr<std::mutex>> cryptoLocks;
static void cryptoLockingCallback(int mode,
                                  int type,
                                  const char* file, int line)
{
    (void) file;
    (void) line;
    if (mode & CRYPTO_LOCK)
    {
        cryptoLocks[type]->lock();
    }
    else if (mode & CRYPTO_UNLOCK)
    {
        cryptoLocks[type]->unlock();
    }
}
#endif

static std::once_flag initCryptoThreadSafeSupportOnceFlag;
static void InitCryptoThreadSafeSupport()
{
#ifndef CRYPTO_THREADID_set_callback
    CRYPTO_THREADID_set_callback(cryptoSetThreadIDCallback);
#endif

#ifndef CRYPTO_set_locking_callback
    for (int i = 0; i < CRYPTO_num_locks(); i++)
    {
        cryptoLocks[i] = std::make_shared<std::mutex>();
    }
    CRYPTO_set_locking_callback(cryptoLockingCallback);
#endif
}
#endif

class SSLHelper : public brynet::base::NonCopyable,
                  public std::enable_shared_from_this<SSLHelper>
{
public:
    using Ptr = std::shared_ptr<SSLHelper>;

#ifdef BRYNET_USE_OPENSSL
    bool initSSL(const std::string& certificate,
                 const std::string& privatekey)
    {
        std::call_once(initCryptoThreadSafeSupportOnceFlag,
                       InitCryptoThreadSafeSupport);

        if (mOpenSSLCTX != nullptr)
        {
            return false;
        }
        if (certificate.empty() || privatekey.empty())
        {
            return false;
        }

        mOpenSSLCTX = SSL_CTX_new(SSLv23_method());
        SSL_CTX_set_client_CA_list(mOpenSSLCTX,
                                   SSL_load_client_CA_file(certificate.c_str()));
        SSL_CTX_set_verify_depth(mOpenSSLCTX, 10);

        if (SSL_CTX_use_certificate_chain_file(mOpenSSLCTX,
                                               certificate.c_str()) <= 0)
        {
            SSL_CTX_free(mOpenSSLCTX);
            mOpenSSLCTX = nullptr;
            return false;
        }

        if (SSL_CTX_use_PrivateKey_file(mOpenSSLCTX,
                                        privatekey.c_str(),
                                        SSL_FILETYPE_PEM) <= 0)
        {
            SSL_CTX_free(mOpenSSLCTX);
            mOpenSSLCTX = nullptr;
            return false;
        }

        if (!SSL_CTX_check_private_key(mOpenSSLCTX))
        {
            SSL_CTX_free(mOpenSSLCTX);
            mOpenSSLCTX = nullptr;
            return false;
        }

        return true;
    }

    void destroySSL()
    {
        if (mOpenSSLCTX != nullptr)
        {
            SSL_CTX_free(mOpenSSLCTX);
            mOpenSSLCTX = nullptr;
        }
    }

    SSL_CTX* getOpenSSLCTX()
    {
        return mOpenSSLCTX;
    }
#endif
    static Ptr Create()
    {
        class make_shared_enabler : public SSLHelper
        {
        };
        return std::make_shared<make_shared_enabler>();
    }

protected:
    SSLHelper() BRYNET_NOEXCEPT
    {
#ifdef BRYNET_USE_OPENSSL
        mOpenSSLCTX = nullptr;
#endif
    }

    virtual ~SSLHelper() BRYNET_NOEXCEPT
    {
#ifdef BRYNET_USE_OPENSSL
        destroySSL();
#endif
    }

private:
#ifdef BRYNET_USE_OPENSSL
    SSL_CTX* mOpenSSLCTX;
#endif
};

}}// namespace brynet::net