proxyTest/main.cpp

#include <iostream>
#include <boost/asio.hpp>
#include <boost/lexical_cast.hpp>
#include <thread>
#include <array>
#include <iomanip>


#include <boost/bind.hpp>

#include <boost/thread/thread.hpp>

#define SSL_R_SHORT_READ 219
#include "ssl/ssl_locl.h"
#include <boost/asio/ssl.hpp>

#if defined(close)
#undef close
#endif

enum AddressType
{
	AT_IPV4 = 0,
	AT_HOST = 3,
	AT_IPV6 = 4
};

class ConnectResponseRecord
{
public:
	std::vector<unsigned char> rawData;

	enum ConnectResponseType
	{
		CRT_SUCCESS = 0,
		CRT_GENERAL_SOCKS_SERVER_FAILURE = 1,
		CRT_CONNECTION_NOT_ALLOWED_BY_RULESET = 2,
		CRT_NETWORK_UNREACHABLE = 3,
		CRT_HOST_UNREACHABLE = 4,
		CRT_CONNECTION_REFUSED = 5,
		CRT_TTL_EXPIRED = 6,
		CRT_COMMAND_NOT_SUPPORTED = 7,
		CRT_ADDRESS_TYPE_NOT_SUPPORTED = 8,
		CRT_TO_FF_UNASSIGNED = 9
	};

	ConnectResponseType connectResponseType;

	AddressType addressType;

	std::string address;

	uint16_t port;
};

class ConnectRequestRecord
{
public:
	std::string address;
	uint16_t port;

	std::string getRequestData();
};

std::string ConnectRequestRecord::getRequestData()
{
	std::string data = "";
	data += 0x05;
	data += 0x01;
	data += char(0x00);
	data += 0x03;
	data += static_cast<unsigned char>(address.size());
	data += address;
	data += port / 256;
	data += port % 256;
	return data;
}

class ProxyClient
{
public:
	ProxyClient(boost::asio::io_service& ioServiceIn, boost::asio::ssl::context& context, boost::asio::ip::tcp::resolver& resolverIn)
		: ioService(ioServiceIn)
		, socket(ioServiceIn, context)
		, resolver(resolverIn)
	{
		socket.set_verify_mode(boost::asio::ssl::verify_peer);
		socket.set_verify_callback(
			std::bind(&ProxyClient::verify_certificate, this, std::placeholders::_1, std::placeholders::_2));
	}


	void start()
	{
		doConnect();
	}

	void close()
	{
		ioService.post([this]() { lowerSocket().close(); });
	}

	std::function<void()> onReady;

	boost::asio::ssl::stream<boost::asio::ip::tcp::socket>& getSocket()
	{
		return socket;
	}

	boost::asio::ssl::stream<boost::asio::ip::tcp::socket>::lowest_layer_type& lowerSocket()
	{
		return socket.lowest_layer();
	}

private:


	
	

	void doConnect()
	{
		//boost::asio::ip::tcp::resolver::iterator endpointIterator(resolver.resolve({ "127.0.0.1", "8043" }));
		//boost::asio::ip::tcp::resolver::iterator endpointIterator(resolver.resolve({ "https-proxy.fishrungames.com", "8043" }));

		boost::asio::ip::tcp::resolver::iterator endpointIterator(resolver.resolve({ "52.89.37.158", "8043" }));

		boost::asio::async_connect(lowerSocket(), endpointIterator,
			[this](boost::system::error_code ec, boost::asio::ip::tcp::resolver::iterator)
		{
			if (!ec)
			{
				doHandshake();
			}
		});
	}


	void doHandshake()
	{
		socket.async_handshake(boost::asio::ssl::stream_base::client,
			[this](const boost::system::error_code& error) {
		

			if (!error)
			{
				onReady();
				//sendVersion();
			}
			else
			{
				std::cout << "Handshake failed: " << error.message() << "\n";
				lowerSocket().close();
			}

		});
	}



