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

Merge pull request #133 from klondi/httpproxy 

SOCKS5 support
pull/134/head
orignal 10 years ago
parent
7acdc0a606 17ccaab792
commit
1b3652e135
2 changed files with 316 additions and 97 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 306
      SOCKS.cpp
  2. 97
      SOCKS.h

306
SOCKS.cpp
Unescape View File

@ -4,44 +4,109 @@ @@ -4,44 +4,109 @@
#include "Destination.h"
#include "ClientContext.h"
#include "I2PEndian.h"
#include <cstring>
#include <cassert>
namespace i2p
{
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");
//TODO: send the right response
boost::asio::async_write(*m_sock, boost::asio::buffer("\x00\x5b 12345"),
std::bind(&SOCKS4AHandler::SentSocksFailed, this,
LogPrint(eLogWarning,"--- SOCKS5 authentication negotiation failed");
boost::asio::async_write(*m_sock, boost::asio::buffer("\x05\xff",2),
std::bind(&SOCKSHandler::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 +116,7 @@ namespace proxy @@ -51,7 +116,7 @@ namespace proxy
}
}
void SOCKS4AHandler::CloseStream()
void SOCKSHandler::CloseStream()
{
if (m_stream) {
LogPrint(eLogDebug,"--- SOCKS close stream");
@ -59,11 +124,7 @@ namespace proxy @@ -59,11 +124,7 @@ namespace proxy
}
}
const size_t socks_hostname_size = 1024;
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 +132,10 @@ namespace proxy @@ -71,6 +132,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 +143,18 @@ namespace proxy @@ -78,12 +143,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 +163,7 @@ namespace proxy @@ -92,7 +163,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 +174,7 @@ namespace proxy @@ -103,7 +174,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 +204,7 @@ namespace proxy @@ -133,7 +204,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 +216,12 @@ namespace proxy @@ -145,11 +216,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) {
if (m_destination.size() > max_socks_hostname_size) {
LogPrint(eLogError,"--- SOCKS4a destination is too large ");
SocksFailed();
SocksRequestFailed();
return 0;
}
m_destination.push_back(*sock_buff);
@ -165,7 +237,125 @@ namespace proxy @@ -165,7 +237,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 +365,105 @@ namespace proxy @@ -175,109 +365,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()
{
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)
void SOCKSHandler::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) {
if(m_state == READY) {
LogPrint (eLogInfo,"--- SOCKS New I2PTunnel connection");
auto connection = std::make_shared<i2p::client::I2PTunnelConnection>((i2p::client::I2PTunnel *)m_parent, m_sock, m_stream);
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)
{
if (stream)
void SOCKSHandler::HandleStreamRequestComplete (std::shared_ptr<i2p::stream::Stream> stream)
{
if (stream) {
m_stream = stream;
ConnectionSuccess();
}
else
{
SocksRequestSuccess();
} 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

97
SOCKS.h
Unescape View File

@ -1,41 +1,31 @@ @@ -1,41 +1,31 @@
#ifndef SOCKS4A_H__
#define SOCKS4A_H__
#ifndef SOCKS_H__
#define SOCKS_H__
#include <climits>
#include <memory>
#include <vector>
#include <boost/asio.hpp>
#include "Identity.h"
#include "Streaming.h"
#include "I2PTunnel.h"
#ifdef MAC_OSX
/*
* - MAXHOSTNAMELEN from <sys/param.h>
* on MacOS X 10.3, FreeBSD 6.0, NetBSD 3.0, OpenBSD 3.8, AIX 5.1, HP-UX 11,
* IRIX 6.5, OSF/1 5.1, Interix 3.5, Haiku,
* - MAXHOSTNAMELEN from <netdb.h>
* on Solaris 10, Cygwin, BeOS,
* - 256 on mingw.
*
* */
#include <sys/param.h>
#define HOST_NAME_MAX MAXHOSTNAMELEN
#endif
namespace i2p
{
namespace proxy
{
const size_t socks_buffer_size = 8192;
const size_t max_socks_hostname_size = 255; // Limit for socks5 and bad idea to traverse
class SOCKS4AServer;
class SOCKS4AHandler {
class SOCKSServer;
class SOCKSHandler {
private:
enum state {
GET_VERSION,
SOCKS4A,
SOCKS5_S1, //Authentication negotiation
SOCKS5_S2, //Authentication
SOCKS5_S3, //Request
READY
};
enum parseState {
@ -48,6 +38,36 @@ namespace proxy @@ -48,6 +38,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 +75,25 @@ namespace proxy @@ -55,20 +75,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);
void ConnectionSuccess();
//HACK: we need to pass the shared_ptr to ensure the buffer will live enough
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 +102,31 @@ namespace proxy @@ -77,23 +102,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) :
m_parent(parent), m_sock(sock), m_stream(nullptr), m_state(GET_VERSION)
{ AsyncSockRead(); m_destination.reserve(HOST_NAME_MAX+1); }
SOCKSHandler(SOCKSServer * parent, boost::asio::ip::tcp::socket * sock) :
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(max_socks_hostname_size+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 +142,7 @@ namespace proxy @@ -109,7 +142,7 @@ namespace proxy
boost::asio::deadline_timer m_Timer;
};
typedef SOCKS4AServer SOCKSProxy;
typedef SOCKSServer SOCKSProxy;
}
}

Write Preview
Loading…
Cancel
Save