From d8f24b442bfa57d9d426560280e9896b05864882 Mon Sep 17 00:00:00 2001 From: orignal Date: Wed, 8 Jun 2016 14:05:20 -0400 Subject: [PATCH 01/17] fixed mapping --- I2CP.cpp | 31 +++++++++++++++++-------------- 1 file changed, 17 insertions(+), 14 deletions(-) diff --git a/I2CP.cpp b/I2CP.cpp index f7ad7dfd..5447a622 100644 --- a/I2CP.cpp +++ b/I2CP.cpp @@ -276,21 +276,24 @@ namespace client size_t offset = 0; while (offset < len) { - auto semicolon = (const uint8_t *)memchr (buf + offset, ';', len - offset); - if (semicolon) + std::string param = ExtractString (buf + offset, len - offset); + offset += param.length (); + if (buf[offset] != '=') { - auto l = semicolon - buf - offset + 1; - auto equal = (const uint8_t *)memchr (buf + offset, '=', l); - if (equal) - { - auto l1 = equal - buf - offset + 1; - mapping.insert (std::make_pair (std::string ((const char *)(buf + offset), l1 -1), - std::string ((const char *)(buf + offset + l1), l - l1 - 2))); - } - offset += l; - } - else - break; + LogPrint (eLogWarning, "I2CP: Unexpected character ", buf[offset], " instead '=' after ", param); + break; + } + offset++; + + std::string value = ExtractString (buf + offset, len - offset); + offset += value.length (); + if (buf[offset] != ';') + { + LogPrint (eLogWarning, "I2CP: Unexpected character ", buf[offset], " instead ';' after ", value); + break; + } + offset++; + mapping.insert (std::make_pair (param, value)); } } From 21b5f2c96ab80631c85f9f2e1097ad9f90bc3bd8 Mon Sep 17 00:00:00 2001 From: orignal Date: Wed, 8 Jun 2016 14:14:19 -0400 Subject: [PATCH 02/17] fixed crash upon I2CP session disconnect --- I2CP.cpp | 15 ++++++++------- I2CP.h | 4 ++-- 2 files changed, 10 insertions(+), 9 deletions(-) diff --git a/I2CP.cpp b/I2CP.cpp index 5447a622..e0ab180a 100644 --- a/I2CP.cpp +++ b/I2CP.cpp @@ -23,7 +23,7 @@ namespace i2p namespace client { - I2CPDestination::I2CPDestination (I2CPSession& owner, std::shared_ptr identity, bool isPublic, const std::map& params): + I2CPDestination::I2CPDestination (std::shared_ptr owner, std::shared_ptr identity, bool isPublic, const std::map& params): LeaseSetDestination (isPublic, ¶ms), m_Owner (owner), m_Identity (identity) { } @@ -37,7 +37,7 @@ namespace client { uint32_t length = bufbe32toh (buf); if (length > len - 4) length = len - 4; - m_Owner.SendMessagePayloadMessage (buf + 4, length); + m_Owner->SendMessagePayloadMessage (buf + 4, length); } void I2CPDestination::CreateNewLeaseSet (std::vector > tunnels) @@ -46,9 +46,9 @@ namespace client m_LeaseSetExpirationTime = ls.GetExpirationTime (); uint8_t * leases = ls.GetLeases (); leases[-1] = tunnels.size (); - htobe16buf (leases - 3, m_Owner.GetSessionID ()); + htobe16buf (leases - 3, m_Owner->GetSessionID ()); size_t l = 2/*sessionID*/ + 1/*num leases*/ + i2p::data::LEASE_SIZE*tunnels.size (); - m_Owner.SendI2CPMessage (I2CP_REQUEST_VARIABLE_LEASESET_MESSAGE, leases - 3, l); + m_Owner->SendI2CPMessage (I2CP_REQUEST_VARIABLE_LEASESET_MESSAGE, leases - 3, l); } void I2CPDestination::LeaseSetCreated (const uint8_t * buf, size_t len) @@ -78,10 +78,10 @@ namespace client if (ls) { bool sent = s->SendMsg (msg, ls); - s->m_Owner.SendMessageStatusMessage (nonce, sent ? eI2CPMessageStatusGuaranteedSuccess : eI2CPMessageStatusGuaranteedFailure); + s->m_Owner->SendMessageStatusMessage (nonce, sent ? eI2CPMessageStatusGuaranteedSuccess : eI2CPMessageStatusGuaranteedFailure); } else - s->m_Owner.SendMessageStatusMessage (nonce, eI2CPMessageStatusNoLeaseSet); + s->m_Owner->SendMessageStatusMessage (nonce, eI2CPMessageStatusNoLeaseSet); }); } } @@ -134,6 +134,7 @@ namespace client void I2CPSession::Stop () { + Terminate (); } void I2CPSession::ReadProtocolByte () @@ -327,7 +328,7 @@ namespace client { bool isPublic = true; if (params[I2CP_PARAM_DONT_PUBLISH_LEASESET] == "true") isPublic = false; - m_Destination = std::make_shared(*this, identity, isPublic, params); + m_Destination = std::make_shared(shared_from_this (), identity, isPublic, params); m_Destination->Start (); SendSessionStatusMessage (1); // created LogPrint (eLogDebug, "I2CP: session ", m_SessionID, " created"); diff --git a/I2CP.h b/I2CP.h index 436b1ad6..62a9a729 100644 --- a/I2CP.h +++ b/I2CP.h @@ -63,7 +63,7 @@ namespace client { public: - I2CPDestination (I2CPSession& owner, std::shared_ptr identity, bool isPublic, const std::map& params); + I2CPDestination (std::shared_ptr owner, std::shared_ptr identity, bool isPublic, const std::map& params); void SetEncryptionPrivateKey (const uint8_t * key); void LeaseSetCreated (const uint8_t * buf, size_t len); // called from I2CPSession @@ -87,7 +87,7 @@ namespace client private: - I2CPSession& m_Owner; + std::shared_ptr m_Owner; std::shared_ptr m_Identity; uint8_t m_EncryptionPrivateKey[256]; uint64_t m_LeaseSetExpirationTime; From b786576bcb6b8d4778429a3afbc351ba5426da38 Mon Sep 17 00:00:00 2001 From: hagen Date: Thu, 9 Jun 2016 14:30:36 +0000 Subject: [PATCH 03/17] * HTTPProxy.cpp : always set dest_port --- HTTPProxy.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/HTTPProxy.cpp b/HTTPProxy.cpp index a2bc4828..ec3dcffa 100644 --- a/HTTPProxy.cpp +++ b/HTTPProxy.cpp @@ -223,6 +223,8 @@ namespace proxy { u.parse(t); dest_host = u.host; dest_port = u.port; + if (dest_port == 0) + dest_port = 80; /* always set port for CreateStream() */ } else { /* relative url and missing 'Host' header */ std::string message = "Can't detect destination host from request"; From 88561c22d361ccaf3330fa5f73b24154294200c4 Mon Sep 17 00:00:00 2001 From: orignal Date: Thu, 9 Jun 2016 14:34:38 -0400 Subject: [PATCH 04/17] make sure ackThrough is correct --- Streaming.cpp | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/Streaming.cpp b/Streaming.cpp index ab0a6df0..a258eef1 100644 --- a/Streaming.cpp +++ b/Streaming.cpp @@ -232,6 +232,11 @@ namespace stream bool acknowledged = false; auto ts = i2p::util::GetMillisecondsSinceEpoch (); uint32_t ackThrough = packet->GetAckThrough (); + if (ackThrough > m_SequenceNumber) + { + LogPrint (eLogError, "Streaming: Unexpected ackThrough=", ackThrough, " > seqn=", m_SequenceNumber); + return; + } int nackCount = packet->GetNACKCount (); for (auto it = m_SentPackets.begin (); it != m_SentPackets.end ();) { @@ -521,7 +526,7 @@ namespace stream size += 4; // receiveStreamID htobe32buf (packet + size, m_SequenceNumber++); size += 4; // sequenceNum - htobe32buf (packet + size, m_LastReceivedSequenceNumber); + htobe32buf (packet + size, m_LastReceivedSequenceNumber >= 0 ? m_LastReceivedSequenceNumber : 0); size += 4; // ack Through packet[size] = 0; size++; // NACK count From d5d501875ea5ad08730279e45b09432cb5d7a119 Mon Sep 17 00:00:00 2001 From: orignal Date: Thu, 9 Jun 2016 14:56:12 -0400 Subject: [PATCH 05/17] send correct ackThrough --- Streaming.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Streaming.cpp b/Streaming.cpp index a258eef1..1a6fdbca 100644 --- a/Streaming.cpp +++ b/Streaming.cpp @@ -341,9 +341,9 @@ namespace stream htobe32buf (packet + size, m_SequenceNumber++); size += 4; // sequenceNum if (isNoAck) - htobe32buf (packet + size, m_LastReceivedSequenceNumber); - else htobuf32 (packet + size, 0); + else + htobe32buf (packet + size, m_LastReceivedSequenceNumber); size += 4; // ack Through packet[size] = 0; size++; // NACK count From f6d7f7d984a5b4e1bb9c6471fd938193af90b94a Mon Sep 17 00:00:00 2001 From: orignal Date: Thu, 9 Jun 2016 15:48:31 -0400 Subject: [PATCH 06/17] set port to 80 is not specified --- HTTPProxy.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/HTTPProxy.cpp b/HTTPProxy.cpp index ec3dcffa..c1ebc4e8 100644 --- a/HTTPProxy.cpp +++ b/HTTPProxy.cpp @@ -223,14 +223,13 @@ namespace proxy { u.parse(t); dest_host = u.host; dest_port = u.port; - if (dest_port == 0) - dest_port = 80; /* always set port for CreateStream() */ } else { /* relative url and missing 'Host' header */ std::string message = "Can't detect destination host from request"; HTTPRequestFailed(message.c_str()); return true; } + if (!dest_port) dest_port = 80; /* always set port for CreateStream() */ //TODO: 443 for https /* make relative url */ url.schema = ""; url.host = ""; From 6de7cd5063fcd7c4ec40d902a7e3da609b6b1b0f Mon Sep 17 00:00:00 2001 From: orignal Date: Fri, 10 Jun 2016 11:39:20 -0400 Subject: [PATCH 07/17] don't send 'accepted' if not requested --- I2CP.cpp | 39 +++++++++++++++++++++++++++++++-------- I2CP.h | 4 +++- 2 files changed, 34 insertions(+), 9 deletions(-) diff --git a/I2CP.cpp b/I2CP.cpp index e0ab180a..20f9dcee 100644 --- a/I2CP.cpp +++ b/I2CP.cpp @@ -117,7 +117,7 @@ namespace client I2CPSession::I2CPSession (I2CPServer& owner, std::shared_ptr socket): m_Owner (owner), m_Socket (socket), m_NextMessage (nullptr), m_NextMessageLen (0), m_NextMessageOffset (0), - m_MessageID (0) + m_MessageID (0), m_IsSendAccepted (true) { RAND_bytes ((uint8_t *)&m_SessionID, 2); } @@ -317,21 +317,42 @@ namespace client { auto identity = std::make_shared(); size_t offset = identity->FromBuffer (buf, len); + if (!offset) + { + LogPrint (eLogError, "I2CP: create session maformed identity"); + SendSessionStatusMessage (3); // invalid + return; + } uint16_t optionsSize = bufbe16toh (buf + offset); offset += 2; - + if (optionsSize > len - offset) + { + LogPrint (eLogError, "I2CP: options size ", optionsSize, "exceeds message size"); + SendSessionStatusMessage (3); // invalid + return; + } std::map params; ExtractMapping (buf + offset, optionsSize, params); - offset += optionsSize; + offset += optionsSize; // options + if (params[I2CP_PARAM_MESSAGE_RELIABILITY] == "none") m_IsSendAccepted = false; + offset += 8; // date if (identity->Verify (buf, offset, buf + offset)) // signature { bool isPublic = true; if (params[I2CP_PARAM_DONT_PUBLISH_LEASESET] == "true") isPublic = false; - m_Destination = std::make_shared(shared_from_this (), identity, isPublic, params); - m_Destination->Start (); - SendSessionStatusMessage (1); // created - LogPrint (eLogDebug, "I2CP: session ", m_SessionID, " created"); + if (!m_Destination) + { + m_Destination = std::make_shared(shared_from_this (), identity, isPublic, params); + SendSessionStatusMessage (1); // created + LogPrint (eLogDebug, "I2CP: session ", m_SessionID, " created"); + m_Destination->Start (); + } + else + { + LogPrint (eLogError, "I2CP: session already exists"); + SendSessionStatusMessage (4); // refused + } } else { @@ -363,6 +384,7 @@ namespace client void I2CPSession::SendMessageStatusMessage (uint32_t nonce, I2CPMessageStatus status) { + if (!nonce) return; // don't send status with zero nonce uint8_t buf[15]; htobe16buf (buf, m_SessionID); htobe32buf (buf + 2, m_MessageID++); @@ -406,7 +428,8 @@ namespace client uint32_t payloadLen = bufbe32toh (buf + offset); offset += 4; uint32_t nonce = bufbe32toh (buf + offset + payloadLen); - SendMessageStatusMessage (nonce, eI2CPMessageStatusAccepted); // accepted + if (m_IsSendAccepted) + SendMessageStatusMessage (nonce, eI2CPMessageStatusAccepted); // accepted m_Destination->SendMsgTo (buf + offset, payloadLen, identity.GetIdentHash (), nonce); } } diff --git a/I2CP.h b/I2CP.h index 62a9a729..f77607ba 100644 --- a/I2CP.h +++ b/I2CP.h @@ -56,7 +56,8 @@ namespace client }; // params - const char I2CP_PARAM_DONT_PUBLISH_LEASESET[] = "i2cp.dontPublishLeaseSet "; + const char I2CP_PARAM_DONT_PUBLISH_LEASESET[] = "i2cp.dontPublishLeaseSet"; + const char I2CP_PARAM_MESSAGE_RELIABILITY[] = "i2cp.messageReliability"; class I2CPSession; class I2CPDestination: public LeaseSetDestination @@ -148,6 +149,7 @@ namespace client std::shared_ptr m_Destination; uint16_t m_SessionID; uint32_t m_MessageID; + bool m_IsSendAccepted; }; typedef void (I2CPSession::*I2CPMessageHandler)(const uint8_t * buf, size_t len); From ecd3a49d48378ac5156caafd43f98e421afc8f9a Mon Sep 17 00:00:00 2001 From: orignal Date: Fri, 10 Jun 2016 11:47:22 -0400 Subject: [PATCH 08/17] handle DestroySession properly --- I2CP.cpp | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/I2CP.cpp b/I2CP.cpp index 20f9dcee..d3ad2350 100644 --- a/I2CP.cpp +++ b/I2CP.cpp @@ -117,9 +117,8 @@ namespace client I2CPSession::I2CPSession (I2CPServer& owner, std::shared_ptr socket): m_Owner (owner), m_Socket (socket), m_NextMessage (nullptr), m_NextMessageLen (0), m_NextMessageOffset (0), - m_MessageID (0), m_IsSendAccepted (true) + m_SessionID (0), m_MessageID (0), m_IsSendAccepted (true) { - RAND_bytes ((uint8_t *)&m_SessionID, 2); } I2CPSession::~I2CPSession () @@ -315,6 +314,7 @@ namespace client void I2CPSession::CreateSessionMessageHandler (const uint8_t * buf, size_t len) { + RAND_bytes ((uint8_t *)&m_SessionID, 2); auto identity = std::make_shared(); size_t offset = identity->FromBuffer (buf, len); if (!offset) @@ -365,7 +365,11 @@ namespace client { SendSessionStatusMessage (0); // destroy LogPrint (eLogDebug, "I2CP: session ", m_SessionID, " destroyed"); - Terminate (); + if (m_Destination) + { + m_Destination->Stop (); + m_Destination = 0; + } } void I2CPSession::ReconfigureSessionMessageHandler (const uint8_t * buf, size_t len) From 8feca6874a1f76704273c6afe1d60ec8969fa098 Mon Sep 17 00:00:00 2001 From: orignal Date: Fri, 10 Jun 2016 12:18:19 -0400 Subject: [PATCH 09/17] process complete message --- I2CP.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/I2CP.cpp b/I2CP.cpp index d3ad2350..71188ec8 100644 --- a/I2CP.cpp +++ b/I2CP.cpp @@ -167,7 +167,7 @@ namespace client size_t offset = 0; // from m_Buffer if (m_NextMessage) { - if (m_NextMessageOffset + bytes_transferred <= m_NextMessageLen) + if (m_NextMessageOffset + bytes_transferred < m_NextMessageLen) { memcpy (m_NextMessage + m_NextMessageOffset, m_Buffer, bytes_transferred); m_NextMessageOffset += bytes_transferred; From b15b38868d391892f8adcc3f565a7f8dab286066 Mon Sep 17 00:00:00 2001 From: orignal Date: Fri, 10 Jun 2016 14:01:39 -0400 Subject: [PATCH 10/17] rolled back to previous implementation --- HTTPProxy.cpp | 443 +++++++++++++++++++++++++++----------------------- HTTPProxy.h | 25 ++- 2 files changed, 262 insertions(+), 206 deletions(-) diff --git a/HTTPProxy.cpp b/HTTPProxy.cpp index c1ebc4e8..056e3170 100644 --- a/HTTPProxy.cpp +++ b/HTTPProxy.cpp @@ -1,14 +1,8 @@ #include #include +#include #include #include -#include -#include -#include -#include - -#include "I2PService.h" -#include "Destination.h" #include "HTTPProxy.h" #include "util.h" #include "Identity.h" @@ -20,57 +14,71 @@ #include "Config.h" #include "HTTP.h" -namespace i2p { -namespace proxy { - bool str_rmatch(std::string & str, const char *suffix) { - auto pos = str.rfind (suffix); - if (pos == std::string::npos) - return false; /* not found */ - if (str.length() == (pos + std::strlen(suffix))) - return true; /* match */ - return false; - } - - class HTTPReqHandler: public i2p::client::I2PServiceHandler, public std::enable_shared_from_this +namespace i2p +{ +namespace proxy +{ + static const size_t http_buffer_size = 8192; + class HTTPProxyHandler: public i2p::client::I2PServiceHandler, public std::enable_shared_from_this { private: + enum state + { + GET_METHOD, + GET_HOSTNAME, + GET_HTTPV, + GET_HTTPVNL, //TODO: fallback to finding HOst: header if needed + DONE + }; - bool HandleRequest(std::size_t len); + void EnterState(state nstate); + bool HandleData(uint8_t *http_buff, std::size_t len); void HandleSockRecv(const boost::system::error_code & ecode, std::size_t bytes_transfered); void Terminate(); void AsyncSockRead(); - void HTTPRequestFailed(const char *message); - void RedirectToJumpService(std::string & host); - bool ExtractAddressHelper(i2p::http::URL & url, std::string & b64); - void SanitizeHTTPRequest(i2p::http::HTTPReq & req); + void HTTPRequestFailed(/*std::string message*/); + void RedirectToJumpService(); + void ExtractRequest(); + bool IsI2PAddress(); + bool ValidateHTTPRequest(); + void HandleJumpServices(); + bool CreateHTTPRequest(uint8_t *http_buff, std::size_t len); void SentHTTPFailed(const boost::system::error_code & ecode); void HandleStreamRequestComplete (std::shared_ptr stream); + uint8_t m_http_buff[http_buffer_size]; std::shared_ptr m_sock; - std::vector m_recv_buf; /* as "downstream recieve buffer", from client to me */ - std::vector m_send_buf; /* as "upstream send buffer", from me to remote host */ + std::string m_request; //Data left to be sent + std::string m_url; //URL + std::string m_method; //Method + std::string m_version; //HTTP version + std::string m_address; //Address + std::string m_path; //Path + int m_port; //Port + state m_state;//Parsing state public: - HTTPReqHandler(HTTPProxy * parent, std::shared_ptr sock) : - I2PServiceHandler(parent), m_sock(sock), m_recv_buf(8192), m_send_buf(0) {}; - ~HTTPReqHandler() { Terminate(); } + HTTPProxyHandler(HTTPProxyServer * parent, std::shared_ptr sock) : + I2PServiceHandler(parent), m_sock(sock) + { EnterState(GET_METHOD); } + ~HTTPProxyHandler() { Terminate(); } void Handle () { AsyncSockRead(); } }; - void HTTPReqHandler::AsyncSockRead() + void HTTPProxyHandler::AsyncSockRead() { LogPrint(eLogDebug, "HTTPProxy: async sock read"); - if (!m_sock) { + if(m_sock) { + m_sock->async_receive(boost::asio::buffer(m_http_buff, http_buffer_size), + std::bind(&HTTPProxyHandler::HandleSockRecv, shared_from_this(), + std::placeholders::_1, std::placeholders::_2)); + } else { LogPrint(eLogError, "HTTPProxy: no socket for read"); - return; } - m_sock->async_receive(boost::asio::buffer(m_recv_buf), - std::bind(&HTTPReqHandler::HandleSockRecv, shared_from_this(), - std::placeholders::_1, std::placeholders::_2)); } - void HTTPReqHandler::Terminate() { + void HTTPProxyHandler::Terminate() { if (Kill()) return; if (m_sock) { @@ -81,176 +89,203 @@ namespace proxy { Done(shared_from_this()); } - void HTTPReqHandler::HTTPRequestFailed(const char *message) + /* All hope is lost beyond this point */ + //TODO: handle this apropriately + void HTTPProxyHandler::HTTPRequestFailed(/*HTTPProxyHandler::errTypes error*/) { - i2p::http::HTTPRes res; - res.code = 500; - res.add_header("Content-Type", "text/plain"); - res.add_header("Connection", "close"); - res.body = message; - res.body += "\r\n"; - std::string response = res.to_string(); - boost::asio::async_write(*m_sock, boost::asio::buffer(response, response.size()), - std::bind(&HTTPReqHandler::SentHTTPFailed, shared_from_this(), std::placeholders::_1)); + static std::string response = "HTTP/1.0 500 Internal Server Error\r\nContent-type: text/html\r\nContent-length: 0\r\n"; + boost::asio::async_write(*m_sock, boost::asio::buffer(response,response.size()), + std::bind(&HTTPProxyHandler::SentHTTPFailed, shared_from_this(), std::placeholders::_1)); } - void HTTPReqHandler::RedirectToJumpService(std::string & host) + void HTTPProxyHandler::RedirectToJumpService(/*HTTPProxyHandler::errTypes error*/) { - i2p::http::HTTPRes res; + std::stringstream response; + std::string httpAddr; i2p::config::GetOption("http.address", httpAddr); + uint16_t httpPort; i2p::config::GetOption("http.port", httpPort); + + response << "HTTP/1.1 302 Found\r\nLocation: http://" << httpAddr << ":" << httpPort << "/?page=jumpservices&address=" << m_address << "\r\n\r\n"; + boost::asio::async_write(*m_sock, boost::asio::buffer(response.str (),response.str ().length ()), + std::bind(&HTTPProxyHandler::SentHTTPFailed, shared_from_this(), std::placeholders::_1)); + } + + void HTTPProxyHandler::EnterState(HTTPProxyHandler::state nstate) + { + m_state = nstate; + } + + void HTTPProxyHandler::ExtractRequest() + { + LogPrint(eLogDebug, "HTTPProxy: request: ", m_method, " ", m_url); i2p::http::URL url; - - i2p::config::GetOption("http.address", url.host); - i2p::config::GetOption("http.port", url.port); - url.schema = "http"; - url.path = "/"; - url.query = "page=jumpservices&address="; - url.query += host; - - res.code = 302; /* redirect */ - res.add_header("Location", url.to_string().c_str()); - res.add_header("Connection", "close"); - - std::string response = res.to_string(); - boost::asio::async_write(*m_sock, boost::asio::buffer(response, response.length()), - std::bind(&HTTPReqHandler::SentHTTPFailed, shared_from_this(), std::placeholders::_1)); + url.parse (m_url); + m_address = url.host; + m_port = url.port; + m_path = url.path; + if (!m_port) m_port = 80; + LogPrint(eLogDebug, "HTTPProxy: server: ", m_address, ", port: ", m_port, ", path: ", m_path); } - bool HTTPReqHandler::ExtractAddressHelper(i2p::http::URL & url, std::string & b64) + bool HTTPProxyHandler::ValidateHTTPRequest() { - const char *param = "i2paddresshelper="; - std::size_t pos = url.query.find(param); - std::size_t len = std::strlen(param); - std::map params; - - if (pos == std::string::npos) - return false; /* not found */ - if (!url.parse_query(params)) + if ( m_version != "HTTP/1.0" && m_version != "HTTP/1.1" ) + { + LogPrint(eLogError, "HTTPProxy: unsupported version: ", m_version); + HTTPRequestFailed(); //TODO: send right stuff return false; - - std::string value = params["i2paddresshelper"]; - len += value.length(); - b64 = i2p::http::UrlDecode(value); - url.query.replace(pos, len, ""); + } return true; } - void HTTPReqHandler::SanitizeHTTPRequest(i2p::http::HTTPReq & req) + void HTTPProxyHandler::HandleJumpServices() { - req.del_header("Referer"); - req.del_header("Via"); - req.del_header("Forwarded"); - std::vector toErase; - for (auto it : req.headers) { - if (it.first.compare(0, 12, "X-Forwarded-")) { - toErase.push_back(it.first); - } else if (it.first.compare(0, 6, "Proxy-")) { - toErase.push_back(it.first); - } else { - /* allow this header */ - } + static const char * helpermark1 = "?i2paddresshelper="; + static const char * helpermark2 = "&i2paddresshelper="; + size_t addressHelperPos1 = m_path.rfind (helpermark1); + size_t addressHelperPos2 = m_path.rfind (helpermark2); + size_t addressHelperPos; + if (addressHelperPos1 == std::string::npos) + { + if (addressHelperPos2 == std::string::npos) + return; //Not a jump service + else + addressHelperPos = addressHelperPos2; } - for (auto header : toErase) { - req.headers.erase(header); + else + { + if (addressHelperPos2 == std::string::npos) + addressHelperPos = addressHelperPos1; + else if ( addressHelperPos1 > addressHelperPos2 ) + addressHelperPos = addressHelperPos1; + else + addressHelperPos = addressHelperPos2; } - /* replace headers */ - req.add_header("Connection", "close", true); /* keep-alive conns not supported yet */ - req.add_header("User-Agent", "MYOB/6.66 (AN/ON)", true); /* privacy */ + auto base64 = m_path.substr (addressHelperPos + strlen(helpermark1)); + base64 = i2p::util::http::urlDecode(base64); //Some of the symbols may be urlencoded + LogPrint (eLogInfo, "HTTPProxy: jump service for ", m_address, ", inserting to address book"); + //TODO: this is very dangerous and broken. We should ask the user before doing anything see http://pastethis.i2p/raw/pn5fL4YNJL7OSWj3Sc6N/ + //TODO: we could redirect the user again to avoid dirtiness in the browser + i2p::client::context.GetAddressBook ().InsertAddress (m_address, base64); + m_path.erase(addressHelperPos); } - /** - * @param len length of data in m_recv_buf - * @return true on processed request or false if more data needed - */ - bool HTTPReqHandler::HandleRequest(std::size_t len) + bool HTTPProxyHandler::IsI2PAddress() { - i2p::http::HTTPReq req; - i2p::http::URL url; - std::string b64; - - int req_len = 0; - - req_len = req.parse((const char *) m_recv_buf.data(), len); - if (req_len == 0) - return false; /* need more data */ - if (req_len < 0) { - LogPrint(eLogError, "HTTPProxy: unable to parse request"); - HTTPRequestFailed("invalid request"); - return true; /* parse error */ + auto pos = m_address.rfind (".i2p"); + if (pos != std::string::npos && (pos+4) == m_address.length ()) + { + return true; } + return false; + } - /* parsing success, now let's look inside request */ - LogPrint(eLogDebug, "HTTPProxy: requested: ", req.uri); - url.parse(req.uri); - - if (ExtractAddressHelper(url, b64)) { - i2p::client::context.GetAddressBook ().InsertAddress (url.host, b64); - std::string message = "added b64 from addresshelper for " + url.host + " to address book"; - LogPrint (eLogInfo, "HTTPProxy: ", message); - message += ", please reload page"; - HTTPRequestFailed(message.c_str()); - return true; /* request processed */ - } + bool HTTPProxyHandler::CreateHTTPRequest(uint8_t *http_buff, std::size_t len) + { + ExtractRequest(); //TODO: parse earlier + if (!ValidateHTTPRequest()) return false; + HandleJumpServices(); i2p::data::IdentHash identHash; - if (str_rmatch(url.host, ".i2p")) { - if (!i2p::client::context.GetAddressBook ().GetIdentHash (url.host, identHash)) { - RedirectToJumpService(url.host); - return true; /* request processed */ + if (IsI2PAddress ()) + { + if (!i2p::client::context.GetAddressBook ().GetIdentHash (m_address, identHash)){ + RedirectToJumpService(); + return false; } - /* TODO: outproxy handler here */ - } else { - std::string message = "Host " + url.host + " not inside i2p network, but outproxy support still missing"; - HTTPRequestFailed(message.c_str()); - LogPrint (eLogWarning, "HTTPProxy: ", message); - return true; } - SanitizeHTTPRequest(req); - - std::string dest_host = url.host; - uint16_t dest_port = url.port; - /* set proper 'Host' header in upstream request */ - auto h = req.headers.find("Host"); - if (dest_host != "") { - /* absolute url, replace 'Host' header */ - std::string h = dest_host; - if (dest_port != 0 && dest_port != 80) - h += ":" + std::to_string(dest_port); - req.add_header("Host", h, true); - } else if (h != req.headers.end()) { - /* relative url and 'Host' header provided. transparent proxy mode? */ - i2p::http::URL u; - std::string t = "http://" + h->second; - u.parse(t); - dest_host = u.host; - dest_port = u.port; - } else { - /* relative url and missing 'Host' header */ - std::string message = "Can't detect destination host from request"; - HTTPRequestFailed(message.c_str()); - return true; - } - if (!dest_port) dest_port = 80; /* always set port for CreateStream() */ //TODO: 443 for https - /* make relative url */ - url.schema = ""; - url.host = ""; - req.uri = url.to_string(); - - /* drop original request from input buffer */ - m_recv_buf.erase(m_recv_buf.begin(), m_recv_buf.begin() + req_len); - - /* build new buffer from modified request and data from original request */ - std::string request = req.to_string(); - m_send_buf.assign(request.begin(), request.end()); - m_send_buf.insert(m_send_buf.end(), m_recv_buf.begin(), m_recv_buf.end()); - - /* connect to destination */ - GetOwner()->CreateStream (std::bind (&HTTPReqHandler::HandleStreamRequestComplete, - shared_from_this(), std::placeholders::_1), dest_host, dest_port); + + m_request = m_method; + m_request.push_back(' '); + m_request += m_path; + m_request.push_back(' '); + m_request += m_version; + m_request.push_back('\r'); + m_request.push_back('\n'); + m_request.append("Connection: close\r\n"); + // TODO: temporary shortcut. Must be implemented properly + uint8_t * eol = nullptr; + bool isEndOfHeader = false; + while (!isEndOfHeader && len && (eol = (uint8_t *)memchr (http_buff, '\r', len))) + { + if (eol) + { + *eol = 0; eol++; + if (strncmp ((const char *)http_buff, "Referer", 7) && strncmp ((const char *)http_buff, "Connection", 10)) // strip out referer and connection + { + if (!strncmp ((const char *)http_buff, "User-Agent", 10)) // replace UserAgent + m_request.append("User-Agent: MYOB/6.66 (AN/ON)"); + else + m_request.append ((const char *)http_buff); + m_request.append ("\r\n"); + } + isEndOfHeader = !http_buff[0]; + auto l = eol - http_buff; + http_buff = eol; + len -= l; + if (len > 0) // \r + { + http_buff++; + len--; + } + } + } + m_request.append(reinterpret_cast(http_buff),len); return true; } - void HTTPReqHandler::HandleSockRecv(const boost::system::error_code & ecode, std::size_t len) + bool HTTPProxyHandler::HandleData(uint8_t *http_buff, std::size_t len) + { + while (len > 0) + { + //TODO: fallback to finding HOst: header if needed + switch (m_state) + { + case GET_METHOD: + switch (*http_buff) + { + case ' ': EnterState(GET_HOSTNAME); break; + default: m_method.push_back(*http_buff); break; + } + break; + case GET_HOSTNAME: + switch (*http_buff) + { + case ' ': EnterState(GET_HTTPV); break; + default: m_url.push_back(*http_buff); break; + } + break; + case GET_HTTPV: + switch (*http_buff) + { + case '\r': EnterState(GET_HTTPVNL); break; + default: m_version.push_back(*http_buff); break; + } + break; + case GET_HTTPVNL: + switch (*http_buff) + { + case '\n': EnterState(DONE); break; + default: + LogPrint(eLogError, "HTTPProxy: rejected invalid request ending with: ", ((int)*http_buff)); + HTTPRequestFailed(); //TODO: add correct code + return false; + } + break; + default: + LogPrint(eLogError, "HTTPProxy: invalid state: ", m_state); + HTTPRequestFailed(); //TODO: add correct code 500 + return false; + } + http_buff++; + len--; + if (m_state == DONE) + return CreateHTTPRequest(http_buff,len); + } + return true; + } + + void HTTPProxyHandler::HandleSockRecv(const boost::system::error_code & ecode, std::size_t len) { LogPrint(eLogDebug, "HTTPProxy: sock recv: ", len, " bytes"); if(ecode) @@ -260,44 +295,54 @@ namespace proxy { return; } - if (HandleRequest(len)) { - m_recv_buf.clear(); - return; /* request processed */ + if (HandleData(m_http_buff, len)) + { + if (m_state == DONE) + { + LogPrint(eLogDebug, "HTTPProxy: requested: ", m_url); + GetOwner()->CreateStream (std::bind (&HTTPProxyHandler::HandleStreamRequestComplete, + shared_from_this(), std::placeholders::_1), m_address, m_port); + } + else + AsyncSockRead(); } - AsyncSockRead(); + } - void HTTPReqHandler::SentHTTPFailed(const boost::system::error_code & ecode) + void HTTPProxyHandler::SentHTTPFailed(const boost::system::error_code & ecode) { if (ecode) LogPrint (eLogError, "HTTPProxy: Closing socket after sending failure because: ", ecode.message ()); Terminate(); } - void HTTPReqHandler::HandleStreamRequestComplete (std::shared_ptr stream) + void HTTPProxyHandler::HandleStreamRequestComplete (std::shared_ptr stream) { - if (!stream) { + if (stream) + { + if (Kill()) return; + LogPrint (eLogInfo, "HTTPProxy: New I2PTunnel connection"); + auto connection = std::make_shared(GetOwner(), m_sock, stream); + GetOwner()->AddHandler (connection); + connection->I2PConnect (reinterpret_cast(m_request.data()), m_request.size()); + Done(shared_from_this()); + } + else + { LogPrint (eLogError, "HTTPProxy: error when creating the stream, check the previous warnings for more info"); - HTTPRequestFailed("error when creating the stream, check logs"); - return; + HTTPRequestFailed(); // TODO: Send correct error message host unreachable } - if (Kill()) - return; - LogPrint (eLogDebug, "HTTPProxy: New I2PTunnel connection"); - auto connection = std::make_shared(GetOwner(), m_sock, stream); - GetOwner()->AddHandler (connection); - connection->I2PConnect (m_send_buf.data(), m_send_buf.size()); - Done (shared_from_this()); } - HTTPProxy::HTTPProxy(const std::string& address, int port, std::shared_ptr localDestination): + HTTPProxyServer::HTTPProxyServer(const std::string& address, int port, std::shared_ptr localDestination): TCPIPAcceptor(address, port, localDestination ? localDestination : i2p::client::context.GetSharedLocalDestination ()) { } - std::shared_ptr HTTPProxy::CreateHandler(std::shared_ptr socket) + std::shared_ptr HTTPProxyServer::CreateHandler(std::shared_ptr socket) { - return std::make_shared (this, socket); + return std::make_shared (this, socket); } -} // http -} // i2p + +} +} diff --git a/HTTPProxy.h b/HTTPProxy.h index 29b997eb..b5ed77b9 100644 --- a/HTTPProxy.h +++ b/HTTPProxy.h @@ -1,21 +1,32 @@ #ifndef HTTP_PROXY_H__ #define HTTP_PROXY_H__ -namespace i2p { -namespace proxy { - class HTTPProxy: public i2p::client::TCPIPAcceptor +#include +#include +#include +#include +#include "I2PService.h" +#include "Destination.h" + +namespace i2p +{ +namespace proxy +{ + class HTTPProxyServer: public i2p::client::TCPIPAcceptor { public: - HTTPProxy(const std::string& address, int port, std::shared_ptr localDestination = nullptr); - ~HTTPProxy() {}; + HTTPProxyServer(const std::string& address, int port, std::shared_ptr localDestination = nullptr); + ~HTTPProxyServer() {}; protected: // Implements TCPIPAcceptor std::shared_ptr CreateHandler(std::shared_ptr socket); const char* GetName() { return "HTTP Proxy"; } }; -} // http -} // i2p + + typedef HTTPProxyServer HTTPProxy; +} +} #endif From 2e1e95d48368a210b97ee6c8c68c5e8eba15fd82 Mon Sep 17 00:00:00 2001 From: orignal Date: Fri, 10 Jun 2016 15:12:50 -0400 Subject: [PATCH 11/17] pass URL params --- HTTPProxy.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/HTTPProxy.cpp b/HTTPProxy.cpp index 056e3170..153e61f7 100644 --- a/HTTPProxy.cpp +++ b/HTTPProxy.cpp @@ -122,6 +122,7 @@ namespace proxy m_address = url.host; m_port = url.port; m_path = url.path; + if (url.query.length () > 0) m_path += "?" + url.query; if (!m_port) m_port = 80; LogPrint(eLogDebug, "HTTPProxy: server: ", m_address, ", port: ", m_port, ", path: ", m_path); } From 44556b7f5e8e626c21f8ac5076e55760798d10d4 Mon Sep 17 00:00:00 2001 From: orignal Date: Fri, 10 Jun 2016 15:25:30 -0400 Subject: [PATCH 12/17] correct string size for mapping --- I2CP.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/I2CP.cpp b/I2CP.cpp index 71188ec8..4842bf2d 100644 --- a/I2CP.cpp +++ b/I2CP.cpp @@ -277,7 +277,7 @@ namespace client while (offset < len) { std::string param = ExtractString (buf + offset, len - offset); - offset += param.length (); + offset += param.length () + 1; if (buf[offset] != '=') { LogPrint (eLogWarning, "I2CP: Unexpected character ", buf[offset], " instead '=' after ", param); @@ -286,7 +286,7 @@ namespace client offset++; std::string value = ExtractString (buf + offset, len - offset); - offset += value.length (); + offset += value.length () + 1; if (buf[offset] != ';') { LogPrint (eLogWarning, "I2CP: Unexpected character ", buf[offset], " instead ';' after ", value); From f4d8c3304abf47b851c706948337d75ab80b3747 Mon Sep 17 00:00:00 2001 From: orignal Date: Fri, 10 Jun 2016 18:43:35 -0400 Subject: [PATCH 13/17] execute lookup wothout session --- I2CP.cpp | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/I2CP.cpp b/I2CP.cpp index 4842bf2d..68809817 100644 --- a/I2CP.cpp +++ b/I2CP.cpp @@ -449,7 +449,7 @@ namespace client void I2CPSession::HostLookupMessageHandler (const uint8_t * buf, size_t len) { uint16_t sessionID = bufbe16toh (buf); - if (sessionID == m_SessionID) + if (sessionID == m_SessionID || sessionID == 0xFFFF) // -1 means without session { uint32_t requestID = bufbe32toh (buf + 2); //uint32_t timeout = bufbe32toh (buf + 6); @@ -476,15 +476,17 @@ namespace client return; } - if (m_Destination) + std::shared_ptr destination = m_Destination; + if(!destination) destination = i2p::client::context.GetSharedLocalDestination (); + if (destination) { - auto ls = m_Destination->FindLeaseSet (ident); + auto ls = destination->FindLeaseSet (ident); if (ls) SendHostReplyMessage (requestID, ls->GetIdentity ()); else { auto s = shared_from_this (); - m_Destination->RequestDestination (ident, + destination->RequestDestination (ident, [s, requestID](std::shared_ptr leaseSet) { s->SendHostReplyMessage (requestID, leaseSet ? leaseSet->GetIdentity () : nullptr); From bf8db7725f6e3c7e1ec337563ab948197f92ee28 Mon Sep 17 00:00:00 2001 From: orignal Date: Fri, 10 Jun 2016 22:13:20 -0400 Subject: [PATCH 14/17] set -1 as default session id --- I2CP.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/I2CP.cpp b/I2CP.cpp index 68809817..044fd7a3 100644 --- a/I2CP.cpp +++ b/I2CP.cpp @@ -117,7 +117,7 @@ namespace client I2CPSession::I2CPSession (I2CPServer& owner, std::shared_ptr socket): m_Owner (owner), m_Socket (socket), m_NextMessage (nullptr), m_NextMessageLen (0), m_NextMessageOffset (0), - m_SessionID (0), m_MessageID (0), m_IsSendAccepted (true) + m_SessionID (0xFFFF), m_MessageID (0), m_IsSendAccepted (true) { } From 88f52c490295c1ca703ce4b8bf6203ecf7b74e7c Mon Sep 17 00:00:00 2001 From: Osipov Kirill Date: Sat, 11 Jun 2016 11:20:20 +0300 Subject: [PATCH 15/17] Remove unused assigning (success is assinged anyway) --- AddressBook.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/AddressBook.cpp b/AddressBook.cpp index 0dbb42d7..5e7510a5 100644 --- a/AddressBook.cpp +++ b/AddressBook.cpp @@ -744,7 +744,6 @@ namespace client LogPrint (eLogInfo, "Addressbook: received ", m_Link, " ETag: ", m_Etag, " Last-Modified: ", m_LastModified); if (!response.eof () && !response.fail ()) { - success = true; if (!isChunked) success = ProcessResponse (response, isGzip); else From ae6877ce2fb7e496c2cc96deacc767c192b57eef Mon Sep 17 00:00:00 2001 From: orignal Date: Sun, 12 Jun 2016 08:22:55 -0400 Subject: [PATCH 16/17] handle incomplete message header --- I2CP.cpp | 83 ++++++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 62 insertions(+), 21 deletions(-) diff --git a/I2CP.cpp b/I2CP.cpp index 044fd7a3..dab7f9b0 100644 --- a/I2CP.cpp +++ b/I2CP.cpp @@ -167,24 +167,59 @@ namespace client size_t offset = 0; // from m_Buffer if (m_NextMessage) { - if (m_NextMessageOffset + bytes_transferred < m_NextMessageLen) + if (!m_NextMessageLen) // we didn't receive header yet { - memcpy (m_NextMessage + m_NextMessageOffset, m_Buffer, bytes_transferred); - m_NextMessageOffset += bytes_transferred; - offset = bytes_transferred; + if (m_NextMessageOffset + bytes_transferred < I2CP_HEADER_SIZE) + { + // still no complete header + memcpy (m_NextMessage + m_NextMessageOffset, m_Buffer, bytes_transferred); + m_NextMessageOffset += bytes_transferred; + offset = bytes_transferred; + } + else + { + // we know message length now + offset = I2CP_HEADER_SIZE - m_NextMessageOffset; + memcpy (m_NextMessage + m_NextMessageOffset, m_Buffer, offset); + m_NextMessageLen = bufbe32toh (m_NextMessage + I2CP_HEADER_LENGTH_OFFSET) + I2CP_HEADER_SIZE; + m_NextMessageOffset = I2CP_HEADER_SIZE; + } + } + + if (offset < bytes_transferred) + { + auto msgRemainingLen = m_NextMessageLen - m_NextMessageOffset; + auto bufRemainingLen = bytes_transferred - offset; + if (bufRemainingLen < msgRemainingLen) + { + memcpy (m_NextMessage + m_NextMessageOffset, m_Buffer + offset, bufRemainingLen); + m_NextMessageOffset += bufRemainingLen; + offset += bufRemainingLen; + } + else + { + // m_NextMessage complete + offset += msgRemainingLen; + memcpy (m_NextMessage + m_NextMessageOffset, m_Buffer + offset, msgRemainingLen); + HandleNextMessage (m_NextMessage); + delete[] m_NextMessage; + m_NextMessage = nullptr; + } } - else - { - // m_NextMessage complete - offset = m_NextMessageLen - m_NextMessageOffset; - memcpy (m_NextMessage + m_NextMessageOffset, m_Buffer, offset); - HandleNextMessage (m_NextMessage); - delete[] m_NextMessage; - m_NextMessage = nullptr; - } } + // process the rest while (offset < bytes_transferred) { + if (bytes_transferred - offset < I2CP_HEADER_SIZE) + { + // we don't have message header yet + m_NextMessage = new uint8_t[0xFFFF]; // allocate 64K + m_NextMessageLen = 0; // we must set message length later + m_NextMessageOffset = bytes_transferred - offset; + memcpy (m_NextMessage, m_Buffer + offset, m_NextMessageOffset); // just copy it + break; + } + auto msgLen = bufbe32toh (m_Buffer + offset + I2CP_HEADER_LENGTH_OFFSET) + I2CP_HEADER_SIZE; if (msgLen > 0xFFFF) // 64K { @@ -236,14 +271,20 @@ namespace client void I2CPSession::SendI2CPMessage (uint8_t type, const uint8_t * payload, size_t len) { - auto l = len + I2CP_HEADER_SIZE; - uint8_t * buf = new uint8_t[l]; - htobe32buf (buf + I2CP_HEADER_LENGTH_OFFSET, len); - buf[I2CP_HEADER_TYPE_OFFSET] = type; - memcpy (buf + I2CP_HEADER_SIZE, payload, len); - boost::asio::async_write (*m_Socket, boost::asio::buffer (buf, l), boost::asio::transfer_all (), - std::bind(&I2CPSession::HandleI2CPMessageSent, shared_from_this (), - std::placeholders::_1, std::placeholders::_2, buf)); + auto socket = m_Socket; + if (socket) + { + auto l = len + I2CP_HEADER_SIZE; + uint8_t * buf = new uint8_t[l]; + htobe32buf (buf + I2CP_HEADER_LENGTH_OFFSET, len); + buf[I2CP_HEADER_TYPE_OFFSET] = type; + memcpy (buf + I2CP_HEADER_SIZE, payload, len); + boost::asio::async_write (*socket, boost::asio::buffer (buf, l), boost::asio::transfer_all (), + std::bind(&I2CPSession::HandleI2CPMessageSent, shared_from_this (), + std::placeholders::_1, std::placeholders::_2, buf)); + } + else + LogPrint (eLogError, "I2CP: Can't write to the socket"); } void I2CPSession::HandleI2CPMessageSent (const boost::system::error_code& ecode, std::size_t bytes_transferred, const uint8_t * buf) From e795de5562309f7f2bd9dec4e6b0dee7d5ad9b07 Mon Sep 17 00:00:00 2001 From: Jeff Becker Date: Mon, 13 Jun 2016 07:48:20 -0400 Subject: [PATCH 17/17] fix 500 response in http proxy --- HTTPProxy.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/HTTPProxy.cpp b/HTTPProxy.cpp index 153e61f7..48fa0ae6 100644 --- a/HTTPProxy.cpp +++ b/HTTPProxy.cpp @@ -93,7 +93,7 @@ namespace proxy //TODO: handle this apropriately void HTTPProxyHandler::HTTPRequestFailed(/*HTTPProxyHandler::errTypes error*/) { - static std::string response = "HTTP/1.0 500 Internal Server Error\r\nContent-type: text/html\r\nContent-length: 0\r\n"; + static std::string response = "HTTP/1.0 500 Internal Server Error\r\nContent-type: text/html\r\nContent-length: 0\r\n\r\n"; boost::asio::async_write(*m_sock, boost::asio::buffer(response,response.size()), std::bind(&HTTPProxyHandler::SentHTTPFailed, shared_from_this(), std::placeholders::_1)); }