	bool verify_certificate(bool preverified,
		boost::asio::ssl::verify_context& ctx)
	{
		// The verify callback can be used to check whether the certificate that is
		// being presented is valid for the peer. For example, RFC 2818 describes
		// the steps involved in doing this for HTTPS. Consult the OpenSSL
		// documentation for more details. Note that the callback is called once
		// for each certificate in the certificate chain, starting from the root
		// certificate authority.

		// In this example we will simply print the certificate's subject name.
		char subject_name[256];
		X509* cert = X509_STORE_CTX_get_current_cert(ctx.native_handle());
		X509_NAME_oneline(X509_get_subject_name(cert), subject_name, 256);
		std::cout << "Verifying " << subject_name << "\n";

		return preverified;
	}


	void sendVersion()
	{
		std::array<char, 3> version = {0x05, 0x01, 0x02};

		boost::asio::async_write(socket,
			boost::asio::buffer(version.data(),
				version.size()),
			[this](boost::system::error_code ec, std::size_t length)
		{
			if (!ec)
			{
				doReadServerVersion();
			}
			else
			{
				lowerSocket().close();
			}
		});
	}

	std::array<unsigned char, 2> serverVersionMethod;
	std::array<unsigned char, 2> serverAuthStatus;

	std::vector<ConnectRequestRecord> connectRequestArr;
	
	void doReadServerVersion()
	{
		boost::asio::async_read(socket,
			boost::asio::buffer(serverVersionMethod.data(), serverVersionMethod.size()),
			[this](boost::system::error_code ec, std::size_t length)
		{
			if (!ec)
			{
				if (serverVersionMethod[0] == 5 && serverVersionMethod[1] == 2)
				{
					doWriteLoginPassword();
				}
				else
				{
					//Others not supported
					lowerSocket().close();
				}
			}
			else
			{
				lowerSocket().close();
			}
		});
	}

	void doWriteLoginPassword()
	{
		std::string login = "telegram-proxy-user";
		std::string password = "telegram-telegram-999112";
		std::string data = "";
		data += 0x01;
		data += static_cast<unsigned char>(login.size());
		data += login;
		data += static_cast<unsigned char>(password.size());
		data += password;

		boost::asio::async_write(socket,
			boost::asio::buffer(data.data(),
				data.size()),
			[this](boost::system::error_code ec, std::size_t length)
		{
			if (!ec)
			{
				doReadAuthStatus();
			}
			else
			{
				lowerSocket().close();
			}
		});
	}


	void connectToWebAddress(std::string address)
	{
		ConnectRequestRecord record = { address, 80 };

		connectRequestArr.push_back(record);

		auto data = record.getRequestData();

		boost::asio::async_write(socket,
			boost::asio::buffer(data.data(),
				data.size()),
			[this](boost::system::error_code ec, std::size_t length)
		{
			if (!ec)
			{
				doReadConnectToWebAddressResponse();
			}
			else
			{
				lowerSocket().close();
			}
		});

	}




	void doWriteSomething()
	{
		//std::array<char, 100> something = { 0x05, 0x01, 0x00, 0x03 };


		std::string data = "GET / HTTP/1.1\r\nHost: www.google.com\r\nConnection: close\r\n\r\n";

		boost::asio::async_write(socket,
			boost::asio::buffer(data.data(),
				data.size()),
			[this](boost::system::error_code ec, std::size_t length)
		{
			if (!ec)
			{
				doReadSomethingText();
			}
			else
			{
				lowerSocket().close();
			}
		});
	}

	void doReadAuthStatus()
	{
		boost::asio::async_read(socket,
			boost::asio::buffer(serverAuthStatus.data(), serverAuthStatus.size()),
			[this](boost::system::error_code ec, std::size_t length)
		{
			if (!ec)
			{
				if (serverAuthStatus[0] == 1 && serverAuthStatus[1] == 0)
				{
					//doWriteSomething();

					/*
					if (onReady)
					{
						onReady();
					}*/
					

					//connectToWebAddress("www.google.com");
				}
				else
				{
					//Authorization is not succeed
					lowerSocket().close();
				}
			}
			else
			{
				lowerSocket().close();
			}
		});
	}


