Merge pull request #81 from majestrate/pull-request-0

socks proxy

Daemon.cpp

@@ -15,6 +15,7 @@
 #include "Streaming.h"
 #include "HTTPServer.h"
 #include "HTTPProxy.h"
+#include "SOCKS.h"
 
 namespace i2p
 {
@@ -23,14 +24,16 @@ namespace i2p
 		class Daemon_Singleton::Daemon_Singleton_Private
 		{
 		public:
-			Daemon_Singleton_Private() : httpServer(nullptr), httpProxy(nullptr) { };
+			Daemon_Singleton_Private() : httpServer(nullptr), httpProxy(nullptr), socksProxy(nullptr) { };
 			~Daemon_Singleton_Private() {
 				delete httpServer;
 				delete httpProxy;
+				delete socksProxy;
 			};
 
 			i2p::util::HTTPServer *httpServer;
 			i2p::proxy::HTTPProxy *httpProxy;
+			i2p::proxy::SOCKSProxy *socksProxy;
 		};
 
 		Daemon_Singleton::Daemon_Singleton() : running(1), d(*new Daemon_Singleton_Private()) {};
@@ -83,7 +86,7 @@ namespace i2p
 
 			d.httpServer = new i2p::util::HTTPServer(i2p::util::config::GetArg("-httpport", 7070));
 			d.httpServer->Start();
-			LogPrint("HTTPServer started");
+			LogPrint("HTTP Server started");
 
 			i2p::data::netdb.Start();
 			LogPrint("NetDB started");
@@ -98,8 +101,10 @@ namespace i2p
 
 			d.httpProxy = new i2p::proxy::HTTPProxy(i2p::util::config::GetArg("-httpproxyport", 4446));
 			d.httpProxy->Start();
-			LogPrint("Proxy started");
+			LogPrint("HTTP Proxy started");
-
+			d.socksProxy = new i2p::proxy::SOCKSProxy(i2p::util::config::GetArg("-socksproxyport", 4447));
+			d.socksProxy->Start();
+			LogPrint("SOCKS Proxy Started");
 			return true;
 		}
 
@@ -108,7 +113,9 @@ namespace i2p
 			LogPrint("Shutdown started.");
 
 			d.httpProxy->Stop();
-			LogPrint("HTTPProxy stoped");
+			LogPrint("HTTP Proxy stoped");
+			d.socksProxy->Stop();
+			LogPrint("SOCKS Proxy stoped");
 			i2p::stream::StopStreaming();
 			LogPrint("Streaming stoped");
 			i2p::garlic::routing.Stop();
@@ -120,9 +127,9 @@ namespace i2p
 			i2p::data::netdb.Stop();
 			LogPrint("NetDB stoped");
 			d.httpServer->Stop();
-			LogPrint("HTTPServer stoped");
+			LogPrint("HTTP Server stoped");
 			StopLog ();
-
+                        delete d.socksProxy; d.socksProxy = nullptr;
 			delete d.httpProxy; d.httpProxy = nullptr;
 			delete d.httpServer; d.httpServer = nullptr;
 

Makefile

@@ -6,7 +6,7 @@ OBJECTS = obj/CryptoConst.o obj/base64.o obj/NTCPSession.o obj/RouterInfo.o obj/
     obj/TunnelGateway.o obj/TransitTunnel.o obj/I2NPProtocol.o obj/Log.o obj/Garlic.o \
     obj/HTTPServer.o obj/Streaming.o obj/Identity.o obj/SSU.o obj/util.o obj/Reseed.o \
     obj/UPnP.o obj/TunnelPool.o obj/HTTPProxy.o obj/AddressBook.o  obj/Daemon.o \
-    obj/DaemonLinux.o obj/SSUData.o obj/i2p.o obj/aes.o
+    obj/DaemonLinux.o obj/SSUData.o obj/i2p.o obj/aes.o obj/SOCKS.o
 INCFLAGS = 
 LDFLAGS = -Wl,-rpath,/usr/local/lib -lcryptopp -lboost_system -lboost_filesystem -lboost_regex -lboost_program_options -lpthread
 LIBS = 

SOCKS.cpp

