ims-volte-vowifi
/
doubango
9
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
doubango/tinyNET/src/tnet_proxy_node_socks_plugin.c

941 lines
40 KiB
C
Executable File
Raw Blame History

/*
* Copyright (C) 2010-2015 Mamadou DIOP.
* Copyright (C) 2015 Doubango Telecom.
*
* This file is part of Open Source Doubango Framework.
*
* DOUBANGO is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* DOUBANGO is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with DOUBANGO.
*
*/
// http://en.wikipedia.org/wiki/SOCKS
// SOCKS Protocol Version 5: http://tools.ietf.org/html/rfc1928
// Username/Password Authentication for SOCKS V5: https://www.ietf.org/rfc/rfc1929.txt
// GSS-API Authentication Method for SOCKS Version 5: https://tools.ietf.org/html/rfc1961
// SSPI/Kerberos Interoperability with GSSAPI: https://msdn.microsoft.com/en-us/library/ms995352.aspx
// Mozilla issue: https://bugzilla.mozilla.org/show_bug.cgi?id=122752
#include "tnet_proxy_node_socks_plugin.h"
#include "tnet_proxy_plugin.h"
#include "tnet_socket.h"
#include "tnet_utils.h"
#include "tnet_endianness.h"
#include "tsk_safeobj.h"
#include "tsk_buffer.h"
#include "tsk_memory.h"
#include "tsk_string.h"
#include "tsk_debug.h"
#if TNET_UNDER_APPLE
# if !defined(USING_CFSTREAM)
# define USING_CFSTREAM 0 // Works with HTTP streams only :(
# endif /* USING_CFSTREAM */
#endif /* TNET_UNDER_APPLE */
#if USING_CFSTREAM
# import <CFNetwork/CFNetwork.h>
# import <SystemConfiguration/SystemConfiguration.h>
#endif /* TNET_UNDER_APPLE */
#if HAVE_GSSAPI_H
# if TNET_UNDER_APPLE
# include <GSS/gssapi.h>
# else
# include <gssapi.h>
# endif
#endif /* HAVE_GSSAPI_H */
#define kSocks4StatusGranted 0x5a
#if !defined(TNET_SOCKS5_HAVE_AUTH_NONE)
# define TNET_SOCKS5_HAVE_AUTH_NONE 1
#endif /* TNET_SOCKS5_HAVE_AUTH_NONE */
#if !defined(TNET_SOCKS5_HAVE_AUTH_USRPWD)
# define TNET_SOCKS5_HAVE_AUTH_USRPWD 1
#endif /* TNET_SOCKS5_HAVE_AUTH_USRPWD */
#if !defined(TNET_SOCKS5_HAVE_AUTH_GSSAPI)
# if HAVE_GSSAPI_H // TODO: Add Microsoft SSPI
# define TNET_SOCKS5_HAVE_AUTH_GSSAPI 0
# endif /* HAVE_GSSAPI_H */
#endif /* TNET_SOCKS5_HAVE_AUTH_GSSAPI */
#if !TNET_SOCKS5_HAVE_AUTH_NONE && !TNET_SOCKS5_HAVE_AUTH_USRPWD && !TNET_SOCKS5_HAVE_AUTH_GSSAPI
# error "At least one Socks5 authentication method must be enabled"
#endif
#define kSocks5AuthMethodNone 0x00 // NO AUTHENTICATION REQUIRED
#define kSocks5AuthMethodGSSAPI 0x01 // GSSAPI
#define kSocks5AuthMethodUsrPwd 0x02 // USERNAME/PASSWORD
typedef int socks5_auth_method_t;
typedef enum socks5_state_e {
socks5_state_none,
socks5_state_greeting,
socks5_state_auth_req,
socks5_state_conn_req,
socks5_state_conn_accept,
socks5_state_error
}
socks5_state_t;
typedef struct tnet_proxy_node_socks_plugin_s {
TNET_DECLARE_PROXY_NONE;
struct {
tsk_bool_t completed;
tsk_bool_t started;
tsk_buffer_t* buff;
uint8_t* pending_data_ptr;
tsk_size_t pending_data_len;
socks5_state_t socks5_state;
socks5_auth_method_t socks5_auth_method;
#if TNET_SOCKS5_HAVE_AUTH_GSSAPI
struct {
gss_ctx_id_t ctx;
OM_uint32 status_minor;
OM_uint32 status_major;
gss_name_t server_name;
tsk_bool_t init_sec_complete;
} gss;
#endif /* TNET_SOCKS5_HAVE_AUTH_GSSAPI */
} handshacking;
TSK_DECLARE_SAFEOBJ;
}
tnet_proxy_node_socks_plugin_t;
static const char* __socks5_state_to_string(socks5_state_t state);
static const char* __socks5_method_to_string(socks5_auth_method_t method);
#if TNET_SOCKS5_HAVE_AUTH_GSSAPI
static int __socks5_gss_import_name(tnet_proxy_node_t* self);
static int __socks5_gss_init_sec_context(tnet_proxy_node_t* self);
static void __socks_gss_print_error(const char* info, OM_uint32 status_major, OM_uint32 status_minor);
#endif /* TNET_SOCKS5_HAVE_AUTH_GSSAPI */
static int _tnet_proxy_node_socks_plugin_configure(tnet_proxy_node_t* self, ...)
{
tnet_proxy_node_socks_plugin_t* node = (tnet_proxy_node_socks_plugin_t*)self;
va_list ap;
int ret = 0;
// input parameters already checked by the caller
tsk_safeobj_lock(node);
// extract dst_host, dst_port, proxy_host, proxy_port, ipv6_enabled, ...
va_start(ap, self);
ret = tnet_proxy_node_configure_2(self, &ap);
va_end(ap);
tsk_safeobj_unlock(node);
return 0;
}
static int _tnet_proxy_node_socks_plugin_start_handshaking(tnet_proxy_node_t* self)
{
tnet_proxy_node_socks_plugin_t* node = (tnet_proxy_node_socks_plugin_t*)self;
int ret = 0;
// input parameters already checked by the caller
tsk_safeobj_lock(node);
if (node->handshacking.started) {
TSK_DEBUG_ERROR("handshaking already started");
goto bail;
}
if (tsk_strnullORempty(self->dst_host) || !self->dst_port) {
TSK_DEBUG_ERROR("Invalid proxy host and/or port for socks server %s:%hu", self->proxy_host, self->proxy_port);
ret = -2;
goto bail;
}
// reset pending data
TSK_FREE(node->handshacking.pending_data_ptr);
node->handshacking.pending_data_len = 0;
#if USING_CFSTREAM
if (tsk_strnullORempty(self->proxy_host) || !self->proxy_port) {
TSK_DEBUG_ERROR("Invalid proxy host and/or port for socks server %s:%hu", self->proxy_host, self->proxy_port);
ret = -2;
goto bail;
}
if (!self->cf_read_stream || !self->cf_write_stream) {
TSK_DEBUG_ERROR("Invalid CFStreams: read=%d write=%d", !!self->cf_read_stream, !!self->cf_write_stream);
ret = -3;
goto bail;
}
CFStringRef cfstrHost = CFStringCreateWithCStringNoCopy(kCFAllocatorDefault, self->proxy_host, kCFStringEncodingUTF8, NULL);
int intPort = (int)self->proxy_port;
CFNumberRef cfintPort = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &intPort);
CFDictionaryRef proxyDict = CFNetworkCopySystemProxySettings();
CFMutableDictionaryRef socksConfig = CFDictionaryCreateMutableCopy(kCFAllocatorDefault, 0, proxyDict);
CFDictionarySetValue(socksConfig, kCFStreamPropertySOCKSProxyHost, cfstrHost);
CFDictionarySetValue(socksConfig, kCFStreamPropertySOCKSProxyPort, cfintPort);
CFDictionarySetValue(socksConfig, kCFStreamPropertySOCKSVersion, self->type == tnet_proxy_type_socks4 ? kCFStreamSocketSOCKSVersion4 : kCFStreamSocketSOCKSVersion5);
if (!tsk_strnullORempty(self->login)) {
CFStringRef cfstrLogin = CFStringCreateWithCStringNoCopy(kCFAllocatorDefault, self->login, kCFStringEncodingUTF8, NULL);
CFDictionarySetValue(socksConfig, kCFStreamPropertySOCKSUser, cfstrLogin);
CFRelease(cfstrLogin);
}
if (!tsk_strnullORempty(self->password)) {
CFStringRef cfstrPassword = CFStringCreateWithCStringNoCopy(kCFAllocatorDefault, self->password, kCFStringEncodingUTF8, NULL);
CFDictionarySetValue(socksConfig, kCFStreamPropertySOCKSPassword, cfstrPassword);
CFRelease(cfstrPassword);
}
if (!CFReadStreamSetProperty(self->cf_read_stream, kCFStreamPropertySOCKSProxy, socksConfig)) {
CFStreamError error = CFReadStreamGetError(self->cf_read_stream);
TSK_DEBUG_INFO("CFReadStreamSetProperty(kCFStreamPropertySOCKSProxy) failed code=%d, domain=%ld", (int)error.error, error.domain);
ret = -4;
}
else if (!CFWriteStreamSetProperty(self->cf_write_stream, kCFStreamPropertySOCKSProxy, socksConfig)) {
CFStreamError error = CFWriteStreamGetError(self->cf_write_stream);
TSK_DEBUG_INFO("CFWriteStreamSetProperty(kCFStreamPropertySOCKSProxy) code=%d, domain=%ld", (int)error.error, error.domain);
ret = -5;
}
CFRelease(cfstrHost);
CFRelease(cfintPort);
CFRelease(socksConfig);
CFRelease(proxyDict);
node->handshacking.started = (ret == 0);
node->handshacking.completed = node->handshacking.started; // no handshaking data to send, up to the system
#else
{
tsk_size_t size_to_reserve, userid_len = tsk_strlen(self->login), domain_len = 0;
if (self->type == tnet_proxy_type_socks4 || self->type == tnet_proxy_type_socks4a) {
size_to_reserve = 1 /* version number */
+ 1 /* command code */
+ 2 /* network byte order port number */
+ 4 /* network byte order IP address */
+ userid_len + 1 /* the user ID string, variable length, terminated with a null (0x00) */
;
if (self->type == tnet_proxy_type_socks4a) {
domain_len = tsk_strlen(self->dst_host);
size_to_reserve += domain_len + 1/* the domain name of the host we want to contact, variable length, terminated with a null (0x00) */
;
}
}
else { // SOCKS5
if (node->handshacking.socks5_state != socks5_state_none) {
TSK_DEBUG_ERROR("Socks5 handshaking state mut start at none");
ret = -6;
goto bail;
}
// Greeting
size_to_reserve = 1 /* version number */
+ 1 /* number of authentication methods supported */
#if TNET_SOCKS5_HAVE_AUTH_NONE
+ 1
#endif
#if TNET_SOCKS5_HAVE_AUTH_USRPWD
+ 1
#endif
#if TNET_SOCKS5_HAVE_AUTH_GSSAPI
+ 1
#endif
;
}
node->handshacking.pending_data_ptr = (uint8_t*)tsk_realloc(node->handshacking.pending_data_ptr, size_to_reserve);
if (!node->handshacking.pending_data_ptr) {
TSK_DEBUG_ERROR("Failed to allocate buffer with size = %u", (unsigned)size_to_reserve);
node->handshacking.pending_data_len = 0;
ret = -5;
goto bail;
}
node->handshacking.pending_data_len = size_to_reserve;
if (self->type == tnet_proxy_type_socks4 || self->type == tnet_proxy_type_socks4a) {
node->handshacking.pending_data_ptr[0] = 0x04; // version number
node->handshacking.pending_data_ptr[1] = 0x01; // establish a TCP/IP stream connection (caller aldready check we're dealing with Streams)
node->handshacking.pending_data_ptr[2] = (self->dst_port >> 8) & 0xFF; // port, first byte
node->handshacking.pending_data_ptr[3] = self->dst_port & 0xFF; // port, second byte
if (self->type == tnet_proxy_type_socks4) {
struct sockaddr_storage addr;
// network byte order IPv4 address (SOCKS4 doesn't support hostnames)
if ((ret = tnet_sockaddr_init(self->dst_host, self->dst_port, self->socket.type, &addr)) != 0 || addr.ss_family != AF_INET) {
TSK_DEBUG_ERROR("tnet_sockaddr_init(%s, %d, %d) failed", self->dst_host, self->dst_port, self->socket.type);
ret = -6;
goto bail;
}
memcpy(&node->handshacking.pending_data_ptr[4], (void*)&((const struct sockaddr_in*)&addr)->sin_addr.s_addr, 4);
}
else {
// deliberate invalid IP address, 4 bytes, first three must be 0x00 and the last one must not be 0x00
node->handshacking.pending_data_ptr[4] = 0x00;
node->handshacking.pending_data_ptr[5] = 0x00;
node->handshacking.pending_data_ptr[6] = 0x00;
node->handshacking.pending_data_ptr[7] = 0x83; // non-zeo byte
}
// the user ID string, variable length, terminated with a null (0x00)
if (userid_len > 0) {
memcpy(&node->handshacking.pending_data_ptr[8], self->login, userid_len);
}
node->handshacking.pending_data_ptr[8 + userid_len] = 0x00;
// the domain name of the host we want to contact, variable length, terminated with a null (0x00)
if (self->type == tnet_proxy_type_socks4a) {
if (domain_len > 0) {
memcpy(&node->handshacking.pending_data_ptr[8 + userid_len + 1], self->dst_host, domain_len);
}
node->handshacking.pending_data_ptr[8 + userid_len + 1 + domain_len] = 0x00;
}
}
else { // SOCKS5
uint8_t* auths_ptr = &node->handshacking.pending_data_ptr[2];
node->handshacking.pending_data_ptr[0] = 0x05; // version number
node->handshacking.pending_data_ptr[1] = 0x00; // number of authentication methods supported
#if TNET_SOCKS5_HAVE_AUTH_NONE
node->handshacking.pending_data_ptr[1] += 1;
#endif
#if TNET_SOCKS5_HAVE_AUTH_USRPWD
node->handshacking.pending_data_ptr[1] += 1;
#endif
#if TNET_SOCKS5_HAVE_AUTH_GSSAPI
node->handshacking.pending_data_ptr[1] += 1;
#endif
#if TNET_SOCKS5_HAVE_AUTH_GSSAPI
*auths_ptr++ = kSocks5AuthMethodGSSAPI;
#endif
#if TNET_SOCKS5_HAVE_AUTH_USRPWD
*auths_ptr++ = kSocks5AuthMethodUsrPwd;
#endif
#if TNET_SOCKS5_HAVE_AUTH_NONE
*auths_ptr++ = kSocks5AuthMethodNone;
#endif
// change state from none to greeting
node->handshacking.socks5_state = socks5_state_greeting;
}
node->handshacking.started = tsk_true;
}
#endif
bail:
tsk_safeobj_unlock(node);
return ret;
}
static int _tnet_proxy_node_socks_plugin_set_handshaking_data(tnet_proxy_node_t* self, const void* data_ptr, tsk_size_t data_size)
{
tnet_proxy_node_socks_plugin_t* node = (tnet_proxy_node_socks_plugin_t*)self;
int ret = 0;
// input parameters already checked by the caller
tsk_safeobj_lock(node);
if (!node->handshacking.started) {
TSK_DEBUG_ERROR("handshaking not started");
ret = -3;
goto bail;
}
#if USING_CFSTREAM
TSK_DEBUG_ERROR("Up to CFStreams to handle handshaking");
ret = -2;
goto bail;
#else
if (!node->handshacking.buff) {
if (!(node->handshacking.buff = tsk_buffer_create(data_ptr, data_size))) {
ret = -2;
goto bail;
}
}
else {
if ((ret = tsk_buffer_append(node->handshacking.buff, data_ptr, data_size)) != 0) {
goto bail;
}
}
if (self->type == tnet_proxy_type_socks4 || self->type == tnet_proxy_type_socks4a) {
static const tsk_size_t min_bytes_count = 8;
const uint8_t* buff = (const uint8_t*)node->handshacking.buff->data;
uint8_t status;
if (node->handshacking.buff->size < min_bytes_count) {
TSK_DEBUG_INFO("Not enough data in the SOCKS4/4a handshaking buffer yet");
goto bail;
}
status = buff[1];
TSK_DEBUG_INFO("SOCKS4/4a status = 0x%x", status);
if (status != kSocks4StatusGranted) { // status == granted ?
TSK_DEBUG_ERROR("SOCKS response from the server has status equal to 0x%x", status);
ret = -3;
goto bail;
}
// remove already parsed data
tsk_buffer_remove(node->handshacking.buff, 0, min_bytes_count);
// handshaking is done ?
node->handshacking.completed = (status == kSocks4StatusGranted);
}
else if (self->type == tnet_proxy_type_socks5) {
const uint8_t* buff = (const uint8_t*)node->handshacking.buff->data;
TSK_DEBUG_INFO("Socks5 state = %s", __socks5_state_to_string(node->handshacking.socks5_state));
if (node->handshacking.socks5_state == socks5_state_greeting) {
// response to greeting
if (node->handshacking.buff->size < 2/*1-byte version + 1-byte authentication method*/) {
TSK_DEBUG_INFO("Not enough data in the SOCKS5 handshaking buffer yet");
goto bail;
}
if (buff[0] != 0x05) {
TSK_DEBUG_ERROR("Invalid version (%d)", buff[0]);
ret = -3;
goto bail;
}
if (buff[1] == kSocks5AuthMethodNone || buff[1] == kSocks5AuthMethodUsrPwd || buff[1] == kSocks5AuthMethodGSSAPI) {
node->handshacking.socks5_auth_method = (socks5_auth_method_t)buff[1];
TSK_DEBUG_INFO("Server selected Socks5 authentication method = %s", __socks5_method_to_string(node->handshacking.socks5_auth_method));
tsk_buffer_remove(node->handshacking.buff, 0, 2); // remove parsed bytes
if (node->handshacking.socks5_auth_method == kSocks5AuthMethodNone) {
node->handshacking.socks5_state = socks5_state_conn_req;
// FIXME:
TSK_DEBUG_ERROR("Not implemented yet");
ret = -3;
goto bail;
}
else {
if (node->handshacking.socks5_auth_method == kSocks5AuthMethodUsrPwd) {
tsk_size_t userlen = tsk_strlen(self->login), pwdlen = tsk_strlen(self->password);
tsk_size_t size_to_reserve = 1 /* version number */
+ 1 /* username length */
+ userlen /* username */
+ 1 /* password length */
+ pwdlen;
node->handshacking.pending_data_ptr = (uint8_t*)tsk_realloc(node->handshacking.pending_data_ptr, size_to_reserve);
if (!node->handshacking.pending_data_ptr) {
TSK_DEBUG_ERROR("Failed to allocate buffer with size = %u", (unsigned)size_to_reserve);
node->handshacking.pending_data_len = 0;
ret = -5;
goto bail;
}
node->handshacking.pending_data_len = size_to_reserve;
node->handshacking.pending_data_ptr[0] = 0x01;
node->handshacking.pending_data_ptr[1] = (userlen & 0xFF);
if (userlen > 0) {
memcpy(&node->handshacking.pending_data_ptr[2], self->login, userlen);
}
node->handshacking.pending_data_ptr[2 + userlen] = (uint8_t)pwdlen;
if (pwdlen > 0) {
memcpy(&node->handshacking.pending_data_ptr[2 + userlen + 1], self->password, pwdlen);
}
node->handshacking.socks5_state = socks5_state_auth_req;
}
else if (node->handshacking.socks5_auth_method == kSocks5AuthMethodGSSAPI) {
#if TNET_SOCKS5_HAVE_AUTH_GSSAPI
if ((ret = __socks5_gss_import_name(self))) {
TSK_DEBUG_ERROR("gss_import_name() failed");
goto bail;
}
if ((ret = __socks5_gss_init_sec_context(self))) {
TSK_DEBUG_ERROR("gss_import_name() failed");
goto bail;
}
#else
TSK_DEBUG_ERROR("GSSAPI not supported");
ret = -3;
goto bail;
#endif
}
else {
TSK_DEBUG_ERROR("Not implemented yet");
ret = -3;
goto bail;
}
}
}
else {
TSK_DEBUG_ERROR("Invalid authentication method (%d)", buff[1]);
ret = -3;
goto bail;
}
}
else if (node->handshacking.socks5_state == socks5_state_auth_req) {
// response to authentication
if (node->handshacking.socks5_auth_method == kSocks5AuthMethodUsrPwd) {
if (node->handshacking.buff->size < 2/*1-byte version + 1-byte status code*/) {
TSK_DEBUG_INFO("Not enough data in the SOCKS5 handshaking buffer yet");
goto bail;
}
if (buff[0] != 0x1) {
TSK_DEBUG_ERROR("Invalid version :%d", buff[0]);
ret = -3;
goto bail;
}
TSK_DEBUG_INFO("Socks5 authentication status code: %d", buff[1]);
if (buff[1] != 0x00) {
TSK_DEBUG_ERROR("Authentication failed with status code :%d", buff[1]);
ret = -3;
goto bail;
}
tsk_buffer_remove(node->handshacking.buff, 0, 2); // remove parsed bytes
node->handshacking.socks5_state = socks5_state_conn_req;
}
else if (node->handshacking.socks5_auth_method == kSocks5AuthMethodGSSAPI) {
// FIXME:
TSK_DEBUG_ERROR("Not implemented yet");
ret = -3;
goto bail;
}
else {
TSK_DEBUG_ERROR("Invalid authentication method (%d)", buff[1]);
ret = -3;
goto bail;
}
// State changed from "auth_req" to "conn_req" : build connection request
if (node->handshacking.socks5_state == socks5_state_conn_req) {
#define kAddrTypeIPv4 0x01
#define kAddrTypeDomaineName 0x03
#define kAddrTypeIPv6 0x04
struct sockaddr_storage addr;
tsk_bool_t is_ip = tsk_false; // ip or domain name
uint8_t addr_type = 0x00;
tsk_size_t dst_addr_len = 0, size_to_reserve = 1 /* version number */
+ 1 /* command code */
+ 1 /* reserved, must be 0x00 */
+ 1 /* address type */
+ 0 /* destination address (==to be computed later==) */
+ 2 /* port number in a network byte order */
;
if ((ret = tnet_sockaddr_init(self->dst_host, self->dst_port, self->socket.type, &addr)) != 0) {
TSK_DEBUG_WARN("tnet_sockaddr_init(%s, %d, %d) failed", self->dst_host, self->dst_port, self->socket.type);
// maybe DNS issue (e.g UDP blocked), do not exit, up to the server to resolve it
is_ip = tsk_false;
}
else {
tnet_ip_t ip = {0};
tnet_get_sockip((const struct sockaddr *)&addr, &ip);
is_ip = tsk_striequals(self->dst_host, ip);
}
if (is_ip) {
dst_addr_len = (addr.ss_family == AF_INET6) ? 16 : 4;
addr_type = (addr.ss_family == AF_INET6) ? kAddrTypeIPv6 : kAddrTypeIPv4;
}
else {
dst_addr_len = 1 /* length*/ + tsk_strlen(self->dst_host);
addr_type = kAddrTypeDomaineName;
}
size_to_reserve += dst_addr_len;
node->handshacking.pending_data_ptr = (uint8_t*)tsk_realloc(node->handshacking.pending_data_ptr, size_to_reserve);
if (!node->handshacking.pending_data_ptr) {
TSK_DEBUG_ERROR("Failed to allocate buffer with size = %u", (unsigned)size_to_reserve);
node->handshacking.pending_data_len = 0;
ret = -5;
goto bail;
}
node->handshacking.pending_data_len = size_to_reserve;
node->handshacking.pending_data_ptr[0] = 0x05; // version number
node->handshacking.pending_data_ptr[1] = 0x01; // establish a TCP/IP stream connection
node->handshacking.pending_data_ptr[2] = 0x00; // reserved, must be 0x00
node->handshacking.pending_data_ptr[3] = addr_type;
if (addr_type == kAddrTypeIPv4) {
memcpy(&node->handshacking.pending_data_ptr[4], (void*)&((const struct sockaddr_in*)&addr)->sin_addr.s_addr, 4);
}
else if (addr_type == kAddrTypeIPv6) {
memcpy(&node->handshacking.pending_data_ptr[4], (void*)&((const struct sockaddr_in6*)&addr)->sin6_addr, 16);
}
else { // DomaineName
node->handshacking.pending_data_ptr[4] = (uint8_t)(dst_addr_len - 1);/* length */;
memcpy(&node->handshacking.pending_data_ptr[5], self->dst_host, (dst_addr_len - 1));
}
node->handshacking.pending_data_ptr[4 + dst_addr_len] = (self->dst_port >> 8) & 0xFF;
node->handshacking.pending_data_ptr[4 + dst_addr_len + 1] = (self->dst_port & 0xFF);
}
}
else if (node->handshacking.socks5_state == socks5_state_conn_req) {
// response to connection request
if (node->handshacking.buff->size < 2/*1-byte version + 1-byte status*/) {
TSK_DEBUG_INFO("Not enough data in the SOCKS5 handshaking buffer yet");
goto bail;
}
if (buff[0] != 0x05) {
TSK_DEBUG_ERROR("Invalid version (%d)", buff[0]);
ret = -3;
goto bail;
}
TSK_DEBUG_INFO("Socks5 connection request status code: %d", buff[1]);
if (buff[1] != 0x00) {
TSK_DEBUG_ERROR("Socks5 connection request failed with status code :%d", buff[1]);
ret = -3;
goto bail;
}
tsk_buffer_remove(node->handshacking.buff, 0, 2); // remove parsed bytes
node->handshacking.socks5_state = socks5_state_conn_accept;
node->handshacking.completed = tsk_true;
}
else if (node->handshacking.socks5_state == socks5_state_conn_accept) {
TSK_DEBUG_INFO("Socks5 connection accepted");
// nothing else to do
}
else {
// FIXME:
TSK_DEBUG_ERROR("Not implemented yet");
ret = -3;
goto bail;
}
}
else {
TSK_DEBUG_ERROR("Invalid proxy type:%d", self->type);
ret = -3;
goto bail;
}
#endif
bail:
if (ret != 0) {
if (self->type == tnet_proxy_type_socks5) {
node->handshacking.socks5_state = socks5_state_error;
}
}
tsk_safeobj_unlock(node);
return ret;
}
static int _tnet_proxy_node_socks_plugin_get_handshaking_pending_data(tnet_proxy_node_t* self, void** data_pptr, tsk_size_t* data_psize)
{
tnet_proxy_node_socks_plugin_t* node = (tnet_proxy_node_socks_plugin_t*)self;
int ret = -1;
// input parameters already checked by the caller
tsk_safeobj_lock(node);
#if USING_CFSTREAM
*data_psize = 0; // no pending data
ret = 0;
#else
if (node->handshacking.pending_data_ptr && node->handshacking.pending_data_len > 0) {
if ((*data_pptr = tsk_realloc(*data_pptr, node->handshacking.pending_data_len))) {
memcpy(*data_pptr, node->handshacking.pending_data_ptr, (tsk_size_t) node->handshacking.pending_data_len);
*data_psize = node->handshacking.pending_data_len;
ret = 0;
}
// reset the pending data. Up to the caller to hold the returned data and send it as many as required (e.g. when using unreliable transport)
TSK_FREE(node->handshacking.pending_data_ptr);
node->handshacking.pending_data_len = 0;
}
#endif
tsk_safeobj_unlock(node);
return ret;
}
static int _tnet_proxy_node_socks_plugin_get_handshaking_completed(tnet_proxy_node_t* self, tsk_bool_t* completed)
{
tnet_proxy_node_socks_plugin_t* node = (tnet_proxy_node_socks_plugin_t*)self;
int ret = 0;
// input parameters already checked by the caller
tsk_safeobj_lock(node);
*completed = node->handshacking.completed;
tsk_safeobj_unlock(node);
return ret;
}
static const char* __socks5_state_to_string(socks5_state_t state)
{
switch (state) {
case socks5_state_none:
return "none";
case socks5_state_greeting:
return "greeting";
case socks5_state_auth_req:
return "auth_req";
case socks5_state_conn_req:
return "conn_req";
case socks5_state_conn_accept:
return "conn_accept";
case socks5_state_error:
return "error";
default:
return "unknown";
}
}
static const char* __socks5_method_to_string(socks5_auth_method_t method)
{
switch (method) {
case kSocks5AuthMethodNone:
return "none";
case kSocks5AuthMethodGSSAPI:
return "gssapi";
case kSocks5AuthMethodUsrPwd:
return "usr/pwd";
default:
return "unknown";
}
}
#if TNET_SOCKS5_HAVE_AUTH_GSSAPI
// rfc1961 - 3.1 Preparation
static int __socks5_gss_import_name(tnet_proxy_node_t* self)
{
int i, ret = 0;
tnet_proxy_node_socks_plugin_t* node = (tnet_proxy_node_socks_plugin_t*)self;
gss_buffer_desc input_name_buffer = GSS_C_EMPTY_BUFFER;
if (!self) {
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
// reset context
node->handshacking.gss.ctx = GSS_C_NO_CONTEXT;
// reset pending handshaking data
TSK_FREE(node->handshacking.pending_data_ptr);
node->handshacking.pending_data_len = 0;
/*
For example, when using Kerberos V5 naming, the imported name may be
of the form "SERVICE:socks@socks_server_hostname" where
"socks_server_hostname" is the fully qualified host name of the
server with all letters in lower case.
*/
input_name_buffer.length = tsk_sprintf((char**)&input_name_buffer.value, "SERVICE:socks@%s", self->proxy_host);
for (i = 0; i < input_name_buffer.length; ++i) {
((char*)input_name_buffer.value)[i] = tolower(((char*)input_name_buffer.value)[i]);
}
/*
The client should call gss_import_name to obtain an internal
representation of the server name. For maximal portability the
default name_type GSS_C_NULL_OID should be used to specify the
default name space, and the input name_string should treated by the
client's code as an opaque name-space specific input.
*/
node->handshacking.gss.status_major = gss_import_name(&node->handshacking.gss.status_minor, &input_name_buffer, GSS_C_NULL_OID, &node->handshacking.gss.server_name);
TSK_DEBUG_INFO("gss_import_name(%.*s, GSS_C_NULL_OID): minor_status = %u, major_status = %u", (int)input_name_buffer.length, (const char*)input_name_buffer.value, node->handshacking.gss.status_minor, node->handshacking.gss.status_major);
if (node->handshacking.gss.status_major != GSS_S_COMPLETE) {
__socks_gss_print_error("gss_import_name failed", node->handshacking.gss.status_major, node->handshacking.gss.status_minor);
ret = -2;
goto bail;
}
/* debug */{
gss_OID output_name_type;
gss_buffer_desc output_name = GSS_C_EMPTY_BUFFER;
node->handshacking.gss.status_major = gss_display_name(&node->handshacking.gss.status_minor,
node->handshacking.gss.server_name,
&output_name,
&output_name_type);
TSK_DEBUG_INFO("gss_display_name(%.*s): minor_status = %u, major_status = %u, output = %.*s", (int)input_name_buffer.length, (const char*)input_name_buffer.value, node->handshacking.gss.status_minor, node->handshacking.gss.status_major, (int)output_name.length, (const char*)output_name.value);
node->handshacking.gss.status_major = gss_release_buffer(&node->handshacking.gss.status_minor, &output_name);
}
bail:
gss_release_buffer(&node->handshacking.gss.status_minor, &input_name_buffer);
return 0;
}
// 3.2 Client Context Establishment
// 3.3 Client Context Establishment Major Status codes
static int __socks5_gss_init_sec_context(tnet_proxy_node_t* self)
{
int ret = 0;
OM_uint32 req_flags;
tnet_proxy_node_socks_plugin_t* node = (tnet_proxy_node_socks_plugin_t*)self;
gss_buffer_desc input_token = GSS_C_EMPTY_BUFFER, *input_token_ptr = GSS_C_NO_BUFFER;
gss_buffer_desc output_token = GSS_C_EMPTY_BUFFER;
/*
+------+------+------+.......................+
+ ver | mtyp | len | token |
+------+------+------+.......................+
+ 0x01 | 0x01 | 0x02 | up to 2^16 - 1 octets |
+------+------+------+.......................+
*/
#define kTokenMsgHdrLongLen 4 // with "len" field
#define kTokenMsgHdrShortLen 2 // without "len" field
if (!self) {
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
if (node->handshacking.buff && node->handshacking.buff->size >= kTokenMsgHdrShortLen) {
const uint8_t* buff = (const uint8_t*)node->handshacking.buff->data;
if (buff[1] == kSocks5AuthMethodGSSAPI) {
if (node->handshacking.buff->size >= kTokenMsgHdrLongLen) {
uint16_t len = ((buff[2] << 8) & 0x00FF) | (buff[3] & 0xFF);
if (len >= kTokenMsgHdrLongLen + node->handshacking.buff->size) {
input_token.value = (void*) (buff + kTokenMsgHdrLongLen);
input_token.length = (size_t)len;
input_token_ptr = &input_token;
TSK_DEBUG_INFO("GSS Input token: ver=%d, mtyp=%d, len=%d", buff[0], buff[1], len);
}
}
}
else {
TSK_DEBUG_ERROR("GSS invalid mtyp(%u)", buff[1]);
ret = -5;
goto bail;
}
}
req_flags = GSS_C_MUTUAL_FLAG | GSS_C_REPLAY_FLAG | GSS_C_DELEG_FLAG;
// However, GSS_C_SEQUENCE_FLAG should only be passed in for TCP-based clients, not for UDP-based clients.
if (TNET_SOCKET_TYPE_IS_STREAM(self->socket.type)) {
req_flags |= GSS_C_SEQUENCE_FLAG;
}
node->handshacking.gss.status_major = gss_delete_sec_context(&node->handshacking.gss.status_minor, &node->handshacking.gss.ctx, NULL);
node->handshacking.gss.ctx = GSS_C_NO_CONTEXT;
node->handshacking.gss.status_major = gss_init_sec_context(&node->handshacking.gss.status_minor,
GSS_C_NO_CREDENTIAL, // GSS_C_NO_CREDENTIAL into cred_handle to specify the default credential (for initiator usage)
&node->handshacking.gss.ctx,
node->handshacking.gss.server_name,
GSS_C_NULL_OID, // GSS_C_NULL_OID into mech_type to specify the default mechanism
req_flags,
GSS_C_INDEFINITE,
GSS_C_NO_CHANNEL_BINDINGS,
input_token_ptr,
tsk_null,
&output_token,
tsk_null,
tsk_null);
// Only "GSS_S_COMPLETE" and "GSS_S_CONTINUE_NEEDED" are acceptable
if (node->handshacking.gss.status_major != GSS_S_COMPLETE && node->handshacking.gss.status_major != GSS_S_CONTINUE_NEEDED) {
__socks_gss_print_error("gss_init_sec_context failed", node->handshacking.gss.status_major, node->handshacking.gss.status_minor);
ret = -2;
goto bail;
}
// reset pending handshaking data
TSK_FREE(node->handshacking.pending_data_ptr);
node->handshacking.pending_data_len = 0;
if (output_token.length > 0 && output_token.value) {
node->handshacking.pending_data_len = kTokenMsgHdrLongLen + output_token.length;
node->handshacking.pending_data_ptr = tsk_realloc(node->handshacking.pending_data_ptr, node->handshacking.pending_data_len);
if (!node->handshacking.pending_data_ptr) {
TSK_DEBUG_ERROR("Failed to allocate buffer with size = %u", (unsigned)node->handshacking.pending_data_len);
node->handshacking.pending_data_len = 0;
ret = -3;
goto bail;
}
node->handshacking.pending_data_ptr[0] = 0x01;
node->handshacking.pending_data_ptr[1] = kSocks5AuthMethodGSSAPI;
node->handshacking.pending_data_ptr[2] = ((output_token.length >> 8) & 0xFF);
node->handshacking.pending_data_ptr[3] = output_token.length & 0xFF;
memcpy(&node->handshacking.pending_data_ptr[4], output_token.value, output_token.length);
}
if (input_token.length > 0) {
tsk_buffer_remove(node->handshacking.buff, 0, kTokenMsgHdrLongLen + input_token.length);
}
// update "init_sec_complete"
node->handshacking.gss.init_sec_complete = (ret == 0) && (node->handshacking.gss.status_major == GSS_S_COMPLETE);
bail:
return ret;
}
static void __socks_gss_print_error(const char* info, OM_uint32 status_major, OM_uint32 status_minor)
{
OM_uint32 m1, m2, s1, s2;
gss_buffer_desc out1 = {.value = tsk_null, .length = 0}, out2 = {.value = tsk_null, .length = 0};
// print the error
m1 = 0, s1 = 0;
gss_display_status(&s1, status_major, GSS_C_GSS_CODE, GSS_C_NULL_OID, &m1, &out1);
m2 = 0, s2 = 0;
gss_display_status(&s2, status_minor, GSS_C_MECH_CODE, GSS_C_NULL_OID, &m2, &out2);
TSK_DEBUG_ERROR("%s (status_major=%u, status_minor=%u): GSS_C_GSS_CODE(%u, %s), GSS_C_MECH_CODE(%u, %s)",
info,
status_major, status_minor,
s1, (const char*)out1.value, s2, (const char*)out2.value);
gss_release_buffer(&s1, &out1);
gss_release_buffer(&s2, &out2);
}
#endif /* TNET_SOCKS5_HAVE_AUTH_GSSAPI */
/* constructor */
static tsk_object_t* tnet_proxy_node_socks_plugin_ctor(tsk_object_t * self, va_list * app)
{
tnet_proxy_node_socks_plugin_t *node = self;
if (node) {
/* init base */
tnet_proxy_node_init(TNET_PROXY_NODE(node));
/* init self */
tsk_safeobj_init(node);
#if TNET_SOCKS5_HAVE_AUTH_GSSAPI
node->handshacking.gss.server_name = GSS_C_NO_NAME;
node->handshacking.gss.ctx = GSS_C_NO_CONTEXT;
#endif
TSK_DEBUG_INFO("Create SOCKS(4/4a/5) proxy node");
}
return self;
}
/* destructor */
static tsk_object_t* tnet_proxy_node_socks_plugin_dtor(tsk_object_t * self)
{
tnet_proxy_node_socks_plugin_t *node = self;
if (node) {
/* deinit base */
tnet_proxy_node_deinit(TNET_PROXY_NODE(node));
/* deinit self */
TSK_FREE(node->handshacking.pending_data_ptr);
TSK_OBJECT_SAFE_FREE(node->handshacking.buff);
#if TNET_SOCKS5_HAVE_AUTH_GSSAPI
gss_release_name(&node->handshacking.gss.status_minor, &node->handshacking.gss.server_name);
if (node->handshacking.gss.ctx != GSS_C_NO_CONTEXT) {
gss_delete_sec_context(&node->handshacking.gss.status_minor, &node->handshacking.gss.ctx, GSS_C_NO_BUFFER);
}
#endif /* TNET_SOCKS5_HAVE_AUTH_GSSAPI */
tsk_safeobj_deinit(node);
TSK_DEBUG_INFO("*** Socks(4/4a/5) proxy node destroyed ***");
}
return self;
}
/* object definition */
static const tsk_object_def_t thttp_proxy_node_def_s = {
sizeof(tnet_proxy_node_socks_plugin_t),
tnet_proxy_node_socks_plugin_ctor,
tnet_proxy_node_socks_plugin_dtor,
tsk_null,
};
/* plugin definition*/
static const struct tnet_proxy_node_plugin_def_s tnet_proxy_node_socks_plugin_def_s = {
&thttp_proxy_node_def_s,
(tnet_proxy_type_socks4 | tnet_proxy_type_socks4a | tnet_proxy_type_socks5),
"SOCKS(4/4a/5) proxy node plugin",
_tnet_proxy_node_socks_plugin_configure,
_tnet_proxy_node_socks_plugin_start_handshaking,
_tnet_proxy_node_socks_plugin_set_handshaking_data,
_tnet_proxy_node_socks_plugin_get_handshaking_pending_data,
_tnet_proxy_node_socks_plugin_get_handshaking_completed
};
const struct tnet_proxy_node_plugin_def_s *tnet_proxy_node_socks_plugin_def_t = &tnet_proxy_node_socks_plugin_def_s;
Reference in New Issue View Git Blame Copy Permalink