Merge pull request #1478 from unlnown542a/openssl

add ntcp2proxy support

libi2pd/Config.cpp

@@ -61,6 +61,7 @@ namespace config {
 			("ntcp", value<bool>()->default_value(false),                      "Enable NTCP transport (default: disabled)")
 			("ssu", value<bool>()->default_value(true),                       "Enable SSU transport (default: enabled)")
 			("ntcpproxy", value<std::string>()->default_value(""),            "Proxy URL for NTCP transport")
+			("ntcp2proxy", value<std::string>()->default_value(""),           "Proxy URL for NTCP2 transport")
 #ifdef _WIN32
 			("svcctl", value<std::string>()->default_value(""),               "Windows service management ('install' or 'remove')")
 			("insomnia", bool_switch()->default_value(false),                 "Prevent system from sleeping (default: disabled)")

libi2pd/NTCP2.cpp

@@ -20,6 +20,8 @@
 #include "Transports.h"
 #include "NetDb.hpp"
 #include "NTCP2.h"
+#include "HTTP.h"
+#include "util.h"
 
 namespace i2p
 {
@@ -375,6 +377,78 @@ namespace transport
 		}
 	}
 
+	void NTCP2Server::AfterSocksHandshake(std::shared_ptr<NTCP2Session> conn, std::shared_ptr<boost::asio::deadline_timer> timer, const std::string & host, uint16_t port, RemoteAddressType addrtype)
+	{
+
+		// build request
+		size_t sz = 0;
+		uint8_t buff[256];
+		uint8_t readbuff[256];
+		buff[0] = 0x05;
+		buff[1] = 0x01;
+		buff[2] = 0x00;
+
+		if(addrtype == eIP4Address)
+		{
+			buff[3] = 0x01;
+			auto addr = boost::asio::ip::address::from_string(host).to_v4();
+			auto addrbytes = addr.to_bytes();
+			auto addrsize = addrbytes.size();
+			memcpy(buff+4, addrbytes.data(), addrsize);
+		}
+		else if (addrtype == eIP6Address)
+		{
+			buff[3] = 0x04;
+			auto addr = boost::asio::ip::address::from_string(host).to_v6();
+			auto addrbytes = addr.to_bytes();
+			auto addrsize = addrbytes.size();
+			memcpy(buff+4, addrbytes.data(), addrsize);
+		}
+		else if (addrtype == eHostname)
+		{
+			buff[3] = 0x03;
+			size_t addrsize = host.size();
+			sz = addrsize + 1 + 4;
+			if (2 + sz > sizeof(buff))
+			{
+				// too big
+				return;
+			}
+			buff[4] = (uint8_t) addrsize;
+			memcpy(buff+5, host.c_str(), addrsize);
+		}
+		htobe16buf(buff+sz, port);
+		sz += 2;
+		boost::asio::async_write(conn->GetSocket(), boost::asio::buffer(buff, sz), boost::asio::transfer_all(), [=](const boost::system::error_code & ec, std::size_t written) {
+			if(ec)
+			{
+				LogPrint(eLogError, "NTCP2: failed to write handshake to socks proxy ", ec.message());
+				return;
+			}
+		});
+
+		boost::asio::async_read(conn->GetSocket(), boost::asio::buffer(readbuff, 10), [=](const boost::system::error_code & e, std::size_t transferred) {
+			if(e)
+			{
+				LogPrint(eLogError, "NTCP2: socks proxy read error ", e.message());
+			}
+			else if(transferred == sz)
+			{
+				if( readbuff[1] == 0x00)
+				{
+					timer->cancel();
+					conn->ClientLogin();
+					return;
+				}
+			}
+			if(!e)
+				i2p::data::netdb.SetUnreachable (conn->GetRemoteIdentity ()->GetIdentHash (), true);
+			timer->cancel();
+			conn->Terminate();
+		});
+	}
+
+
 	NTCP2Session::~NTCP2Session ()
 	{
 		delete[] m_NextReceivedBuffer;
@@ -1094,6 +1168,150 @@ namespace transport
 		EncryptAndSendNextBuffer (payloadLen);
 	}
 