@@ -0,0 +1,282 @@
+#include "SOCKS.h"
+#include "Identity.h"
+#include "NetDb.h"
+#include <cstring>
+#include <stdexcept>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/bind.hpp>
+
+namespace i2p
+{
+namespace proxy
+{
+	constexpr uint8_t socks_leaseset_timeout = 10;
+	constexpr uint8_t socks_timeout = 60;
+		
+	void SOCKS4AHandler::AsyncSockRead()
+	{
+		LogPrint("--- socks4a async sock read");
+		if(m_sock) {
+			if (m_state == INITIAL) {
+				m_sock->async_receive(boost::asio::buffer(m_sock_buff, socks_buffer_size),
+						      boost::bind(&SOCKS4AHandler::HandleSockRecv, this,
+								  boost::asio::placeholders::error,
+								  boost::asio::placeholders::bytes_transferred));
+			} else { 
+				m_sock->async_receive(boost::asio::buffer(m_sock_buff, socks_buffer_size),
+						      boost::bind(&SOCKS4AHandler::HandleSockForward, this,
+								  boost::asio::placeholders::error,
+								  boost::asio::placeholders::bytes_transferred));
+			}
+		} else {
+			LogPrint("--- socks4a no socket for read");
+		}
+	}
+	
+	void SOCKS4AHandler::AsyncStreamRead()
+	{
+		
+		LogPrint("--- socks4a async stream read");
+		if (m_stream) {
+			m_stream->AsyncReceive(
+				boost::asio::buffer(m_stream_buff, socks_buffer_size),
+				boost::bind(&SOCKS4AHandler::HandleStreamRecv, this,
+					    boost::asio::placeholders::error, 
+					    boost::asio::placeholders::bytes_transferred), socks_timeout);
+		} else {
+			LogPrint("--- socks4a no stream for read");
+		}
+	}
+
+        void SOCKS4AHandler::Terminate() {
+                CloseStream();
+                CloseSock();
+                delete this; // ew
+        }
+	
+	void SOCKS4AHandler::SocksFailed()
+	{
+		LogPrint("--- socks4a failed");
+		m_sock->send(boost::asio::buffer("\x00\x5b 12345"));
+		Terminate();
+	}
+	
+	void SOCKS4AHandler::CloseSock()
+	{
+		if (m_sock) {
+			LogPrint("--- socks4a close sock");
+			m_sock->close();
+			delete m_sock;
+			m_sock = nullptr;
+		}
+	}
+
+	void SOCKS4AHandler::CloseStream()
+	{
+		if (m_stream) {
+			LogPrint("--- socks4a close stream");
+			delete m_stream;
+			m_stream = nullptr;
+		}
+	}
+
+	constexpr size_t socks_hostname_size = 1024;
+	constexpr size_t socks_ident_size = 1024;
+	constexpr size_t destb32_len = 52;
+	
+	void SOCKS4AHandler::HandleSockForward(const boost::system::error_code & ecode, std::size_t len)
+	{
+		if(ecode) {
+			LogPrint("--- socks4a forward got error: ", ecode);
+			Terminate();
+			return;
+		}
+		
+		LogPrint("--- socks4a sock forward: ", len);
+		m_stream->Send(m_sock_buff, len, 1);
+	}
+
+	void SOCKS4AHandler::HandleSockRecv(const boost::system::error_code & ecode, std::size_t len)
+	{
+		LogPrint("--- socks4a sock recv: ", len);
+		
+		if(ecode) {
+			LogPrint(" --- sock recv got error: ", ecode);
+                        Terminate();
+			return;
+		}
+
+		if (m_state == INITIAL) {
+
+			char hostbuff[socks_hostname_size];
+			char identbuff[socks_ident_size];
+			std::memset(hostbuff, 0, sizeof(hostbuff));
+			std::memset(identbuff, 0, sizeof(hostbuff));
+			std::string dest;
+			// get port
+			uint16_t port = 0;
+			uint16_t idx1 = 0;
+			uint16_t idx2 = 0;
+				
+			LogPrint("--- socks4a state initial ", len);
+
+			// check valid request
+			if( m_sock_buff[0] != 4 || m_sock_buff[1] != 1 || m_sock_buff[len-1] ) {
+				LogPrint("--- socks4a rejected invalid");
+				SocksFailed();
+				return;
+			}
+
+			// get port
+			port = m_sock_buff[3] | m_sock_buff[2] << 8;
+
+			// read ident 
+			do {
+				LogPrint("--- socks4a ", (int) m_sock_buff[9+idx1]);
+				identbuff[idx1] = m_sock_buff[8+idx1];
+			} while( identbuff[idx1++] && idx1 < socks_ident_size );
+
+			LogPrint("--- socks4a ident ", identbuff);
+			// read hostname
+			do {
+				hostbuff[idx2] = m_sock_buff[8+idx1+idx2];
+			} while( hostbuff[idx2++] && idx2 < socks_hostname_size );
+
+			LogPrint("--- socks4a requested ", hostbuff, ":" , port);
+
+			dest = std::string(hostbuff);
+			if(dest.find(".b32.i2p") == std::string::npos) {
+				LogPrint("--- socks4a invalid hostname: ", dest);
+				SocksFailed();
+				return;
+			}
+				
+			if ( i2p::data::Base32ToByteStream(hostbuff, destb32_len, (uint8_t *) m_dest, 32) != 32 ) {
+				LogPrint("--- sock4a invalid b32: ", dest);
+			}
+			
+			LogPrint("--- sock4a find lease set");
+			m_ls = i2p::data::netdb.FindLeaseSet(m_dest);
+			if (!m_ls || m_ls->HasNonExpiredLeases()) {
+				i2p::data::netdb.Subscribe(m_dest);
+				m_ls_timer.expires_from_now(boost::posix_time::seconds(socks_leaseset_timeout));
+				m_ls_timer.async_wait(boost::bind(&SOCKS4AHandler::LeaseSetTimeout, this, boost::asio::placeholders::error));
+			} else {
+				ConnectionSuccess();
+			}
+		} else {
+			LogPrint("--- socks4a state?? ", m_state);
+		}
+	}
+	
+	void SOCKS4AHandler::HandleStreamRecv(const boost::system::error_code & ecode, std::size_t len)
+	{
+		if(ecode) { LogPrint("--- socks4a stream recv error: ", ecode); m_state = END; }
+		switch(m_state) {
+		case INITIAL:
+		case END:
+			Terminate();
+                        return;
+		case OKAY:
+			LogPrint("--- socks4a stream recv ", len);
+			boost::asio::async_write(*m_sock, boost::asio::buffer(m_stream_buff, len), 
+						 boost::bind(&SOCKS4AHandler::StreamWrote, this, 
+							     boost::asio::placeholders::error));
+		}
+	}
+	
+	void SOCKS4AHandler::SockWrote(const boost::system::error_code & ecode)
+	{
+		LogPrint("--- socks4a sock wrote");
+		if(ecode) { LogPrint("--- socks4a SockWrote error: ",ecode); }
+		else { AsyncSockRead(); }
+	}
+
+	void SOCKS4AHandler::StreamWrote(const boost::system::error_code & ecode)
+	{
+		
+		LogPrint("--- socks4a stream wrote");
+		if(ecode) { LogPrint("--- socks4a StreamWrote error: ",ecode); }
+		else { AsyncStreamRead(); }
+	}
+
+	void SOCKS4AHandler::LeaseSetTimeout(const boost::system::error_code & ecode)
+	{
+		m_ls = i2p::data::netdb.FindLeaseSet(m_dest);
+		if(m_ls) {
+			ConnectionSuccess();
+		} else {
+			LogPrint("--- socks4a ls timeout");
+			SocksFailed();
+		}
+	}
+
+	void SOCKS4AHandler::ConnectionSuccess()
+	{
+		LogPrint("--- socks4a connection success");
+		boost::asio::async_write(*m_sock, boost::asio::buffer("\x00\x5a 12345"),
+					 boost::bind(&SOCKS4AHandler::SentConnectionSuccess, this,
+						     boost::asio::placeholders::error));
+	}
+
+	void SOCKS4AHandler::SentConnectionSuccess(const boost::system::error_code & ecode)
+	{
+		LogPrint("--- socks4a making connection");
+		m_stream = i2p::stream::CreateStream(*m_ls);
+		m_state = OKAY;
+		LogPrint("--- socks4a state is ", m_state);
+		AsyncSockRead();
+		AsyncStreamRead();
+	}
+
+	void SOCKS4AServer::Run()
+	{
+		LogPrint("--- socks4a run");
+		m_run = true;
+		while(m_run) {
+			try {
+				m_ios.run();
+			} catch (std::runtime_error & exc) {
+				LogPrint("--- socks4a exception: ", exc.what());
+			}
+		}
+	}
+	
+	void SOCKS4AServer::Accept()
+	{
+		m_new_sock = new boost::asio::ip::tcp::socket(m_ios);
+		m_acceptor.async_accept(*m_new_sock, 
+					boost::bind(
+						&SOCKS4AServer::HandleAccept, this, boost::asio::placeholders::error));
+	}
+
+	void SOCKS4AServer::Start()
+	{
+                m_run = true;
+		m_thread = new std::thread(std::bind(&SOCKS4AServer::Run, this));
+		m_acceptor.listen();
+		Accept();
+	}
+	
+	void SOCKS4AServer::Stop()
+	{
+		m_acceptor.close();
+		m_run = false;
+		m_ios.stop();
+		if (m_thread) {
+			m_thread->join();
+			delete m_thread;
+			m_thread = nullptr;
+		}
+	}
+		
+	void SOCKS4AServer::HandleAccept(const boost::system::error_code & ecode)
+	{
+		if (!ecode) {
+			LogPrint("--- socks4a accepted");
+			new SOCKS4AHandler(&m_ios, m_new_sock);
+			Accept();
+		}
+	}
+}
+}