	void doReadConnectToWebAddressResponse()
	{
		std::shared_ptr<std::array<unsigned char, 5>> firstPartPtr = std::make_shared<std::array<unsigned char, 5>>();

		boost::asio::async_read(socket,
			boost::asio::buffer(firstPartPtr->data(), firstPartPtr->size()),
			[this, firstPartPtr](boost::system::error_code ec, std::size_t length)
		{
			if (!ec)
			{
				doReadConnectToWebAddressResponsePart2(firstPartPtr);
				
			}
			else
			{
				lowerSocket().close();
			}
		});
	}


	void doReadConnectToWebAddressResponsePart2(std::shared_ptr<std::array<unsigned char, 5>> firstPartPtr)
	{
		unsigned int size = 3;
		if ((*firstPartPtr)[3] == AddressType::AT_IPV4) {
			size = 3;
		}
		if ((*firstPartPtr)[3] == AddressType::AT_HOST) {
			size = (*firstPartPtr)[4];
		}
		if ((*firstPartPtr)[3] == AddressType::AT_IPV6) {
			size = 15;
		}

		size += 2; //add port
		
		std::shared_ptr<std::vector<char>> secondPartPtr = std::make_shared<std::vector<char>>();

		secondPartPtr->resize(size);

		boost::asio::async_read(socket,
			boost::asio::buffer(secondPartPtr->data(), secondPartPtr->size()),
			[this, firstPartPtr, secondPartPtr](boost::system::error_code ec, std::size_t length)
		{
			if (!ec)
			{
				ConnectResponseRecord connectResponseRecord;

				connectResponseRecord.rawData.clear();

				for (unsigned char c : *firstPartPtr)
				{
					connectResponseRecord.rawData.push_back(c);
				}

				for (unsigned char c : *secondPartPtr)
				{
					connectResponseRecord.rawData.push_back(c);
				}

				connectResponseRecord.connectResponseType = static_cast<ConnectResponseRecord::ConnectResponseType>(connectResponseRecord.rawData[1]);
				connectResponseRecord.addressType = static_cast<AddressType>(connectResponseRecord.rawData[3]);

				size_t portOffset = 8;

				if (connectResponseRecord.addressType == AddressType::AT_IPV4)
				{
					connectResponseRecord.address = boost::lexical_cast<std::string>(static_cast<unsigned int>(connectResponseRecord.rawData[4]))
						+ "." + boost::lexical_cast<std::string>(static_cast<unsigned int>(connectResponseRecord.rawData[5]))
						+ "." + boost::lexical_cast<std::string>(static_cast<unsigned int>(connectResponseRecord.rawData[6]))
						+ "." + boost::lexical_cast<std::string>(static_cast<unsigned int>(connectResponseRecord.rawData[7]));

					portOffset = 8;
				}

				if (connectResponseRecord.addressType == AddressType::AT_HOST)
				{
					size_t count = connectResponseRecord.rawData[4];

					for (size_t i = 0; i < count; i++)
					{
						connectResponseRecord.address.push_back(connectResponseRecord.rawData[5 + i]);
					}

					portOffset = 5 + count;
				}

				if (connectResponseRecord.addressType == AddressType::AT_IPV6)
				{

					std::stringstream stream;
					stream << std::hex << connectResponseRecord.rawData[4];
					stream << std::hex << connectResponseRecord.rawData[5];
					stream << ":";
					stream << std::hex << connectResponseRecord.rawData[6];
					stream << std::hex << connectResponseRecord.rawData[7];
					stream << ":";
					stream << std::hex << connectResponseRecord.rawData[8];
					stream << std::hex << connectResponseRecord.rawData[9];
					stream << ":";
					stream << std::hex << connectResponseRecord.rawData[10];
					stream << std::hex << connectResponseRecord.rawData[11];
					stream << ":";
					stream << std::hex << connectResponseRecord.rawData[12];
					stream << std::hex << connectResponseRecord.rawData[13];
					stream << ":";
					stream << std::hex << connectResponseRecord.rawData[14];
					stream << std::hex << connectResponseRecord.rawData[15];
					stream << ":";
					stream << std::hex << connectResponseRecord.rawData[16];
					stream << std::hex << connectResponseRecord.rawData[17];
					stream << ":";
					stream << std::hex << connectResponseRecord.rawData[18];
					stream << std::hex << connectResponseRecord.rawData[19];

					connectResponseRecord.address = stream.str();

					portOffset = 20;
				}

				connectResponseRecord.port = connectResponseRecord.rawData[portOffset] * 256 + connectResponseRecord.rawData[portOffset + 1];

				doWriteSomething();
			}
			else
			{
				lowerSocket().close();
			}
		});
	}

