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 net
} // namespace brynet