SOCKS.h

@@ -0,0 +1,98 @@
+#ifndef SOCKS4A_H__
+#define SOCKS4A_H__
+
+#include <thread>
+#include <boost/asio.hpp>
+#include <vector>
+#include <mutex>
+
+#include "Identity.h"
+#include "Streaming.h"
+
+namespace i2p
+{
+namespace proxy
+{
+
+	constexpr size_t socks_buffer_size = 8192;
+
+	class SOCKS4AHandler {
+
+		private:
+            enum state {
+                    INITIAL,
+                    OKAY,
+                    END
+            };
+
+            void GotClientRequest(boost::system::error_code & ecode, std::string & host, uint16_t port);
+            void HandleSockRecv(const boost::system::error_code & ecode, std::size_t bytes_transfered);
+            void HandleSockForward(const boost::system::error_code & ecode, std::size_t bytes_transfered);
+            void HandleStreamRecv(const boost::system::error_code & ecode, std::size_t bytes_transfered);
+            void Terminate();
+            void CloseSock();
+            void CloseStream();
+            void AsyncSockRead();
+            void AsyncStreamRead();
+            void SocksFailed();
+            void LeaseSetTimeout(const boost::system::error_code & ecode);
+            void StreamWrote(const boost::system::error_code & ecode);		  
+            void SockWrote(const boost::system::error_code & ecode);
+            void SentConnectionSuccess(const boost::system::error_code & ecode);
+            void ConnectionSuccess();
+            
+            uint8_t m_sock_buff[socks_buffer_size];
+            uint8_t m_stream_buff[socks_buffer_size];
+            
+            boost::asio::io_service * m_ios;
+            boost::asio::ip::tcp::socket * m_sock;
+            boost::asio::deadline_timer m_ls_timer;
+            i2p::stream::Stream * m_stream;
+            i2p::data::LeaseSet * m_ls;
+            i2p::data::IdentHash m_dest;
+            state m_state;
+		
+            
+		public:
+			SOCKS4AHandler(boost::asio::io_service * ios, boost::asio::ip::tcp::socket * sock) : 
+				m_ios(ios), m_sock(sock), m_ls_timer(*ios),
+				m_stream(nullptr), m_ls(nullptr), m_state(INITIAL) { AsyncSockRead(); }
+
+			~SOCKS4AHandler() { CloseSock(); CloseStream(); }
+			bool isComplete() { return m_state == END; }
+	};
+
+	class SOCKS4AServer {
+		public:
+			SOCKS4AServer(int port) : m_run(false), 
+									  m_thread(nullptr), 
+									  m_work(m_ios),
+									  m_acceptor(m_ios, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port)),
+									  m_new_sock(nullptr) { }
+			~SOCKS4AServer() { Stop(); }
+			void Start();
+			void Stop();
+		
+
+		private:
+		
+			void Run();
+			void Accept();
+			void HandleAccept(const boost::system::error_code& ecode);
+
+			bool m_run;
+			std::thread * m_thread;
+			boost::asio::io_service m_ios;
+			boost::asio::io_service::work m_work;
+            boost::asio::ip::tcp::acceptor m_acceptor;
+			boost::asio::ip::tcp::socket * m_new_sock;
+		
+
+	};
+
+	typedef SOCKS4AServer SOCKSProxy;
+}
+}
+
+
+#endif