+	void NTCP2Server::UseProxy(ProxyType proxytype, const std::string & addr, uint16_t port)
+	{
+		m_ProxyType = proxytype;
+		m_ProxyAddress = addr;
+		m_ProxyPort = port;
+	}
+
+		void NTCP2Server::HandleProxyConnect(const boost::system::error_code& ecode, std::shared_ptr<NTCP2Session> conn, std::shared_ptr<boost::asio::deadline_timer> timer, const std::string & host, uint16_t port, RemoteAddressType addrtype)
+		{
+			if(ecode)
+			{
+				LogPrint(eLogWarning, "NTCP2: failed to connect to proxy ", ecode.message());
+				timer->cancel();
+				conn->Terminate();
+				return;
+			}
+			if(m_ProxyType == eSocksProxy)
+			{
+				// TODO: support username/password auth etc
+				uint8_t buff[3] = {0x05, 0x01, 0x00};
+				boost::asio::async_write(conn->GetSocket(), boost::asio::buffer(buff, 3), boost::asio::transfer_all(), [=] (const boost::system::error_code & ec, std::size_t transferred) {
+					(void) transferred;
+					if(ec)
+					{
+						LogPrint(eLogWarning, "NTCP2: socks5 write error ", ec.message());
+					}
+				});
+				uint8_t readbuff[2];
+				boost::asio::async_read(conn->GetSocket(), boost::asio::buffer(readbuff, 2), [=](const boost::system::error_code & ec, std::size_t transferred)
+				{
+					LogPrint(eLogError, "NTCP2:  ", transferred);
+					if(ec)
+					{
+						LogPrint(eLogError, "NTCP2: socks5 read error ", ec.message());
+						timer->cancel();
+						conn->Terminate();
+						return;
+					}
+					else if(transferred == 2)
+					{
+						if(readbuff[1] == 0xba)
+						{
+							AfterSocksHandshake(conn, timer, host, port, addrtype);
+							return;
+						}
+						else if (readbuff[1] == 0xff)
+						{
+							LogPrint(eLogError, "NTCP2: socks5 proxy rejected authentication");
+							timer->cancel();
+							conn->Terminate();
+							return;
+						}
+						LogPrint(eLogError, "NTCP2:", readbuff[1]);
+					}
+					LogPrint(eLogError, "NTCP2: socks5 server gave invalid response");
+					timer->cancel();
+					conn->Terminate();
+				});
+			}
+		else if(m_ProxyType == eHTTPProxy)
+		{
+			i2p::http::HTTPReq req;
+			req.method = "CONNECT";
+			req.version ="HTTP/1.1";
+			if(addrtype == eIP6Address)
+				req.uri = "[" + host + "]:" + std::to_string(port);
+			else
+				req.uri = host + ":" + std::to_string(port);
+
+			boost::asio::streambuf writebuff;
+			std::ostream out(&writebuff);
+			out << req.to_string();
+
+			boost::asio::async_write(conn->GetSocket(), writebuff.data(), boost::asio::transfer_all(), [=](const boost::system::error_code & ec, std::size_t transferred) {
+				(void) transferred;
+				if(ec)
+					LogPrint(eLogError, "NTCP2: http proxy write error ", ec.message());
+			});
+
+			boost::asio::streambuf * readbuff = new boost::asio::streambuf;
+			boost::asio::async_read_until(conn->GetSocket(), *readbuff, "\r\n\r\n", [=] (const boost::system::error_code & ec, std::size_t transferred) {
+				if(ec)
+				{
+					LogPrint(eLogError, "NTCP2: http proxy read error ", ec.message());
+					timer->cancel();
+					conn->Terminate();
+				}
+				else
+				{
+					readbuff->commit(transferred);
+					i2p::http::HTTPRes res;
+					if(res.parse(boost::asio::buffer_cast<const char*>(readbuff->data()), readbuff->size()) > 0)
+					{
+						if(res.code == 200)
+						{
+							timer->cancel();
+							conn->ClientLogin();
+							delete readbuff;
+							return;
+						}
+						else
+						{
+							LogPrint(eLogError, "NTCP2: http proxy rejected request ", res.code);
+						}
+					}
+					else
+						LogPrint(eLogError, "NTCP2: http proxy gave malformed response");
+					timer->cancel();
+					conn->Terminate();
+					delete readbuff;
+				}
+			});
+		}
+		else
+			LogPrint(eLogError, "NTCP2: unknown proxy type, invalid state");
+	}
+
+	void NTCP2Server::ConnectWithProxy (const std::string& host, uint16_t port, RemoteAddressType addrtype, std::shared_ptr<NTCP2Session> conn)
+	{
+		if(m_ProxyEndpoint == nullptr)
+		{
+			return;
+		}
+		GetService().post([=]() {
+			if (this->AddNTCP2Session (conn))
+			{
+
+				auto timer = std::make_shared<boost::asio::deadline_timer>(GetService());
+				auto timeout = NTCP_CONNECT_TIMEOUT * 5;
+				conn->SetTerminationTimeout(timeout * 2);
+				timer->expires_from_now (boost::posix_time::seconds(timeout));
+				timer->async_wait ([conn, timeout](const boost::system::error_code& ecode) {
+					if (ecode != boost::asio::error::operation_aborted)
+					{
+						LogPrint (eLogInfo, "NTCP2: Not connected in ", timeout, " seconds");
+						i2p::data::netdb.SetUnreachable (conn->GetRemoteIdentity ()->GetIdentHash (), true);
+						conn->Terminate ();
+					}
+				});
+				conn->GetSocket ().async_connect (*m_ProxyEndpoint, std::bind (&NTCP2Server::HandleProxyConnect, this, std::placeholders::_1, conn, timer, host, port, addrtype));
+			}
+		});
+	}
+
 	void NTCP2Session::SendTermination (NTCP2TerminationReason reason)
 	{
 		if (!m_SendKey || !m_SendSipKey) return;
@@ -1142,6 +1360,7 @@ namespace transport
 
 	NTCP2Server::NTCP2Server ():
 		RunnableServiceWithWork ("NTCP2"),
+		m_ProxyType(eNoProxy), m_Resolver(GetService ()), m_ProxyEndpoint(nullptr),
 		m_TerminationTimer (GetService ())
 	{
 	}
@@ -1156,6 +1375,29 @@ namespace transport
 		if (!IsRunning ())
 		{
 			StartIOService ();
+			if(UsingProxy())
+			{
+				LogPrint(eLogError, "NTCP2: USING PROXY ");
+				// TODO: resolve proxy until it is resolved
+				boost::asio::ip::tcp::resolver::query q(m_ProxyAddress, std::to_string(m_ProxyPort));
+				boost::system::error_code e;
+				auto itr = m_Resolver.resolve(q, e);
+				if(e)
+				{
+					LogPrint(eLogError, "NTCP2: Failed to resolve proxy ", e.message());
+				}
+				else
+				{
+					m_ProxyEndpoint = new boost::asio::ip::tcp::endpoint(*itr);
+					if (m_ProxyEndpoint)
+					{
+						LogPrint(eLogError, "NTCP2: m_ProxyEndpoint %s", m_ProxyEndpoint);
+					}
+				}
+			}
+			else
+			{
+				LogPrint(eLogError, "NTCP2: NOTUSING PROXY ");
 				auto& addresses = context.GetRouterInfo ().GetAddresses ();
 				for (const auto& address: addresses)
 				{
@@ -1199,6 +1441,7 @@ namespace transport
 						}
 					}
 				}
+			}
 			ScheduleTermination ();
 		}
 	}
