527 lines
12 KiB
C++
527 lines
12 KiB
C++
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
extern "C" {
|
|
#include "stellar/stellar.h"
|
|
#include "stellar/session.h"
|
|
#include "stellar/stellar_mq.h"
|
|
#include "stellar/stellar_exdata.h"
|
|
}
|
|
|
|
#include "socks_decoder_internal.h"
|
|
#include "stellar/log.h"
|
|
|
|
#define UNUSED(x) (void)(x)
|
|
|
|
|
|
static void socks_decoder_session_exdata_free(int idx, void *ex_ptr, void *arg)
|
|
{
|
|
UNUSED(idx);
|
|
UNUSED(arg);
|
|
|
|
if (ex_ptr == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
free(ex_ptr);
|
|
|
|
return;
|
|
}
|
|
|
|
//packet format refer to https://zh.wikipedia.org/wiki/SOCKS
|
|
static int socks_rough_rec(const char *payload, size_t payload_len)
|
|
{
|
|
//for socks4
|
|
if (payload_len < SOCKS5_REQUEST_METHOD_MIN_LEN)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if (payload[0] == SOCKS_FIELD_VER_4 && payload[payload_len-1] == 0)
|
|
{
|
|
if (payload_len >= 9)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (payload[0] == SOCKS_FIELD_VER_5)
|
|
{
|
|
if (2 + (unsigned int)payload[1] == payload_len)
|
|
{
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static int socks5_method_request(const char *payload, size_t payload_len)
|
|
{
|
|
if (payload_len < SOCKS5_REQUEST_METHOD_MIN_LEN)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if (payload[0] != SOCKS_FIELD_VER_5)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if ((size_t)(2 + payload[1]) != payload_len)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int socks4_request(struct socks_tunnel_stream *stream, const char *payload, size_t payload_len)
|
|
{
|
|
if (payload_len < 9)
|
|
return -1;
|
|
if (payload[0] != SOCKS_FIELD_VER_4 || payload[payload_len-1] != 0)
|
|
return -1;
|
|
|
|
struct socks_addr *addr = &(stream->info.dst_addr);
|
|
|
|
memcpy(&(addr->port), payload + 2, 2);
|
|
memcpy(&(addr->ipv4), payload + 4, 4);
|
|
|
|
if (addr->ipv4 & 0x00FFFFFF)
|
|
{
|
|
addr->type = SOCKS_ADDR_IPV4;
|
|
return 0;
|
|
}
|
|
else if (addr->ipv4 & 0xFF000000)//socks4a hostname
|
|
{
|
|
size_t pos = 8;
|
|
while (pos < payload_len - 2 && payload[pos] != 0)
|
|
{
|
|
pos++;
|
|
}
|
|
|
|
if (payload[pos] == 0)
|
|
{
|
|
if (payload_len - 1 - pos < 2)
|
|
return -1;
|
|
|
|
addr->fqdn.iov_len = payload_len - 1 - pos - 1;
|
|
addr->fqdn.iov_base = (unsigned char *)calloc(1, addr->fqdn.iov_len + 1);
|
|
|
|
memcpy(addr->fqdn.iov_base, payload+pos+1, addr->fqdn.iov_len);
|
|
|
|
addr->type = SOCKS_ADDR_FQDN;
|
|
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
static int socks5_request(struct socks_tunnel_stream *stream, const char *payload, size_t payload_len)
|
|
{
|
|
unsigned int port_offset = 0;
|
|
struct socks_addr *addr = &(stream->info.dst_addr);
|
|
|
|
if (payload_len < SOCKS5_REQUEST_MIN_LEN)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if (payload[0] != SOCKS_FIELD_VER_5)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if (payload[1] != SOCKS_CMD_CONNECT && payload[1] != SOCKS_CMD_BIND)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if (payload[2] != SOCKS5_RSV_DEFAULT)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
switch (payload[3])
|
|
{
|
|
case SOCKS_ATYPE_IP4:
|
|
{
|
|
if (payload_len != 10)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
addr->type = SOCKS_ADDR_IPV4;
|
|
memcpy(&(addr->ipv4), payload+4, 4);
|
|
|
|
port_offset = 8;
|
|
|
|
break;
|
|
}
|
|
//should be processed
|
|
case SOCKS_ATYPE_IP6:
|
|
{
|
|
if(payload_len != 22)
|
|
{
|
|
return -1;
|
|
}
|
|
addr->type = SOCKS_ADDR_IPV6;
|
|
memcpy(addr->ipv6, payload+4, 16);
|
|
port_offset = 20;
|
|
|
|
break;
|
|
}
|
|
case SOCKS_ATYPE_FQDN:
|
|
{
|
|
if (payload[4] < 0 || payload_len != (size_t)(7 + payload[4]))
|
|
{
|
|
return -1;
|
|
}
|
|
addr->type = SOCKS_ADDR_FQDN;
|
|
addr->fqdn.iov_len = payload[4];
|
|
addr->fqdn.iov_base = (char *)calloc(1, addr->fqdn.iov_len + 1);
|
|
memcpy(addr->fqdn.iov_base, payload+5, payload[4]);
|
|
|
|
port_offset = 5 + payload[4];
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
memcpy(&(addr->port), payload+port_offset, 2);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int socks5_pass_request(struct socks_tunnel_stream *stream, const char *payload, size_t payload_len)
|
|
{
|
|
unsigned char *ubuf = (unsigned char*)payload;
|
|
unsigned char *cur;
|
|
struct socks_info *info = &stream->info;
|
|
|
|
if (ubuf[0]!=1)
|
|
{
|
|
return -1;
|
|
}
|
|
if (payload_len < 2 || payload_len < (size_t)(3+ubuf[1]) || payload_len != (size_t)(3+ubuf[1]+ubuf[2+ubuf[1]]))
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
info->user_name.iov_len = ubuf[1];
|
|
info->user_name.iov_base = (char *)calloc(1, info->user_name.iov_len + 1);
|
|
memcpy(info->user_name.iov_base, ubuf+2, info->user_name.iov_len);
|
|
|
|
info->password.iov_len = ubuf[2+ubuf[1]];
|
|
info->password.iov_base = (char *)calloc(1, info->password.iov_len + 1);
|
|
cur = ubuf + 2 + info->user_name.iov_len + 1;
|
|
memcpy(info->password.iov_base, cur, info->password.iov_len);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void c2s_handler(struct socks_tunnel_stream *stream, const char *payload, size_t payload_len)
|
|
{
|
|
switch (stream->client_state)
|
|
{
|
|
case SS_BEGIN:
|
|
if (socks5_method_request(payload, payload_len) == 0)
|
|
{
|
|
stream->client_state = SS_SUB;
|
|
stream->info.version = SOCKS_VERSION_5;
|
|
}
|
|
else if (socks4_request(stream, payload, payload_len) == 0)
|
|
{
|
|
stream->client_state = SS_END;
|
|
stream->info.version = SOCKS_VERSION_4;
|
|
}
|
|
else
|
|
{
|
|
stream->client_state = SS_FAILED;
|
|
}
|
|
break;
|
|
case SS_SUB:
|
|
if (socks5_request(stream, payload, payload_len) == 0)
|
|
{
|
|
stream->client_state = SS_END;
|
|
}
|
|
else if (socks5_pass_request(stream, payload, payload_len) != 0)
|
|
{
|
|
stream->client_state = SS_FAILED;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static int socks5_method_replay(const char *payload, size_t payload_len)
|
|
{
|
|
if (payload_len != 2)
|
|
{
|
|
return -1;
|
|
}
|
|
if (payload[0] != SOCKS_FIELD_VER_5)
|
|
{
|
|
return -1;
|
|
}
|
|
if (payload[1] != 0 && payload[1]!=2)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
////printf("socks5 method replay!\n");
|
|
return 0;
|
|
}
|
|
|
|
static int socks4_replay(const char *payload, size_t payload_len)
|
|
{
|
|
if (payload_len != 8)
|
|
return -1;
|
|
if (payload[0] != 0 || payload[1] < 90 || payload[1] > 93)
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int socks5_replay(const char *payload, size_t payload_len)
|
|
{
|
|
if (payload_len < 6)
|
|
{
|
|
return -1;
|
|
}
|
|
if (payload[0] != SOCKS_FIELD_VER_5)
|
|
{
|
|
return -1;
|
|
}
|
|
if (payload[1] != 0)
|
|
{
|
|
return -1;
|
|
}
|
|
if (payload[2] != 0)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
switch(payload[3])
|
|
{
|
|
case SOCKS_ATYPE_IP4:
|
|
if (payload_len < 10)
|
|
{
|
|
return -1;
|
|
}
|
|
break;
|
|
case SOCKS_ATYPE_IP6:
|
|
if (payload_len != 22)
|
|
{
|
|
return -1;
|
|
}
|
|
break;
|
|
case SOCKS_ATYPE_FQDN:
|
|
if (payload[4] < 0 || payload_len < (size_t)(7 + payload[4]))
|
|
{
|
|
return -1;
|
|
}
|
|
break;
|
|
default:
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int socks5_pass_reply(const char *payload, size_t payload_len)
|
|
{
|
|
if (payload_len != 2)
|
|
return -1;
|
|
if (payload[0] != 1 || payload[1] != 0)
|
|
return -1;
|
|
return 0;
|
|
}
|
|
|
|
static void s2c_handler(struct socks_tunnel_stream *stream, const char *payload, size_t payload_len)
|
|
{
|
|
switch (stream->server_state)
|
|
{
|
|
case SS_BEGIN:
|
|
if (stream->info.version == SOCKS_VERSION_5 && socks5_method_replay(payload, payload_len) == 0)
|
|
{
|
|
stream->server_state = SS_SUB;
|
|
}
|
|
else if (stream->info.version == SOCKS_VERSION_4 && socks4_replay(payload, payload_len) == 0)
|
|
{
|
|
stream->server_state = SS_END;
|
|
}
|
|
else
|
|
{
|
|
stream->server_state = SS_FAILED;
|
|
//printf("socks error, s2c beign\n");
|
|
}
|
|
break;
|
|
case SS_SUB:
|
|
if (socks5_replay(payload, payload_len) == 0)
|
|
{
|
|
stream->server_state = SS_END;
|
|
}
|
|
else if (socks5_pass_reply(payload, payload_len) != 0)
|
|
{
|
|
stream->server_state = SS_FAILED;
|
|
|
|
//printf("socks error, s2c sub\n");
|
|
}
|
|
break;
|
|
default:
|
|
//error!
|
|
break;
|
|
}
|
|
}
|
|
|
|
int socks_process(struct socks_decoder_info *socks_decoder_info, struct session *sess, struct socks_tunnel_stream *stream, const char *payload, size_t payload_len)
|
|
{
|
|
if (payload_len == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
switch(stream->state)
|
|
{
|
|
case STATE_INIT:
|
|
if (socks_rough_rec(payload, payload_len) < 0)
|
|
{
|
|
stream->state = STATE_FAILED;
|
|
return -1;
|
|
}
|
|
stream->state = STATE_OPENING;
|
|
[[fallthrough]];//continue execute STATE_OPENING
|
|
case STATE_OPENING:
|
|
switch (session_get_flow_type(sess))
|
|
{
|
|
case FLOW_TYPE_C2S:
|
|
c2s_handler(stream, payload, payload_len);
|
|
break;
|
|
case FLOW_TYPE_S2C:
|
|
s2c_handler(stream, payload, payload_len);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (stream->client_state == SS_END && stream->server_state == SS_END)
|
|
{
|
|
if (session_mq_publish_message(sess, socks_decoder_info->socks_decoder_topic_id, &stream->info) < 0)
|
|
{
|
|
STELLAR_LOG_FATAL(socks_decoder_info->log_handle, SOCKS_LOG_MOUDLE, "session_mq_publish_message OPENING failed");
|
|
}
|
|
stellar_session_plugin_dettach_current_session(sess);
|
|
}
|
|
else if (stream->client_state == SS_FAILED || stream->server_state == SS_FAILED)
|
|
{
|
|
//not a socks proxy
|
|
stream->state = STATE_FAILED;
|
|
return -1;
|
|
}
|
|
break;
|
|
default:
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void socks_decoder_on_message(struct session *sess, int topic_id, const void *msg, void *per_session_ctx, void *plugin_env)
|
|
{
|
|
UNUSED(per_session_ctx);
|
|
UNUSED(topic_id);
|
|
UNUSED(msg);
|
|
|
|
struct socks_decoder_info *socks_decoder_info = (struct socks_decoder_info *)plugin_env;
|
|
struct socks_tunnel_stream *socks_tunel_stream = (struct socks_tunnel_stream *)session_exdata_get(sess, socks_decoder_info->sess_exdata_idx);
|
|
const char *payload = NULL;
|
|
size_t payload_len = 0;
|
|
const struct packet *pkt = NULL;
|
|
|
|
if (socks_tunel_stream == NULL)
|
|
{
|
|
socks_tunel_stream = (struct socks_tunnel_stream *)calloc(1, sizeof(struct socks_tunnel_stream));
|
|
session_exdata_set(sess, socks_decoder_info->sess_exdata_idx, socks_tunel_stream);
|
|
}
|
|
|
|
pkt = session_get0_current_packet(sess);
|
|
payload = packet_get_payload(pkt);
|
|
payload_len = packet_get_payload_len(pkt);
|
|
|
|
if (socks_process(socks_decoder_info, sess, socks_tunel_stream, payload, payload_len) < 0)
|
|
{
|
|
stellar_session_plugin_dettach_current_session(sess);
|
|
}
|
|
}
|
|
|
|
extern "C" void *socks_decoder_init(struct stellar *st)
|
|
{
|
|
struct socks_decoder_info *socks_decoder_info = (struct socks_decoder_info *)calloc(1, sizeof(struct socks_decoder_info));
|
|
|
|
socks_decoder_info->sess_exdata_idx= stellar_exdata_new_index(st, "SOCKS_DECODER_SESS_CTX", socks_decoder_session_exdata_free, NULL);
|
|
|
|
socks_decoder_info->st = st;
|
|
socks_decoder_info->log_handle = stellar_get_logger(st);
|
|
|
|
socks_decoder_info->plugin_id = stellar_session_plugin_register(st, NULL, NULL, socks_decoder_info);
|
|
if (socks_decoder_info->plugin_id < 0)
|
|
{
|
|
STELLAR_LOG_FATAL(socks_decoder_info->log_handle, SOCKS_LOG_MOUDLE, "stellar_session_plugin_register failed");
|
|
goto ERROR;
|
|
|
|
}
|
|
|
|
socks_decoder_info->socks_decoder_topic_id = stellar_mq_create_topic(st, SOCKS_MESSAGE_TOPIC, NULL, NULL);
|
|
if (socks_decoder_info->socks_decoder_topic_id < 0)
|
|
{
|
|
STELLAR_LOG_FATAL(socks_decoder_info->log_handle, SOCKS_LOG_MOUDLE, "stellar_session_mq_create_topic failed");
|
|
goto ERROR;
|
|
}
|
|
|
|
socks_decoder_info->tcp_topic_id = stellar_mq_get_topic_id(st, TOPIC_TCP_STREAM);
|
|
if (socks_decoder_info->tcp_topic_id < 0)
|
|
{
|
|
STELLAR_LOG_FATAL(socks_decoder_info->log_handle, SOCKS_LOG_MOUDLE, "stellar_session_mq_get_topic_id failed");
|
|
goto ERROR;
|
|
}
|
|
|
|
if (stellar_session_mq_subscribe(st, socks_decoder_info->tcp_topic_id, socks_decoder_on_message, socks_decoder_info->plugin_id) < 0)
|
|
{
|
|
STELLAR_LOG_FATAL(socks_decoder_info->log_handle, SOCKS_LOG_MOUDLE, "stellar_session_mq_subscribe tcp_topic_id failed");
|
|
goto ERROR;
|
|
}
|
|
|
|
return socks_decoder_info;
|
|
|
|
ERROR:
|
|
if (socks_decoder_info != NULL)
|
|
{
|
|
free(socks_decoder_info);
|
|
}
|
|
perror("socks_decoder init failed");
|
|
exit(-1);
|
|
}
|
|
|
|
extern "C" void socks_decoder_exit(void *plugin_env)
|
|
{
|
|
struct socks_decoder_info *socks_decoder_info = (struct socks_decoder_info *)plugin_env;
|
|
|
|
if (socks_decoder_info != NULL)
|
|
{
|
|
free(socks_decoder_info);
|
|
}
|
|
|
|
return;
|
|
} |