PurpleI2P
/
i2pd
mirror of https://github.com/PurpleI2P/i2pd.git
1
0
Fork 0
Code Issues Releases Activity
Browse Source

Merge branch 'new-proxy' into openssl

pull/572/head
hagen 8 years ago
parent
c664be52d7 da2c04f681
commit
c528d739c8
1 changed files with 144 additions and 190 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 334
      HTTPProxy.cpp

334
HTTPProxy.cpp
Unescape View File

@ -1,6 +1,5 @@
#include <cstring> #include <cstring>
#include <cassert> #include <cassert>
#include <boost/lexical_cast.hpp>
#include <string> #include <string>
#include <atomic> #include <atomic>
#include <memory> #include <memory>
@ -32,51 +31,32 @@ namespace proxy {
return false; return false;
} }
static const size_t http_buffer_size = 8192;
class HTTPReqHandler: public i2p::client::I2PServiceHandler, public std::enable_shared_from_this<HTTPReqHandler> class HTTPReqHandler: public i2p::client::I2PServiceHandler, public std::enable_shared_from_this<HTTPReqHandler>
{ {
private: private:
enum state
{ bool HandleRequest();
GET_METHOD,
GET_HOSTNAME,
GET_HTTPV,
GET_HTTPVNL, //TODO: fallback to finding HOst: header if needed
DONE
};
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 HandleSockRecv(const boost::system::error_code & ecode, std::size_t bytes_transfered);
void Terminate(); void Terminate();
void AsyncSockRead(); void AsyncSockRead();
void HTTPRequestFailed(const char *message); void HTTPRequestFailed(const char *message);
void RedirectToJumpService(std::string & host); void RedirectToJumpService(std::string & host);
void ExtractRequest(); bool ExtractAddressHelper(i2p::http::URL & url, std::string & b64);
bool ValidateHTTPRequest(); void SanitizeHTTPRequest(i2p::http::HTTPReq & req);
void HandleJumpServices();
bool CreateHTTPRequest(uint8_t *http_buff, std::size_t len);
void SentHTTPFailed(const boost::system::error_code & ecode); void SentHTTPFailed(const boost::system::error_code & ecode);
void HandleStreamRequestComplete (std::shared_ptr<i2p::stream::Stream> stream); void HandleStreamRequestComplete (std::shared_ptr<i2p::stream::Stream> stream);
uint8_t m_http_buff[http_buffer_size]; uint8_t m_recv_chunk[8192];
std::string m_recv_buf; // from client
std::string m_send_buf; // to upstream
std::shared_ptr<boost::asio::ip::tcp::socket> m_sock; std::shared_ptr<boost::asio::ip::tcp::socket> m_sock;
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: public:
HTTPReqHandler(HTTPProxy * parent, std::shared_ptr<boost::asio::ip::tcp::socket> sock) : HTTPReqHandler(HTTPProxy * parent, std::shared_ptr<boost::asio::ip::tcp::socket> sock) :
I2PServiceHandler(parent), m_sock(sock) I2PServiceHandler(parent), m_sock(sock) {}
{ EnterState(GET_METHOD); }
~HTTPReqHandler() { Terminate(); } ~HTTPReqHandler() { Terminate(); }
void Handle () { AsyncSockRead(); } void Handle () { AsyncSockRead(); } /* overload */
}; };
void HTTPReqHandler::AsyncSockRead() void HTTPReqHandler::AsyncSockRead()
@ -86,7 +66,7 @@ namespace proxy {
LogPrint(eLogError, "HTTPProxy: no socket for read"); LogPrint(eLogError, "HTTPProxy: no socket for read");
return; return;
} }
m_sock->async_receive(boost::asio::buffer(m_http_buff, http_buffer_size), m_sock->async_read_some(boost::asio::buffer(m_recv_chunk, sizeof(m_recv_chunk)),
std::bind(&HTTPReqHandler::HandleSockRecv, shared_from_this(), std::bind(&HTTPReqHandler::HandleSockRecv, shared_from_this(),
std::placeholders::_1, std::placeholders::_2)); std::placeholders::_1, std::placeholders::_2));
} }
@ -102,8 +82,6 @@ namespace proxy {
Done(shared_from_this()); Done(shared_from_this());
} }
/* All hope is lost beyond this point */
//TODO: handle this apropriately
void HTTPReqHandler::HTTPRequestFailed(const char *message) void HTTPReqHandler::HTTPRequestFailed(const char *message)
{ {
i2p::http::HTTPRes res; i2p::http::HTTPRes res;
@ -125,187 +103,168 @@ namespace proxy {
/* TODO: don't redirect to webconsole, it's not always work, handle jumpservices here */ /* TODO: don't redirect to webconsole, it's not always work, handle jumpservices here */
i2p::config::GetOption("http.address", url.host); i2p::config::GetOption("http.address", url.host);
i2p::config::GetOption("http.port", url.port); i2p::config::GetOption("http.port", url.port);
url.schema = "http";
url.path = "/"; url.path = "/";
url.query = "page=jumpservices&address="; url.query = "page=jumpservices&address=";
url.query += host; url.query += host;
res.code = 302; /* redirect */ res.code = 302; /* redirect */
res.add_header("Location", url.to_string().c_str()); res.add_header("Location", url.to_string().c_str());
res.add_header("Connection", "close");
std::string response = res.to_string(); std::string response = res.to_string();
boost::asio::async_write(*m_sock, boost::asio::buffer(response), boost::asio::async_write(*m_sock, boost::asio::buffer(response),
std::bind(&HTTPReqHandler::SentHTTPFailed, shared_from_this(), std::placeholders::_1)); std::bind(&HTTPReqHandler::SentHTTPFailed, shared_from_this(), std::placeholders::_1));
} }
void HTTPReqHandler::EnterState(HTTPReqHandler::state nstate) bool HTTPReqHandler::ExtractAddressHelper(i2p::http::URL & url, std::string & b64)
{
m_state = nstate;
}
void HTTPReqHandler::ExtractRequest()
{ {
LogPrint(eLogDebug, "HTTPProxy: request: ", m_method, " ", m_url); const char *param = "i2paddresshelper=";
i2p::http::URL url; std::size_t pos = url.query.find(param);
url.parse (m_url); std::size_t len = std::strlen(param);
m_address = url.host; std::map<std::string, std::string> params;
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);
}
bool HTTPReqHandler::ValidateHTTPRequest() if (pos == std::string::npos)
{ return false; /* not found */
if ( m_version != "HTTP/1.0" && m_version != "HTTP/1.1" ) if (!url.parse_query(params))
{
LogPrint(eLogError, "HTTPProxy: unsupported version: ", m_version);
HTTPRequestFailed("unsupported HTTP version");
return false; return false;
}
std::string value = params["i2paddresshelper"];
len += value.length();
b64 = i2p::http::UrlDecode(value);
url.query.replace(pos, len, "");
return true; return true;
} }
void HTTPReqHandler::HandleJumpServices() void HTTPReqHandler::SanitizeHTTPRequest(i2p::http::HTTPReq & req)
{ {
static const char * helpermark1 = "?i2paddresshelper="; /* drop common headers */
static const char * helpermark2 = "&i2paddresshelper="; req.del_header("Referer");
size_t addressHelperPos1 = m_path.rfind (helpermark1); req.del_header("Via");
size_t addressHelperPos2 = m_path.rfind (helpermark2); req.del_header("Forwarded");
size_t addressHelperPos; /* drop proxy-disclosing headers */
if (addressHelperPos1 == std::string::npos) std::vector<std::string> toErase;
{ for (auto it : req.headers) {
if (addressHelperPos2 == std::string::npos) if (it.first.compare(0, 12, "X-Forwarded-") == 0) {
return; //Not a jump service toErase.push_back(it.first);
else } else if (it.first.compare(0, 6, "Proxy-") == 0) {
addressHelperPos = addressHelperPos2; toErase.push_back(it.first);
} else {
/* allow */
}
} }
else for (auto header : toErase) {
{ req.headers.erase(header);
if (addressHelperPos2 == std::string::npos)
addressHelperPos = addressHelperPos1;
else if ( addressHelperPos1 > addressHelperPos2 )
addressHelperPos = addressHelperPos1;
else
addressHelperPos = addressHelperPos2;
} }
auto base64 = m_path.substr (addressHelperPos + strlen(helpermark1)); /* replace headers */
base64 = i2p::util::http::urlDecode(base64); //Some of the symbols may be urlencoded req.add_header("Connection", "close", true); /* keep-alive conns not supported yet */
LogPrint (eLogInfo, "HTTPProxy: jump service for ", m_address, ", inserting to address book"); req.add_header("User-Agent", "MYOB/6.66 (AN/ON)", true); /* privacy */
//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);
} }
bool HTTPReqHandler::CreateHTTPRequest(uint8_t *http_buff, std::size_t len) /**
* @brief Try to parse request from @a m_recv_buf
* If parsing success, rebuild request and store to @a m_send_buf
* with remaining data tail
* @return true on processed request or false if more data needed
*/
bool HTTPReqHandler::HandleRequest()
{ {
ExtractRequest(); //TODO: parse earlier i2p::http::HTTPReq req;
if (!ValidateHTTPRequest()) return false; i2p::http::URL url;
HandleJumpServices(); std::string b64;
int req_len = 0;
i2p::data::IdentHash identHash; req_len = req.parse(m_recv_buf);
if (str_rmatch(m_address, ".i2p"))
{ if (req_len == 0)
if (!i2p::client::context.GetAddressBook ().GetIdentHash (m_address, identHash)){ return false; /* need more data */
RedirectToJumpService(m_address);
return false; if (req_len < 0) {
} LogPrint(eLogError, "HTTPProxy: unable to parse request");
HTTPRequestFailed("invalid request");
return true; /* parse error */
} }
m_request = m_method; /* parsing success, now let's look inside request */
m_request.push_back(' '); LogPrint(eLogDebug, "HTTPProxy: requested: ", req.uri);
m_request += m_path; url.parse(req.uri);
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<const char *>(http_buff),len);
return true;
}
bool HTTPReqHandler::HandleData(uint8_t *http_buff, std::size_t len) /* TODO: show notice page with original link */
{ if (ExtractAddressHelper(url, b64)) {
while (len > 0) i2p::client::context.GetAddressBook ().InsertAddress (url.host, b64);
{ std::string message = "added b64 from addresshelper for " + url.host + " to address book";
//TODO: fallback to finding HOst: header if needed LogPrint (eLogInfo, "HTTPProxy: ", message);
switch (m_state) message += ", please reload page";
{ HTTPRequestFailed(message.c_str());
case GET_METHOD: return true; /* request processed */
switch (*http_buff) }
{
case ' ': EnterState(GET_HOSTNAME); break; SanitizeHTTPRequest(req);
default: m_method.push_back(*http_buff); break;
} std::string dest_host = url.host;
break; uint16_t dest_port = url.port;
case GET_HOSTNAME: /* always set port, even if missing in request */
switch (*http_buff) if (!dest_port) {
{ dest_port = (url.schema == "https") ? 443 : 80;
case ' ': EnterState(GET_HTTPV); break; }
default: m_url.push_back(*http_buff); break; /* detect dest_host, set proper 'Host' header in upstream request */
} auto h = req.headers.find("Host");
break; if (dest_host != "") {
case GET_HTTPV: /* absolute url, replace 'Host' header */
switch (*http_buff) std::string h = dest_host;
{ if (dest_port != 0 && dest_port != 80)
case '\r': EnterState(GET_HTTPVNL); break; h += ":" + std::to_string(dest_port);
default: m_version.push_back(*http_buff); break; req.add_header("Host", h, true);
} } else if (h != req.headers.end()) {
break; /* relative url and 'Host' header provided. transparent proxy mode? */
case GET_HTTPVNL: i2p::http::URL u;
switch (*http_buff) std::string t = "http://" + h->second;
{ u.parse(t);
case '\n': EnterState(DONE); break; dest_host = u.host;
default: dest_port = u.port;
LogPrint(eLogError, "HTTPProxy: rejected invalid request ending with: ", ((int)*http_buff)); } else {
HTTPRequestFailed("rejected invalid request"); /* relative url and missing 'Host' header */
return false; const char *message = "Can't detect destination host from request";
} HTTPRequestFailed(message);
break; return true;
default: }
LogPrint(eLogError, "HTTPProxy: invalid state: ", m_state);
HTTPRequestFailed("invalid parser state"); /* check dest_host really exists and inside I2P network */
return false; i2p::data::IdentHash identHash;
if (str_rmatch(dest_host, ".i2p")) {
if (!i2p::client::context.GetAddressBook ().GetIdentHash (dest_host, identHash)) {
RedirectToJumpService(dest_host); /* unknown host */
return true; /* request processed */
} }
http_buff++; /* TODO: outproxy handler here */
len--; } else {
if (m_state == DONE) std::string message = "Host " + url.host + " not inside i2p network, but outproxy support still missing";
return CreateHTTPRequest(http_buff,len); HTTPRequestFailed(message.c_str());
LogPrint (eLogWarning, "HTTPProxy: ", message);
return true;
} }
/* make relative url */
url.schema = "";
url.host = "";
req.uri = url.to_string();
/* drop original request from recv buffer */
m_recv_buf.erase(0, req_len);
/* build new buffer from modified request and data from original request */
m_send_buf = req.to_string();
m_send_buf.append(m_recv_buf);
/* connect to destination */
LogPrint(eLogDebug, "HTTPProxy: connecting to host ", dest_host, ":", dest_port);
GetOwner()->CreateStream (std::bind (&HTTPReqHandler::HandleStreamRequestComplete,
shared_from_this(), std::placeholders::_1), dest_host, dest_port);
return true; return true;
} }
/* will be called after some data received from client */
void HTTPReqHandler::HandleSockRecv(const boost::system::error_code & ecode, std::size_t len) void HTTPReqHandler::HandleSockRecv(const boost::system::error_code & ecode, std::size_t len)
{ {
LogPrint(eLogDebug, "HTTPProxy: sock recv: ", len, " bytes"); LogPrint(eLogDebug, "HTTPProxy: sock recv: ", len, " bytes, recv buf: ", m_recv_buf.length(), ", send buf: ", m_send_buf.length());
if(ecode) if(ecode)
{ {
LogPrint(eLogWarning, "HTTPProxy: sock recv got error: ", ecode); LogPrint(eLogWarning, "HTTPProxy: sock recv got error: ", ecode);
@ -313,17 +272,12 @@ namespace proxy {
return; return;
} }
if (HandleData(m_http_buff, len)) m_recv_buf.append(reinterpret_cast<const char *>(m_recv_chunk), len);
{ if (HandleRequest()) {
if (m_state == DONE) m_recv_buf.clear();
{ return;
LogPrint(eLogDebug, "HTTPProxy: requested: ", m_url);
GetOwner()->CreateStream (std::bind (&HTTPReqHandler::HandleStreamRequestComplete,
shared_from_this(), std::placeholders::_1), m_address, m_port);
}
else
AsyncSockRead();
} }
AsyncSockRead();
} }
void HTTPReqHandler::SentHTTPFailed(const boost::system::error_code & ecode) void HTTPReqHandler::SentHTTPFailed(const boost::system::error_code & ecode)
@ -342,10 +296,10 @@ namespace proxy {
} }
if (Kill()) if (Kill())
return; return;
LogPrint (eLogDebug, "HTTPProxy: New I2PTunnel connection"); LogPrint (eLogDebug, "HTTPProxy: Created new I2PTunnel stream, sSID=", stream->GetSendStreamID(), ", rSID=", stream->GetRecvStreamID());
auto connection = std::make_shared<i2p::client::I2PTunnelConnection>(GetOwner(), m_sock, stream); auto connection = std::make_shared<i2p::client::I2PTunnelConnection>(GetOwner(), m_sock, stream);
GetOwner()->AddHandler (connection); GetOwner()->AddHandler (connection);
connection->I2PConnect (reinterpret_cast<const uint8_t*>(m_request.data()), m_request.size()); connection->I2PConnect (reinterpret_cast<const uint8_t*>(m_send_buf.data()), m_send_buf.length());
Done (shared_from_this()); Done (shared_from_this());
} }

Write Preview
Loading…
Cancel
Save