@@ -1216,7 +1459,14 @@ namespace transport
 		m_NTCP2Sessions.clear ();
 
 		if (IsRunning ())
+		{
 			m_TerminationTimer.cancel ();
+			if(m_ProxyEndpoint)
+			{
+				delete m_ProxyEndpoint;
+				m_ProxyEndpoint = nullptr;
+			}
+		}
 		StopIOService ();
 	}
 
@@ -1391,4 +1641,3 @@ namespace transport
 	}
 }
 }
-

libi2pd/NTCP2.h

@@ -126,6 +126,7 @@ namespace transport
 	{
 		public:
 
+
 			NTCP2Session (NTCP2Server& server, std::shared_ptr<const i2p::data::RouterInfo> in_RemoteRouter = nullptr);
 			~NTCP2Session ();
 			void Terminate ();
@@ -220,6 +221,20 @@ namespace transport
 	{
 		public:
 
+			enum RemoteAddressType
+			{
+				eIP4Address,
+				eIP6Address,
+				eHostname
+			};
+
+			enum ProxyType
+			{
+				eNoProxy,
+				eSocksProxy,
+				eHTTPProxy
+			};
+
 			NTCP2Server ();
 			~NTCP2Server ();
 
@@ -231,14 +246,22 @@ namespace transport
 			void RemoveNTCP2Session (std::shared_ptr<NTCP2Session> session);
 			std::shared_ptr<NTCP2Session> FindNTCP2Session (const i2p::data::IdentHash& ident);
 
+			void ConnectWithProxy (const std::string& addr, uint16_t port, RemoteAddressType addrtype, std::shared_ptr<NTCP2Session> conn);
 			void Connect(const boost::asio::ip::address & address, uint16_t port, std::shared_ptr<NTCP2Session> conn);
 
+			void AfterSocksHandshake(std::shared_ptr<NTCP2Session> conn, std::shared_ptr<boost::asio::deadline_timer> timer, const std::string & host, uint16_t port, RemoteAddressType addrtype);
+
+
+			bool UsingProxy() const { return m_ProxyType != eNoProxy; };
+			void UseProxy(ProxyType proxy, const std::string & address, uint16_t port);
+
 		private:
 
 			void HandleAccept (std::shared_ptr<NTCP2Session> conn, const boost::system::error_code& error);
 			void HandleAcceptV6 (std::shared_ptr<NTCP2Session> conn, const boost::system::error_code& error);
 
 			void HandleConnect (const boost::system::error_code& ecode, std::shared_ptr<NTCP2Session> conn, std::shared_ptr<boost::asio::deadline_timer> timer);
+			void HandleProxyConnect(const boost::system::error_code& ecode, std::shared_ptr<NTCP2Session> conn, std::shared_ptr<boost::asio::deadline_timer> timer, const std::string & host, uint16_t port, RemoteAddressType adddrtype);
 
 			// timer
 			void ScheduleTermination ();
@@ -251,6 +274,12 @@ namespace transport
 			std::map<i2p::data::IdentHash, std::shared_ptr<NTCP2Session> > m_NTCP2Sessions;
 			std::list<std::shared_ptr<NTCP2Session> > m_PendingIncomingSessions;
 
+			ProxyType m_ProxyType;
+			std::string m_ProxyAddress;
+			uint16_t m_ProxyPort;
+			boost::asio::ip::tcp::resolver m_Resolver;
+			boost::asio::ip::tcp::endpoint * m_ProxyEndpoint;
+
 		public:
 
 			// for HTTP/I2PControl

libi2pd/Transports.cpp

@@ -157,6 +157,7 @@ namespace transport
 		m_IsRunning = true;
 		m_Thread = new std::thread (std::bind (&Transports::Run, this));
 		std::string ntcpproxy; i2p::config::GetOption("ntcpproxy", ntcpproxy);
+		std::string ntcp2proxy; i2p::config::GetOption("ntcp2proxy", ntcp2proxy);
 		i2p::http::URL proxyurl;
 		uint16_t softLimit, hardLimit, threads;
 		i2p::config::GetOption("limits.ntcpsoft", softLimit);
@@ -199,10 +200,33 @@ namespace transport
 		// create NTCP2. TODO: move to acceptor
 		bool ntcp2;  i2p::config::GetOption("ntcp2.enabled", ntcp2);
 		if (ntcp2)
+		{
+			if(ntcp2proxy.size())
+			{
+				if(proxyurl.parse(ntcp2proxy))
+				{
+					if(proxyurl.schema == "socks" || proxyurl.schema == "http")
 					{
 						m_NTCP2Server = new NTCP2Server ();
+						NTCP2Server::ProxyType proxytype = NTCP2Server::eSocksProxy;
+
+						if (proxyurl.schema == "http")
+							proxytype = NTCP2Server::eHTTPProxy;
+
+						m_NTCP2Server->UseProxy(proxytype, proxyurl.host, proxyurl.port) ;
 						m_NTCP2Server->Start();
 					}
+					else
+						LogPrint(eLogError, "Transports: unsupported NTCP2 proxy URL ", ntcp2proxy);
+				}
+				else
+					LogPrint(eLogError, "Transports: invalid NTCP2 proxy url ", ntcp2proxy);
+				return;
+			}
+
+		//	m_NTCP2Server = new NTCP2Server ();
+		//	m_NTCP2Server->Start ();
+		}
 
 		// create acceptors
 		auto& addresses = context.GetRouterInfo ().GetAddresses ();
@@ -415,6 +439,18 @@ namespace transport
                     if (address)
                     {
                         auto s = std::make_shared<NTCP2Session> (*m_NTCP2Server, peer.router);
+
+                        if(m_NTCP2Server->UsingProxy())
+                        {
+                            NTCP2Server::RemoteAddressType remote = NTCP2Server::eIP4Address;
+                            std::string addr = address->host.to_string();
+
+                            if(address->host.is_v6())
+                                remote = NTCP2Server::eIP6Address;
+
+                            m_NTCP2Server->ConnectWithProxy(addr, address->port, remote, s);
+                        }
+                        else
                             m_NTCP2Server->Connect (address->host, address->port, s);
                         return true;
                     }