	unsigned char item;
	std::string result;

	void doReadSomething()
	{
		boost::asio::async_read(socket,
			boost::asio::buffer(&item, 1),
			[this](boost::system::error_code ec, std::size_t length)
		{
			if (!ec)
			{
				result += boost::lexical_cast<std::string>(static_cast<unsigned int>(item)) + " ";
				std::cout << boost::lexical_cast<std::string>(static_cast<unsigned int>(item)) + " ";
				doReadSomething();
			}
			else
			{
				lowerSocket().close();
			}
		});
	}

	void doReadSomethingText()
	{
		boost::asio::async_read(socket,
			boost::asio::buffer(&item, 1),
			[this](boost::system::error_code ec, std::size_t length)
		{
			if (!ec)
			{
				result += (item);
				std::cout << item;
				doReadSomethingText();
			}
			else
			{
				lowerSocket().close();
			}
		});
	}

private:
	boost::asio::io_service& ioService;

	boost::asio::ssl::stream<boost::asio::ip::tcp::socket> socket;

	boost::asio::ip::tcp::resolver& resolver;
};


class ProxyClientSession : public std::enable_shared_from_this<ProxyClientSession> {
public:

	ProxyClientSession(boost::asio::ip::tcp::socket socket, boost::asio::io_service& ioServiceIn, boost::asio::ssl::context& context, boost::asio::ip::tcp::resolver& resolverIn)
		: socket(std::move(socket))
		, resolver(resolverIn)
		, proxyClient(ioServiceIn, context, resolverIn)

	{
		std::cout << "ProxyClientSession create" << std::endl;
	}

	~ProxyClientSession()
	{
		std::cout << "ProxyClientSession destroy" << std::endl;
	}



	void start()
	{
	
		auto self(shared_from_this());

		proxyClient.onReady = [self]() {self->onProxyReady(); };

		proxyClient.start();

	}

	

protected:


	//unsigned char forwardChar;
	//unsigned char backwardChar;

	std::array<unsigned char, 8192> forwardBuffer;
	std::array<unsigned char, 8192> backwardBuffer;

	

	void onProxyReady()
	{
		
		transferDataForward();
		transferDataBackward();
		proxyClient.onReady = nullptr;
	}

	void transferDataForward()
	{
		auto self(shared_from_this());

		socket.async_read_some(boost::asio::buffer(forwardBuffer),
			[this, self](boost::system::error_code ec, std::size_t length)
		{
			if (!ec)
			{

				std::shared_ptr<std::vector<unsigned char>> data = std::make_shared<std::vector<unsigned char>>();
				data->resize(length);

				std::copy(&forwardBuffer[0], &forwardBuffer[0] + length, &(*data)[0]);

				boost::asio::async_write(proxyClient.getSocket(),
					boost::asio::buffer(*data),
					[this, self, data](boost::system::error_code ec, std::size_t length)
				{

					if (!ec)
					{
						transferDataForward();
					}
					else
					{
						std::cout <<  "transferDataForward write error" << std::endl;
						proxyClient.lowerSocket().close();
						socket.close();
					}
				});
			}
			else if (ec == boost::asio::error::eof)
			{
				std::cout << "transferDataForward read end of file" << std::endl;
				if (length > 0)
				{
					std::cout << "but length is positive" << std::endl;
				}
				return;
			}
			else
			{
				std::cout << "transferDataForward read error" << std::endl;

				proxyClient.lowerSocket().close();
				socket.close();
			}
		});
	}

