Add Initial SOCKS5 support

SOCKS.cpp

@@ -6,6 +6,7 @@
 #include "I2PEndian.h"
 #include <cstring>
 #include <cassert>
+#include <vector>
 
 namespace i2p
 {
@@ -14,34 +15,103 @@ namespace proxy
 	const uint8_t socks_leaseset_timeout = 10;
 	const uint8_t socks_timeout = 60;
 
-	void SOCKS4AHandler::AsyncSockRead()
+	void SOCKSHandler::AsyncSockRead()
 	{
 		LogPrint(eLogDebug,"--- SOCKS async sock read");
 		if(m_sock) {
 			m_sock->async_receive(boost::asio::buffer(m_sock_buff, socks_buffer_size),
-						std::bind(&SOCKS4AHandler::HandleSockRecv, this,
+						std::bind(&SOCKSHandler::HandleSockRecv, this,
 								std::placeholders::_1, std::placeholders::_2));
 		} else {
 			LogPrint(eLogError,"--- SOCKS no socket for read");
 		}
 	}
 
-	void SOCKS4AHandler::Terminate() {
+	void SOCKSHandler::Terminate() {
 		CloseStream();
 		CloseSock();
 		delete this; // HACK: ew
 	}
 
-	void SOCKS4AHandler::SocksFailed()
+	void SOCKSHandler::Socks5AuthNegoFailed()
 	{
-		LogPrint(eLogWarning,"--- SOCKS failed");
+		LogPrint(eLogWarning,"--- SOCKS5 authentication negotiation failed");
-		//TODO: send the right response
+		boost::asio::async_write(*m_sock, boost::asio::buffer("\x05\xff",2),
-		boost::asio::async_write(*m_sock, boost::asio::buffer("\x00\x5b 12345"),
+					 std::bind(&SOCKSHandler::SentSocksFailed, this,
-					 std::bind(&SOCKS4AHandler::SentSocksFailed, this,
 						     std::placeholders::_1));
 	}
 
-	void SOCKS4AHandler::CloseSock()
+	void SOCKSHandler::Socks5ChooseAuth()
+	{
+		LogPrint(eLogDebug,"--- SOCKS5 choosing authentication method");
+		//TODO: Choose right method
+		boost::asio::async_write(*m_sock, boost::asio::buffer("\x05\x00",2),
+					 std::bind(&SOCKSHandler::SentSocksResponse, this,
+						     std::placeholders::_1, nullptr));
+	}
+
+	static const char *socks5Replies[9] = {
+		"\x05\x00\x00\x01\x00\x00\x00\x00\x00\x00",
+		"\x05\x01\x00\x01\x00\x00\x00\x00\x00\x00",
+		"\x05\x02\x00\x01\x00\x00\x00\x00\x00\x00",
+		"\x05\x03\x00\x01\x00\x00\x00\x00\x00\x00",
+		"\x05\x04\x00\x01\x00\x00\x00\x00\x00\x00",
+		"\x05\x05\x00\x01\x00\x00\x00\x00\x00\x00",
+		"\x05\x06\x00\x01\x00\x00\x00\x00\x00\x00",
+		"\x05\x07\x00\x01\x00\x00\x00\x00\x00\x00",
+		"\x05\x08\x00\x01\x00\x00\x00\x00\x00\x00" };
+
+	/* All hope is lost */
+	void SOCKSHandler::SocksRequestFailed()
+	{
+		switch (m_socksv) {
+			case 4:
+				LogPrint(eLogWarning,"--- SOCKS4 failed");
+				//TODO: send the right response
+				boost::asio::async_write(*m_sock, boost::asio::buffer("\x00\x5b\x00\x00\x00\x00\x00\x00",8),
+							std::bind(&SOCKSHandler::SentSocksFailed, this, std::placeholders::_1));
+				break;
+			case 5:
+				assert(m_error <= 8);
+				LogPrint(eLogWarning,"--- SOCKS5 failed");
+				//TODO: use error properly and address type m_error
+				boost::asio::async_write(*m_sock, boost::asio::buffer(socks5Replies[m_error],10),
+							std::bind(&SOCKSHandler::SentSocksFailed, this, std::placeholders::_1));
+				break;
+			default:
+				LogPrint (eLogError,"--- SOCKS had invalid version");
+				Terminate();
+				break;
+		}
+	}
+
+	void SOCKSHandler::SocksRequestSuccess()
+	{
+		std::shared_ptr<std::vector<uint8_t>> response(new std::vector<uint8_t>);
+		switch (m_socksv) {
+			case 4:
+				LogPrint(eLogInfo,"--- SOCKS4 connection success");
+				//TODO: send the right response
+				boost::asio::async_write(*m_sock, boost::asio::buffer("\x00\x5a\x00\x00\x00\x00\x00\x00",8),
+							std::bind(&SOCKSHandler::SentSocksResponse, this,
+								std::placeholders::_1, nullptr));
+				break;
+			case 5:
+				LogPrint(eLogInfo,"--- SOCKS5 connection success");
+				//TODO: send the right response using the port? and the localside i2p address
+				boost::asio::async_write(*m_sock, boost::asio::buffer("\x05\x00\x00\x01\x00\x00\x00\x00\x00\x00",10),
+							std::bind(&SOCKSHandler::SentSocksResponse, this,
+								std::placeholders::_1, response));
+				break;
+			default:
+				LogPrint (eLogError,"--- SOCKS had invalid version");
+				Terminate();
+				break;
+		}
+	}
+
+
+	void SOCKSHandler::CloseSock()
 	{
 		if (m_sock) {
 			LogPrint(eLogDebug,"--- SOCKS close sock");
@@ -51,7 +121,7 @@ namespace proxy
 		}
 	}
 
-       void SOCKS4AHandler::CloseStream()
+       void SOCKSHandler::CloseStream()
        {
                if (m_stream) {
                        LogPrint(eLogDebug,"--- SOCKS close stream");
@@ -63,7 +133,7 @@ namespace proxy
 	const size_t socks_ident_size = 1024;
 	const size_t destb32_len = 52;
 
-	std::size_t SOCKS4AHandler::HandleData(uint8_t *sock_buff, std::size_t len)
+	std::size_t SOCKSHandler::HandleData(uint8_t *sock_buff, std::size_t len)
 	{
 		assert(len); // This should always be called with a least a byte left to parse
 		switch (m_state) {
@@ -71,6 +141,10 @@ namespace proxy
 				return HandleVersion(sock_buff);
 			case SOCKS4A:
 				return HandleSOCKS4A(sock_buff,len);
+			case SOCKS5_S1:
+				return HandleSOCKS5Step1(sock_buff,len);
+			case SOCKS5_S3:
+				return HandleSOCKS5Step3(sock_buff,len);
 			default:
 				LogPrint(eLogError,"--- SOCKS state?? ", m_state);
 				Terminate();
@@ -78,12 +152,18 @@ namespace proxy
 		}
 	}
 
-	std::size_t SOCKS4AHandler::HandleVersion(uint8_t *sock_buff)
+	std::size_t SOCKSHandler::HandleVersion(uint8_t *sock_buff)
 	{
 		switch (*sock_buff) {
 			case 4:
 				m_state = SOCKS4A; // Switch to the 4a handler
 				m_pstate = GET4A_COMMAND; //Initialize the parser at the right position
+				m_socksv = 4;
+				return 1;
+			case 5:
+				m_state = SOCKS5_S1; // Switch to the 4a handler
+				m_pstate = GET5_AUTHNUM; //Initialize the parser at the right position
+				m_socksv = 5;
 				return 1;
 			default:
 				LogPrint(eLogError,"--- SOCKS rejected invalid version", ((int)*sock_buff));
@@ -92,7 +172,7 @@ namespace proxy
 		}
 	}
 
-	std::size_t SOCKS4AHandler::HandleSOCKS4A(uint8_t *sock_buff, std::size_t len)
+	std::size_t SOCKSHandler::HandleSOCKS4A(uint8_t *sock_buff, std::size_t len)
 	{
 		std::size_t rv = 0;
 		while (len > 0) {
@@ -103,7 +183,7 @@ namespace proxy
 					if ( *sock_buff != 1 ) {
 						//TODO: we need to support binds and other shit!
 						LogPrint(eLogError,"--- SOCKS4a unsupported command", ((int)*sock_buff));
-						SocksFailed();
+						SocksRequestFailed();
 						return 0;
 					}
 					m_pstate = GET4A_PORT1;
@@ -133,7 +213,7 @@ namespace proxy
 					m_pstate = GET4A_IDENT;
 					if( m_ip == 0 || m_ip > 255 ) {
 						LogPrint(eLogError,"--- SOCKS4a rejected because it's actually SOCKS4");
-						SocksFailed();
+						SocksRequestFailed();
 						return 0;
 					}
 					break;
@@ -145,11 +225,12 @@ namespace proxy
 					if (!*sock_buff) {
 						m_pstate = DONE;
 						m_state = READY;
+						m_need_more = false;
 						return rv;
 					}
 					if (m_destination.size() > HOST_NAME_MAX) {
 						LogPrint(eLogError,"--- SOCKS4a destination is too large ");
-						SocksFailed();
+						SocksRequestFailed();
 						return 0;
 					}
 					m_destination.push_back(*sock_buff);
@@ -165,7 +246,125 @@ namespace proxy
 		return rv;
 	}
 
-	void SOCKS4AHandler::HandleSockRecv(const boost::system::error_code & ecode, std::size_t len)
+	std::size_t SOCKSHandler::HandleSOCKS5Step1(uint8_t *sock_buff, std::size_t len)
+	{
+		std::size_t rv = 0;
+		while (len > 0) {
+			rv++;
+			switch (m_pstate)
+			{
+				case GET5_AUTHNUM:
+					m_authleft = *sock_buff;
+					m_pstate = GET5_AUTH;
+					break;
+				case GET5_AUTH:
+					m_authleft --;
+					if (*sock_buff == 0)
+						m_authchosen = 0;
+					if ( m_authleft == 0 ) {
+						if (m_authchosen == 0xff) {
+							//TODO: we maybe want support for other methods!
+							LogPrint(eLogError,"--- SOCKS5 couldn't negotiate authentication");
+							Socks5AuthNegoFailed();
+							return 0;
+						}
+						m_pstate = GET5_REQUESTV;
+						m_state = SOCKS5_S3;
+						m_need_more = false;
+						Socks5ChooseAuth();
+						return rv;
+					}
+					break;
+				default:
+					LogPrint(eLogError,"--- SOCKS5 parse state?? ", m_pstate);
+					Terminate();
+					return 0;
+			}
+			sock_buff++;
+			len--;
+		}
+		return rv;
+	}
+
+	//TODO this may be merged with the SOCKS4a code
+	std::size_t SOCKSHandler::HandleSOCKS5Step3(uint8_t *sock_buff, std::size_t len)
+	{
+		std::size_t rv = 0;
+		while (len > 0) {
+			rv++;
+			switch (m_pstate)
+			{
+				case GET5_REQUESTV:
+					if (*sock_buff != 5) {
+						LogPrint(eLogError,"--- SOCKS rejected unknown request version", ((int)*sock_buff));
+						m_error = 0x7;
+						SocksRequestFailed();
+						return 0;
+					}
+					m_pstate = GET5_COMMAND;
+					break;
+				case GET5_COMMAND:
+					if ( *sock_buff != 1 ) {
+						//TODO: we need to support binds and other shit!
+						LogPrint(eLogError,"--- SOCKS5 unsupported command", ((int)*sock_buff));
+						m_error = 0x7;
+						SocksRequestFailed();
+						return 0;
+					}
+					m_pstate = GET5_GETRSV;
+					break;
+				case GET5_GETRSV:
+					if ( *sock_buff != 0 ) {
+						LogPrint(eLogError,"--- SOCKS5 unknown reserved field", ((int)*sock_buff));
+						m_error = 0x7;
+						SocksRequestFailed();
+						return 0;
+					}
+					m_pstate = GET5_GETADDRTYPE;
+					break;
+				case GET5_GETADDRTYPE:
+					if ( *sock_buff != 0x3 ) {
+						//TODO: we may want to support other address types!
+						LogPrint(eLogError,"--- SOCKS5 unsupported address type", ((int)*sock_buff));
+						m_error = 0x8;
+						SocksRequestFailed();
+						return 0;
+					}
+					m_pstate = GET5_HOST_SIZE;
+					break;
+				case GET5_HOST_SIZE:
+					m_addrleft = *sock_buff;
+					m_pstate = GET5_HOST;
+					break;
+				case GET5_HOST:
+					m_destination.push_back(*sock_buff);
+					m_addrleft--;
+					if (m_addrleft == 0)
+						m_pstate = GET5_PORT1;
+					break;
+				case GET5_PORT1:
+					m_port = ((uint16_t)*sock_buff) << 8;
+					m_pstate = GET5_PORT2;
+					break;
+				case GET5_PORT2:
+					m_port |= ((uint16_t)*sock_buff);
+					m_pstate = DONE;
+					m_state = READY;
+					m_need_more = false;
+					return rv;
+					break;
+				default:
+					LogPrint(eLogError,"--- SOCKS5 parse state?? ", m_pstate);
+					Terminate();
+					return 0;
+			}
+			sock_buff++;
+			len--;
+		}
+		return rv;
+	}
+
+	void SOCKSHandler::HandleSockRecv(const boost::system::error_code & ecode, std::size_t len)
 	{
 		LogPrint(eLogDebug,"--- SOCKS sock recv: ", len);
 		if(ecode) {
@@ -175,109 +374,105 @@ namespace proxy
 		}
 
 		std::size_t pos = 0;
-		while (pos != len && m_state != READY) {
+		m_need_more = true;
+		while (pos != len && m_state != READY && m_need_more) {
 			assert(pos < len); //We are overflowing the buffer otherwise
 			std::size_t rv = HandleData(m_sock_buff + pos, len - pos);
 			if (!rv) return; //Something went wrong die misserably
 			pos += rv;
 		}
 
+		assert(!(m_state == READY && m_need_more));
+
 		if (m_state == READY) {
 			LogPrint(eLogInfo,"--- SOCKS requested ", m_destination, ":" , m_port);
 			if (pos != len) {
 				LogPrint(eLogError,"--- SOCKS rejected because be can't handle extra data");
-				SocksFailed();
+				SocksRequestFailed();
 				return ;
 			}
 			if(m_destination.find(".i2p") == std::string::npos) {
 				LogPrint(eLogError,"--- SOCKS invalid hostname: ", m_destination);
-				SocksFailed();
+				SocksRequestFailed();
 				return;
 			}
 
 			m_parent->GetLocalDestination ()->CreateStream (
-					std::bind (&SOCKS4AHandler::HandleStreamRequestComplete,
+					std::bind (&SOCKSHandler::HandleStreamRequestComplete,
 					this, std::placeholders::_1), m_destination, m_port);
-		}
+		} else if (m_need_more)
+			AsyncSockRead();
 	}
 
-	void SOCKS4AHandler::ConnectionSuccess()
+	void SOCKSHandler::SentSocksFailed(const boost::system::error_code & ecode)
-	{
-		LogPrint(eLogInfo,"--- SOCKS connection success");
-		//TODO: send the right response
-		boost::asio::async_write(*m_sock, boost::asio::buffer("\x00\x5a 12345"),
-					 std::bind(&SOCKS4AHandler::SentConnectionSuccess, this,
-						     std::placeholders::_1));
-	}
-
-	void SOCKS4AHandler::SentSocksFailed(const boost::system::error_code & ecode)
 	{
 		if (!ecode) {
 			Terminate();
-		}
+		} else {
-		else
-		{
 			LogPrint (eLogError,"--- SOCKS Closing socket after sending failure because: ", ecode.message ());
 			Terminate();
 		}
 	}
 	
-	void SOCKS4AHandler::SentConnectionSuccess(const boost::system::error_code & ecode)
+	void SOCKSHandler::SentSocksResponse(const boost::system::error_code & ecode, std::shared_ptr<std::vector<uint8_t>> response)
 	{
+		response.reset(); // Information wants to be free, so does memory
 		if (!ecode) {
-			LogPrint (eLogInfo,"--- SOCKS New I2PTunnel connection");
+			if(m_state == READY) {
-			auto connection = std::make_shared<i2p::client::I2PTunnelConnection>((i2p::client::I2PTunnel *)m_parent, m_sock, m_stream);
+				LogPrint (eLogInfo,"--- SOCKS New I2PTunnel connection");
-			m_parent->AddConnection (connection);
+				auto connection = std::make_shared<i2p::client::I2PTunnelConnection>((i2p::client::I2PTunnel *)m_parent, m_sock, m_stream);
-			connection->I2PConnect ();
+				m_parent->AddConnection (connection);
+				connection->I2PConnect ();
+			} else {
+				AsyncSockRead();
+			}
 		}
 		else
 		{
-			LogPrint (eLogError,"--- SOCKS Closing socket after sending success because: ", ecode.message ());
+			LogPrint (eLogError,"--- SOCKS Closing socket after sending reply because: ", ecode.message ());
 			Terminate();
 		}
 	}
 	
-	void SOCKS4AHandler::HandleStreamRequestComplete (std::shared_ptr<i2p::stream::Stream> stream)
+	void SOCKSHandler::HandleStreamRequestComplete (std::shared_ptr<i2p::stream::Stream> stream)
 	{
-		if (stream)
+		if (stream) {
-		{
 			m_stream = stream;
-			ConnectionSuccess();
+			SocksRequestSuccess();
-		}
+		} else {
-		else
+			m_error = 0x4;
-		{
 			LogPrint (eLogError,"--- SOCKS Issue when creating the stream, check the previous warnings for more info.");
-			SocksFailed();
+			SocksRequestFailed();
 		}
 	}
 
 
-	void SOCKS4AServer::Start ()
+	void SOCKSServer::Start ()
 	{
 		m_Acceptor.listen ();
 		Accept ();
 	}
 
-	void SOCKS4AServer::Stop ()
+	void SOCKSServer::Stop ()
 	{
 		m_Acceptor.close();
 		m_Timer.cancel ();
 		ClearConnections ();
 	}
 
-	void SOCKS4AServer::Accept ()
+	void SOCKSServer::Accept ()
 	{
 		auto newSocket = new boost::asio::ip::tcp::socket (GetService ());
-		m_Acceptor.async_accept (*newSocket, std::bind (&SOCKS4AServer::HandleAccept, this,
+		m_Acceptor.async_accept (*newSocket, std::bind (&SOCKSServer::HandleAccept, this,
 			std::placeholders::_1, newSocket));
 	}	
 
-	void SOCKS4AServer::HandleAccept (const boost::system::error_code& ecode, boost::asio::ip::tcp::socket * socket)
+	void SOCKSServer::HandleAccept (const boost::system::error_code& ecode, boost::asio::ip::tcp::socket * socket)
 	{
 		if (!ecode)
 		{
 			LogPrint(eLogDebug,"--- SOCKS accepted");
-			new SOCKS4AHandler(this, socket);
+			new SOCKSHandler(this, socket);
 			Accept();
 		}
 		else

SOCKS.h

@@ -29,13 +29,16 @@ namespace proxy
 
 	const size_t socks_buffer_size = 8192;
 
-	class SOCKS4AServer;
+	class SOCKSServer;
-	class SOCKS4AHandler {
+	class SOCKSHandler {
 
 		private:
 			enum state {
 				GET_VERSION,
 				SOCKS4A,
+				SOCKS5_S1, //Authentication negotiation
+				SOCKS5_S2, //Authentication
+				SOCKS5_S3, //Request
 				READY
 			};
 			enum parseState {
@@ -48,6 +51,36 @@ namespace proxy
 				GET4A_IP4,
 				GET4A_IDENT,
 				GET4A_HOST,
+				GET5_AUTHNUM,
+				GET5_AUTH,
+				GET5_REQUESTV,
+				GET5_COMMAND,
+				GET5_GETRSV,
+				GET5_GETADDRTYPE,
+				GET5_IPV4_1,
+				GET5_IPV4_2,
+				GET5_IPV4_3,
+				GET5_IPV4_4,
+				GET5_IPV6_1,
+				GET5_IPV6_2,
+				GET5_IPV6_3,
+				GET5_IPV6_4,
+				GET5_IPV6_5,
+				GET5_IPV6_6,
+				GET5_IPV6_7,
+				GET5_IPV6_8,
+				GET5_IPV6_9,
+				GET5_IPV6_10,
+				GET5_IPV6_11,
+				GET5_IPV6_12,
+				GET5_IPV6_13,
+				GET5_IPV6_14,
+				GET5_IPV6_15,
+				GET5_IPV6_16,
+				GET5_HOST_SIZE,
+				GET5_HOST,
+				GET5_PORT1,
+				GET5_PORT2,
 				DONE
 			};
 
@@ -55,20 +88,25 @@ namespace proxy
 			std::size_t HandleData(uint8_t *sock_buff, std::size_t len);
 			std::size_t HandleVersion(uint8_t *sock_buff);
 			std::size_t HandleSOCKS4A(uint8_t *sock_buff, std::size_t len);
+			std::size_t HandleSOCKS5Step1(uint8_t *sock_buff, std::size_t len);
+			std::size_t HandleSOCKS5Step3(uint8_t *sock_buff, std::size_t len);
 			void HandleSockRecv(const boost::system::error_code & ecode, std::size_t bytes_transfered);
 			void Terminate();
 			void CloseSock();
 			void CloseStream();
 			void AsyncSockRead();
-			void SocksFailed();
+			void Socks5AuthNegoFailed();
+			void Socks5ChooseAuth();
+			void SocksRequestFailed();
+			void SocksRequestSuccess();
 			void SentSocksFailed(const boost::system::error_code & ecode);
-			void SentConnectionSuccess(const boost::system::error_code & ecode);
+			//HACK: we need to pass the shared_ptr to ensure the buffer will live enough
-			void ConnectionSuccess();
+			void SentSocksResponse(const boost::system::error_code & ecode, std::shared_ptr<std::vector<uint8_t>> response);
 			void HandleStreamRequestComplete (std::shared_ptr<i2p::stream::Stream> stream);
 
 			uint8_t m_sock_buff[socks_buffer_size];
             
-			SOCKS4AServer * m_parent;
+			SOCKSServer * m_parent;
 			boost::asio::ip::tcp::socket * m_sock;
 			std::shared_ptr<i2p::stream::Stream> m_stream;
 			state m_state;
@@ -77,23 +115,31 @@ namespace proxy
 			uint16_t m_port;
 			uint32_t m_ip;
 			std::string m_destination;
-		
+			uint8_t m_authleft; //Authentication methods left
-            
+			//TODO: this will probably be more elegant as enums
+			uint8_t m_authchosen; //Authentication chosen
+			uint8_t m_addrtype; //Address type chosen
+			uint8_t m_addrleft; //Address type chosen
+			uint8_t m_error; //Address type chosen
+			uint8_t m_socksv; //Address type chosen
+			bool m_need_more; //Address type chosen
+
 		public:
-			SOCKS4AHandler(SOCKS4AServer * parent, boost::asio::ip::tcp::socket * sock) : 
+			SOCKSHandler(SOCKSServer * parent, boost::asio::ip::tcp::socket * sock) : 
-				m_parent(parent), m_sock(sock), m_stream(nullptr), m_state(GET_VERSION)
+				m_parent(parent), m_sock(sock), m_stream(nullptr), m_state(GET_VERSION),
+				m_authchosen(0xff), m_addrtype(0x01), m_error(0x01)
 				{ AsyncSockRead(); m_destination.reserve(HOST_NAME_MAX+1); }
 
-			~SOCKS4AHandler() { CloseSock(); CloseStream(); }
+			~SOCKSHandler() { CloseSock(); CloseStream(); }
 	};
 
-	class SOCKS4AServer: public i2p::client::I2PTunnel
+	class SOCKSServer: public i2p::client::I2PTunnel
 	{
 		public:
-			SOCKS4AServer(int port) : I2PTunnel(nullptr),
+			SOCKSServer(int port) : I2PTunnel(nullptr),
 				m_Acceptor (GetService (), boost::asio::ip::tcp::endpoint (boost::asio::ip::tcp::v4(), port)),
 				m_Timer (GetService ()) {};
-			~SOCKS4AServer() { Stop(); }
+			~SOCKSServer() { Stop(); }
 
 			void Start ();
 			void Stop ();
@@ -109,7 +155,7 @@ namespace proxy
 			boost::asio::deadline_timer m_Timer;
 	};	
 
-	typedef SOCKS4AServer SOCKSProxy;
+	typedef SOCKSServer SOCKSProxy;
 }
 }