303 lines
10 KiB
C
303 lines
10 KiB
C
#include "socks5.h"
|
|
|
|
struct socks5_ctx {
|
|
struct client_handshake ch;
|
|
struct server_handshake sh;
|
|
struct client_request cr;
|
|
struct server_reply sr;
|
|
uint64_t ch_cursor;
|
|
uint64_t sh_cursor;
|
|
uint64_t cr_cursor;
|
|
uint64_t sr_cursor;
|
|
uint8_t sr_atyp_read;
|
|
char cr_buffer[262];
|
|
size_t ch_size;
|
|
size_t cr_size;
|
|
};
|
|
|
|
int on_socks5_send_handshake(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo);
|
|
|
|
void socks5_free_ctx(void* elem) {
|
|
struct socks5_ctx* ctx = elem;
|
|
free(ctx);
|
|
}
|
|
|
|
void create_socks5_dns_client(struct evt_core_ctx* ctx, char* proxy_host, char* proxy_port, char* addr, uint16_t port) {
|
|
struct evt_core_fdinfo fdinfo;
|
|
struct evt_core_cat cat;
|
|
struct socks5_ctx* s5ctx;
|
|
struct evt_core_fdinfo* reg_fdinfo;
|
|
char url[1024];
|
|
|
|
// 0. Compute domain length and enforce an upper bound on its size
|
|
size_t domainLength = strlen(addr);
|
|
if (domainLength > 255) {
|
|
fprintf(stderr, "domain is too long\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
// 1. Open connection
|
|
int sock = create_tcp_client (proxy_host, proxy_port);
|
|
if (sock < 0) {
|
|
fprintf(stderr, "Unable to connect to proxy %s:%s\n", proxy_host, proxy_port);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
// 2. Create fdinfo
|
|
fdinfo.cat = &cat;
|
|
fdinfo.cat->name = "socks5-send-handshake";
|
|
fdinfo.fd = sock;
|
|
fdinfo.other = malloc(sizeof(struct socks5_ctx));
|
|
if (fdinfo.other == NULL) {
|
|
perror("malloc failed");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
memset(fdinfo.other, 0, sizeof(struct socks5_ctx));
|
|
fdinfo.free_other = socks5_free_ctx;
|
|
sprintf(url, "socks5:send-hs:%s:%d", addr, port);
|
|
fdinfo.url = strdup(url);
|
|
|
|
// 3. Fill socks5_ctx structures
|
|
s5ctx = fdinfo.other;
|
|
|
|
// 3.1 Client handshake to send
|
|
s5ctx->ch.ver = VER_SOCKS5;
|
|
s5ctx->ch.nmethods = 0x01;
|
|
s5ctx->ch.methods[0] = METHOD_NOAUTH;
|
|
s5ctx->ch_size = sizeof(uint8_t) * (2 + s5ctx->ch.nmethods);
|
|
|
|
// 3.2 Client request to send
|
|
s5ctx->cr.ver = VER_SOCKS5;
|
|
s5ctx->cr.cmd = CMD_CONNECT;
|
|
s5ctx->cr.rsv = 0x00;
|
|
s5ctx->cr.atyp = ATYP_DOMAINNAME;
|
|
s5ctx->cr.dst_addr_len = domainLength;
|
|
s5ctx->cr.dst_addr = addr;
|
|
s5ctx->cr.port = htons(port);
|
|
|
|
// 3.3 Generate client request buffer
|
|
s5ctx->cr_size = 0;
|
|
fill_buffer(&s5ctx->cr_size, s5ctx->cr_buffer, &s5ctx->cr, 5*sizeof(uint8_t));
|
|
fill_buffer(&s5ctx->cr_size, s5ctx->cr_buffer, s5ctx->cr.dst_addr, s5ctx->cr.dst_addr_len*sizeof(char));
|
|
fill_buffer(&s5ctx->cr_size, s5ctx->cr_buffer, &s5ctx->cr.port, sizeof(uint16_t));
|
|
|
|
reg_fdinfo = evt_core_add_fd (ctx, &fdinfo);
|
|
reg_fdinfo->cat->cb(ctx, reg_fdinfo);
|
|
}
|
|
|
|
int on_socks5_send_handshake(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo) {
|
|
struct socks5_ctx* s5ctx = fdinfo->other;
|
|
|
|
size_t written = write(fdinfo->fd, &s5ctx->ch + s5ctx->ch_cursor, s5ctx->ch_size - s5ctx->ch_cursor);
|
|
if (written == -1 && errno == EAGAIN) return 1;
|
|
if (written < 0) {
|
|
perror("write failed on tcp socket in socks5");
|
|
evt_core_mv_fd2(ctx, fdinfo, "socks5-failed");
|
|
fdinfo->cat->cb(ctx, fdinfo);
|
|
return 1;
|
|
}
|
|
s5ctx->ch_cursor += written;
|
|
if (s5ctx->ch_cursor < s5ctx->ch_size) return 0;
|
|
|
|
evt_core_mv_fd2(ctx, fdinfo, "socks5-recv-handshake");
|
|
return 1;
|
|
}
|
|
|
|
int on_socks5_recv_handshake(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo) {
|
|
struct socks5_ctx* s5ctx = fdinfo->other;
|
|
int readn = 0;
|
|
|
|
readn = read(fdinfo->fd, &s5ctx->sh + s5ctx->sh_cursor, sizeof(s5ctx->sh) - s5ctx->sh_cursor);
|
|
if (readn == -1 && errno == EAGAIN) return 1;
|
|
if (readn < 0) {
|
|
perror("sock5 handshake failed read");
|
|
evt_core_mv_fd2(ctx, fdinfo, "socks5-failed");
|
|
fdinfo->cat->cb(ctx, fdinfo);
|
|
return 1;
|
|
}
|
|
|
|
s5ctx->sh_cursor += readn;
|
|
if (s5ctx->sh_cursor < sizeof(s5ctx->sh)) return 0;
|
|
|
|
if (s5ctx->ch.ver != s5ctx->sh.ver || s5ctx->sh.method != s5ctx->ch.methods[0]) {
|
|
fprintf(stderr, "Protocol error: client asks for ver=%d, method=%d and server answers with ver=%d, method=%d\n",
|
|
s5ctx->ch.ver, s5ctx->ch.methods[0], s5ctx->sh.ver, s5ctx->sh.method);
|
|
evt_core_mv_fd2(ctx, fdinfo, "socks5-failed");
|
|
fdinfo->cat->cb(ctx, fdinfo);
|
|
return 1;
|
|
}
|
|
printf("[server_handshake] ver=%d, method=%d\n", s5ctx->sh.ver, s5ctx->sh.method);
|
|
evt_core_mv_fd2(ctx, fdinfo, "socks5-send-client-req");
|
|
fdinfo->cat->cb(ctx, fdinfo);
|
|
return 1;
|
|
}
|
|
|
|
int on_socks5_send_client_req(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo) {
|
|
struct socks5_ctx* s5ctx = fdinfo->other;
|
|
int written = 0;
|
|
|
|
written = write(fdinfo->fd, s5ctx->cr_buffer + s5ctx->cr_cursor, s5ctx->cr_size - s5ctx->cr_cursor);
|
|
if (written == -1 && errno == EAGAIN) return 1;
|
|
if (written < 0) {
|
|
fprintf(stderr, "socks5 send client request failed\n");
|
|
evt_core_mv_fd2 (ctx, fdinfo, "socks5-failed");
|
|
fdinfo->cat->cb(ctx, fdinfo);
|
|
return 1;
|
|
}
|
|
s5ctx->cr_cursor += written;
|
|
if (s5ctx->cr_cursor < s5ctx->cr_size) return 0;
|
|
|
|
evt_core_mv_fd2 (ctx, fdinfo, "socks5-recv-server-reply");
|
|
return 1;
|
|
}
|
|
|
|
int socks5_server_reply_atyp_ipv4(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo) {
|
|
struct socks5_ctx* s5ctx = fdinfo->other;
|
|
size_t fixed_headers_size = (void*)&s5ctx->sr.bind_addr.ipv4 - (void*)&s5ctx->sr;
|
|
size_t host_size = sizeof(s5ctx->sr.bind_addr.ipv4);
|
|
uint64_t relative_cursor = (s5ctx->sr_cursor - fixed_headers_size);
|
|
int nread = 0;
|
|
|
|
nread = read(fdinfo->fd,
|
|
s5ctx->sr.bind_addr.ipv4 + relative_cursor,
|
|
host_size - relative_cursor);
|
|
|
|
if (nread == -1 && errno == EAGAIN) return 1;
|
|
if (nread < 0) {
|
|
perror("write failed on tcp socket in socks5");
|
|
evt_core_mv_fd2(ctx, fdinfo, "socks5-failed");
|
|
fdinfo->cat->cb(ctx, fdinfo);
|
|
return 1;
|
|
}
|
|
|
|
s5ctx->sr_cursor += nread;
|
|
if (s5ctx->sr_cursor < fixed_headers_size + host_size) return 0;
|
|
|
|
s5ctx->sr_atyp_read = 1;
|
|
return 0;
|
|
}
|
|
|
|
int socks5_server_reply_atyp_ipv6(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo) {
|
|
struct socks5_ctx* s5ctx = fdinfo->other;
|
|
size_t fixed_headers_size = (void*)&s5ctx->sr.bind_addr.ipv6 - (void*)&s5ctx->sr;
|
|
size_t host_size = sizeof(s5ctx->sr.bind_addr.ipv6);
|
|
uint64_t relative_cursor = (s5ctx->sr_cursor - fixed_headers_size);
|
|
int nread = 0;
|
|
|
|
nread = read(fdinfo->fd,
|
|
s5ctx->sr.bind_addr.ipv6 + relative_cursor,
|
|
host_size - relative_cursor);
|
|
|
|
if (nread == -1 && errno == EAGAIN) return 1;
|
|
if (nread < 0) {
|
|
perror("write failed on tcp socket in socks5");
|
|
evt_core_mv_fd2(ctx, fdinfo, "socks5-failed");
|
|
fdinfo->cat->cb(ctx, fdinfo);
|
|
return 1;
|
|
}
|
|
s5ctx->sr_cursor += nread;
|
|
if (s5ctx->sr_cursor < fixed_headers_size + host_size) return 0;
|
|
|
|
s5ctx->sr_atyp_read = 1;
|
|
return 0;
|
|
}
|
|
|
|
int socks5_server_reply_atyp_dn(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo) {
|
|
struct socks5_ctx* s5ctx = fdinfo->other;
|
|
size_t fixed_headers_size = (void*)&s5ctx->sr.bind_addr.ipv6 - (void*)&s5ctx->sr;
|
|
size_t dn_size_size = sizeof(s5ctx->sr.bind_addr.dns.len);
|
|
uint64_t relative_cursor = 0;
|
|
int nread = 0;
|
|
|
|
if (s5ctx->sr_cursor < fixed_headers_size + dn_size_size) {
|
|
relative_cursor = (s5ctx->sr_cursor - fixed_headers_size);
|
|
nread = read(fdinfo->fd, &s5ctx->sr.bind_addr.dns.len + relative_cursor, dn_size_size - relative_cursor);
|
|
if (nread == -1 && errno == EAGAIN) return 1;
|
|
if (nread < 0) {
|
|
perror("write failed on tcp socket in socks5");
|
|
evt_core_mv_fd2(ctx, fdinfo, "socks5-failed");
|
|
fdinfo->cat->cb(ctx, fdinfo);
|
|
return 1;
|
|
}
|
|
s5ctx->sr_cursor += nread;
|
|
return 0;
|
|
}
|
|
|
|
relative_cursor = s5ctx->sr_cursor - fixed_headers_size - sizeof(s5ctx->sr.bind_addr.dns.len);
|
|
nread = read(fdinfo->fd, &s5ctx->sr.bind_addr.dns.str + relative_cursor, s5ctx->sr.bind_addr.dns.len - relative_cursor);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int on_socks5_recv_server_reply(struct evt_core_ctx* ctx, struct evt_core_fdinfo* fdinfo) {
|
|
struct socks5_ctx* s5ctx = fdinfo->other;
|
|
int readn = 0;
|
|
size_t fixed_headers_size = (void*)&s5ctx->sr.bind_addr - (void*)&s5ctx->sr;
|
|
size_t fixed_tail_size = (void*)(&s5ctx->sr + 1) - (void*)&s5ctx->sr.port ;
|
|
|
|
if (s5ctx->sr_cursor < fixed_headers_size) {
|
|
readn = read(fdinfo->fd, &s5ctx->sr + s5ctx->sr_cursor, fixed_headers_size - s5ctx->sr_cursor);
|
|
if (readn == -1 && errno == EAGAIN) return 1;
|
|
if (readn < 0) goto move_to_failed;
|
|
s5ctx->sr_cursor += readn;
|
|
return 0; // Needed as we might have not read enough bytes and free us from writing a loop
|
|
}
|
|
|
|
if (!s5ctx->sr_atyp_read) {
|
|
if (s5ctx->sr.atyp == ATYP_IPV4) return socks5_server_reply_atyp_ipv4(ctx, fdinfo);
|
|
else if (s5ctx->sr.atyp == ATYP_IPV6) return socks5_server_reply_atyp_ipv6(ctx, fdinfo);
|
|
else if (s5ctx->sr.atyp == ATYP_DOMAINNAME) return socks5_server_reply_atyp_dn(ctx, fdinfo);
|
|
else goto move_to_failed;
|
|
}
|
|
|
|
move_to_failed:
|
|
evt_core_mv_fd2 (ctx, fdinfo, "socks5-failed");
|
|
fdinfo->cat->cb(ctx, fdinfo);
|
|
return 1;
|
|
/*int res;
|
|
struct server_reply sr = {0};
|
|
res = read_entity(sock, &sr, sizeof(uint8_t) * 4);
|
|
if (res == -1) goto read_error;
|
|
|
|
switch(sr.atyp) {
|
|
case ATYP_IPV4:
|
|
if (read_entity(sock, sr.bind_addr.ipv4, sizeof(uint8_t) * 4) == -1)
|
|
goto read_error;
|
|
break;
|
|
case ATYP_DOMAINNAME:
|
|
if (read_entity(sock, &sr.bind_addr.dns.len, sizeof(uint8_t) * 4) == -1)
|
|
goto read_error;
|
|
if (read_entity(sock, sr.bind_addr.dns.str, sizeof(char) * sr.bind_addr.dns.len) == -1)
|
|
goto read_error;
|
|
break;
|
|
case ATYP_IPV6:
|
|
if (read_entity(sock, sr.bind_addr.ipv6, sizeof(uint8_t) * 16) == -1)
|
|
goto read_error;
|
|
break;
|
|
default:
|
|
fprintf(stderr, "Unsupported ATYP in server reply\n");
|
|
return -128;
|
|
}
|
|
res = read_entity(sock, &sr.port, sizeof(uint16_t));
|
|
if (res == -1) {
|
|
perror("read_entity");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
if (sr.rep < 0 || sr.rep > 0x08) {
|
|
fprintf(stderr, "Invalid reply field\n");
|
|
return -128;
|
|
}
|
|
|
|
printf("[server_reply] ver=%d, rep=%s, atyp=%d, port=%d\n", sr.ver, rep_msg[sr.rep], sr.atyp, sr.port);
|
|
return -sr.rep;
|
|
|
|
read_error:
|
|
fprintf(stderr, "Unable to read ATYP\n");
|
|
return -128;*/
|
|
}
|
|
|
|
char* socks5_rep (enum socks5_rep rep) {
|
|
return rep_msg[rep];
|
|
}
|