	void transferDataBackward()
	{
		auto self(shared_from_this());

		proxyClient.getSocket().async_read_some(boost::asio::buffer(backwardBuffer),
			[this, self](boost::system::error_code ec, std::size_t length)
		{
			if (!ec)
			{
				std::shared_ptr<std::vector<unsigned char>> data = std::make_shared<std::vector<unsigned char>>();
				data->resize(length);

				std::copy(&backwardBuffer[0], &backwardBuffer[0] + length, &(*data)[0]);

				boost::asio::async_write(socket,
					boost::asio::buffer(*data),
					[this, self, data](boost::system::error_code ec, std::size_t length)
				{

					if (!ec)
					{
						transferDataBackward();
					}
					else
					{
						std::cout << "transferDataBackward write error" << std::endl;

						proxyClient.lowerSocket().close();
						socket.close();
					}
				});
			}
			else if (ec == boost::asio::error::eof)
			{
				std::cout << "transferDataBackward read end of file" << std::endl;
				if (length > 0)
				{
					std::cout << "but length is positive" << std::endl;
				}
				return;
			}
			else
			{
				std::cout << "transferDataBackward read error" << std::endl;


				proxyClient.lowerSocket().close();
				socket.close();
			}
		});
	}

	
	boost::asio::ip::tcp::socket socket;

	boost::asio::ip::tcp::resolver& resolver;

	ProxyClient proxyClient;
	

};

class IntermediateServer
{
public:

	IntermediateServer(boost::asio::io_service& io_service,
		const boost::asio::ip::tcp::endpoint& endpoint)
		: ioService(io_service)
		, acceptor(io_service, endpoint)
		, socket(io_service)
		, resolver(io_service)
		, ctx(boost::asio::ssl::context::sslv23)
	{

		ctx.load_verify_file("rootca.crt");

		doAccept();
	}

protected:

	void doAccept()
	{
		acceptor.async_accept(socket,
			[this](boost::system::error_code ec)
		{
			if (!ec)
			{
				std::make_shared<ProxyClientSession>(std::move(socket), ioService, ctx, resolver)->start();
			}

			doAccept();
		});
	}


	boost::asio::io_service& ioService;

	boost::asio::ip::tcp::acceptor acceptor;
	boost::asio::ip::tcp::socket socket;

	boost::asio::ip::tcp::resolver resolver;
	//boost::asio::ip::tcp::resolver::iterator endpointIterator;
	boost::asio::ssl::context ctx;


};



int main()
{
	std::cout << "Hello" << std::endl;
	
	boost::asio::io_service ioService;
	//boost::asio::io_service::work work(ioService);


	//Create intermediate:
	boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(), 8042);

	IntermediateServer intermediateServer(ioService, endpoint);
	
	
	//ProxyClient c(ioService, ctx, endpointIterator);

	//std::thread t([&ioService]() { ioService.run(); });

	//t.join();


	boost::thread_group threadpool;
	/*
	threadpool.create_thread(
		boost::bind(&boost::asio::io_service::run, &ioService)
	);
	threadpool.create_thread(
		boost::bind(&boost::asio::io_service::run, &ioService)
	);
	threadpool.create_thread(
		boost::bind(&boost::asio::io_service::run, &ioService)
	);*/
	threadpool.create_thread(
		boost::bind(&boost::asio::io_service::run, &ioService)
	);


	threadpool.join_all();

	
	return 0;
}