[Tips]Linux平台socks5代理

by 云舒
2008-1-25
http://www.ph4nt0m.org


前几天MSN老上不去，我还以为是公司做了防火墙限制。于是把去年这个时候写得一个代理程序改了改，拿出来用。结果发现MSN是因为微软的问题，鄙视啊……
因为写得比较急，这个只支持TCP代理，UDP的我没写，因为MSN用不上。这个代码可以随意修改分发，不过最好能给我一份。

这是头文件：

///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Socks5代理头文件，定义协议相关数据包结构
// 版本 0.1，作者 云舒
// 2007年1月9日凌晨1点15分，GF回家已经11天了。
// 2008年1月25日修改，今年GF一直在我身边，哈哈
//
// 参考：
//              http://www.rfc-editor.org/rfc/rfc1928.txt
//              http://www.rfc-editor.org/rfc/rfc1929.txt
///////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef SOCKS5_H
#define SOCKS5_H

#define VERSION    0x05
#define CONNECT    0x01
#define IPV4        0x01
#define DOMAIN    0x03
#define IPV6        0x04

typedef struct _method_select_response    // 协商方法服务器响应
{
    char    version;    // 服务器支持的Socks版本，0x04或者0x05
    char    select_method;// 服务器选择的方法，0x00为匿名，0x02为密码认证
} METHOD_SELECT_RESPONSE;

typedef struct _method_select_request    // 协商方法服务端请求
{
    char      version;    // 客户端支持的版本，0x04或者0x05
    char    number_methods;    // 客户端支持的方法的数量
    char    methods[255]; // 客户端支持的方法类型，最多255个，0x00为匿名，0x02为密码认证
} METHOD_SELECT_REQUEST;

typedef struct _AUTH_RESPONSE // 用户密码认证服务端响应
{
    char    version;// 版本，此处恒定为0x01
    char    result;// 服务端认证结果，0x00为成功，其他均为失败
} AUTH_RESPONSE;

typedef struct _AUTH_REQUEST //用户密码认证客户端请求
{
    char    version; // 版本，此处恒定为0x01
    char        name_len;     // 第三个字段用户名的长度，一个字节，最长为0xff
    char        name[255]; // 用户名
    char        pwd_len;// 第四个字段密码的长度，一个字节，最长为0xff
    char        pwd[255];    // 密码
} AUTH_REQUEST;

typedef struct _SOCKS5_RESPONSE // 连接真实主机，Socks代理服务器响应
{
    char        version; // 服务器支持的Socks版本，0x04或者0x05
    char        reply; // 代理服务器连接真实主机的结果，0x00成功
    char        reserved;    // 保留位，恒定位0x00
    char        address_type; // Socks代理服务器绑定的地址类型，IP V4为0x01,IP V6为0x04，域名为0x03                
    char        address_port[1];    // 如果address_type为域名，此处第一字节为域名长度，其后为域名本身，无0字符结尾,域名后为Socks代理服务器绑定端口
}SOCKS5_RESPONSE;                    

typedef struct _SOCKS5_REQUEST    // 客户端请求连接真实主机
{
    char    version; // 客户端支持的Socks版本，0x04或者0x05
    char        cmd; // 客户端命令，CONNECT为0x01，BIND为0x02，UDP为0x03，一般为0x01
    char        reserved;    // 保留位，恒定位0x00
    char        address_type; // 客户端请求的真实主机的地址类型，IP V4为0x00,IP V6为0x04，域名为 0x03                                                char        address_port[1];    // 如果address_type为域名，此处第一字节为域名长度，其后为域名本身，无0字符结尾,域名后为真实主机绑定端口

}SOCKS5_REQUEST;                    
#endif 

主程序来了：

///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Socks5程序，只支持TCP代理
// 版本 0.1，作者 云舒
// 2007年1月9日凌晨1点15分，GF回家已经11天了。
// 2008年1月25日修改，今年GF一直在我身边，哈哈
//
// 参考：
//              http://www.rfc-editor.org/rfc/rfc1928.txt
//              http://www.rfc-editor.org/rfc/rfc1929.txt
//编译：
//        gcc -o socks5 -O2 Socks5.c -lpthread( RedHat AS5测试 ）
///////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <stdio.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <pthread.h>
#include <errno.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>

#include "Socks5.h"

#define MAX_USER        10
#define BUFF_SIZE       1024

#define AUTH_CODE       0x02

#define TIME_OUT        6000000

#define USER_NAME       "yunshu"
#define PASS_WORD       "ph4nt0m"

// Select auth method, return 0 if success, -1 if failed
int     SelectMethod( int sock )
{
    char    recv_buffer[BUFF_SIZE] = { 0 };
    char    reply_buffer[2] = { 0 };

    METHOD_SELECT_REQUEST    *method_request;
    METHOD_SELECT_RESPONSE    *method_response;
    
    // recv METHOD_SELECT_REQUEST
    int ret = recv( sock, recv_buffer, BUFF_SIZE, 0 );
    if( ret <= 0 )
    {
        perror( "recv error" );
        close( sock );

        return -1;
    }

    //printf( "SelectMethod: recv %d bytes\n", ret );

    // if client request a wrong version or a wrong number_method
    method_request = (METHOD_SELECT_REQUEST *)recv_buffer;
    method_response = (METHOD_SELECT_RESPONSE *)reply_buffer;

    method_response->version = VERSION;
    
    // if not socks5
    if( (int)method_request->version != VERSION )
    {
        method_response->select_method = 0xff;

        send( sock, method_response, sizeof(METHOD_SELECT_RESPONSE), 0 );
        close( sock );
    
        return -1;
    }

    method_response->select_method = AUTH_CODE;
    if( -1 == send( sock, method_response, sizeof(METHOD_SELECT_RESPONSE), 0 ) )
    {
        close( sock );
        return -1;
    }
        
    return 0;
}

// test password, return 0 for success.
int     AuthPassword( int sock )
{
    char    recv_buffer[BUFF_SIZE] = { 0 };
    char    reply_buffer[BUFF_SIZE] = { 0 };

    AUTH_REQUEST    *auth_request;
    AUTH_RESPONSE    *auth_response;
    
    // auth username and password
    int ret = recv( sock, recv_buffer, BUFF_SIZE, 0 );
    if( ret <= 0 )
    {
        perror( "recv username and password error" );
        close( sock );
        return -1;
    }
    //printf( "AuthPass: recv %d bytes\n", ret );

    auth_request = (AUTH_REQUEST *)recv_buffer;

    memset( reply_buffer, 0, BUFF_SIZE );
    auth_response = (AUTH_RESPONSE *)reply_buffer;
    auth_response->version = 0x01;

    char    recv_name[256] = { 0 };
    char    recv_pass[256] = { 0 };

    // auth_request->name_len is a char, max number is 0xff
    char pwd_str[2] = { 0 };
    strncpy( pwd_str, auth_request->name + auth_request->name_len, 1 );
    int pwd_len = (int)pwd_str[0];

    strncpy( recv_name, auth_request->name, auth_request->name_len );
    strncpy( recv_pass, auth_request->name + auth_request->name_len + sizeof(auth_request->pwd_len), pwd_len );

    //printf( "username: %s\npassword: %s\n", recv_name, recv_pass );
    // check username and password
    if( (strncmp( recv_name, USER_NAME, strlen(USER_NAME) ) == 0) &&
            (strncmp( recv_pass, PASS_WORD, strlen(PASS_WORD) ) == 0)
        )
    {
        auth_response->result = 0x00;
        if( -1 == send( sock, auth_response, sizeof(AUTH_RESPONSE), 0 ) )
        {
            close( sock );
            return -1;
        }
        else
        {
            return 0;
        }
    }
    else
    {
        auth_response->result = 0x01;
        send( sock, auth_response, sizeof(AUTH_RESPONSE), 0 );

        close( sock );
        return -1;
    }
}

// parse command, and try to connect real server.
// return socket for success, -1 for failed.
int    ParseCommand( int sock )
{
    char    recv_buffer[BUFF_SIZE] = { 0 };
    char    reply_buffer[BUFF_SIZE] = { 0 };
    
    SOCKS5_REQUEST    *socks5_request;
    SOCKS5_RESPONSE    *socks5_response;

    // recv command
    int ret = recv( sock, recv_buffer, BUFF_SIZE, 0 );
    if( ret <= 0 )
    {
        perror( "recv connect command error" );

        close( sock );
        return -1;
    }
    
    socks5_request = (SOCKS5_REQUEST *)recv_buffer;
    if( (socks5_request->version != VERSION) || (socks5_request->cmd != CONNECT) ||
        (socks5_request->address_type == IPV6) )
    {
        //printf( "connect command error.\n" );
        close( sock );
        return -1;
    }

    // begain process connect request
    struct sockaddr_in    sin;

    memset( (void *)&sin, 0, sizeof(struct sockaddr_in) );
    sin.sin_family = AF_INET;

    // get real server's ip address
    if( socks5_request->address_type == IPV4 )
    {
        memcpy( &sin.sin_addr.s_addr, &socks5_request->address_type + sizeof(socks5_request->address_type) , 4 );
        memcpy( &sin.sin_port, &socks5_request->address_type + sizeof(socks5_request->address_type) + 4, 2 );

        //printf( "Real Server: %s %d\n", inet_ntoa( sin.sin_addr ), ntohs( sin.sin_port ) );
    }
    else if( socks5_request->address_type == DOMAIN )
    {
        char domain_length = *(&socks5_request->address_type + sizeof(socks5_request->address_type));
        char target_domain[ 256] = { 0 };

        strncpy( target_domain, &socks5_request->address_type + 2, (unsigned int)domain_length );

        //printf( "target: %s\n", target_domain );

        struct hostent *phost = gethostbyname( target_domain );
        if( phost == NULL )
        {
            //printf( "Resolve %s error!\n" , target_domain );

            close( sock );
            return -1;
        }
        memcpy( &sin.sin_addr , phost->h_addr_list[0] , phost->h_length );

        memcpy( &sin.sin_port, &socks5_request->address_type + sizeof(socks5_request->address_type) +
                sizeof(domain_length) + domain_length, 2 );
    }

    // try to connect to real server
    int     real_server_sock = socket( AF_INET, SOCK_STREAM, 0 );
    if( real_server_sock < 0 )
    {
        perror( "Socket creation failed\n");
            
        close( sock );
        return -1;
    }

    memset( reply_buffer, 0, sizeof(BUFF_SIZE) );

    socks5_response = (SOCKS5_RESPONSE *)reply_buffer;

    socks5_response->version = VERSION;
    socks5_response->reserved = 0x00;
    socks5_response->address_type = 0x01;
    memset( socks5_response + 4, 0 , 6 );

    ret = connect( real_server_sock, (struct sockaddr *)&sin, sizeof(struct sockaddr_in) );
    if( ret == 0 )
    {
        socks5_response->reply = 0x00;
        if( -1 == send( sock, socks5_response, 10, 0 ) )
        {
            close( sock );
            
            return -1;
        }
    }
    else
    {
        perror( "Connect to real server error" );
        socks5_response->reply = 0x01;
        send( sock, socks5_response, 10, 0 );
        
        close( sock );
        return -1;
    }
    
    return real_server_sock;
}

int    ForwardData( int sock, int real_server_sock )
{
    char    recv_buffer[BUFF_SIZE] = { 0 };
    
    fd_set    fd_read;
    struct  timeval time_out;

    time_out.tv_sec = 0;
    time_out.tv_usec = TIME_OUT;
    
    int ret = 0;
    
    while( 1 )
    {
        FD_ZERO( &fd_read );
        FD_SET( sock, &fd_read );
        FD_SET( real_server_sock, &fd_read );

        ret = select( (sock > real_server_sock ? sock : real_server_sock) + 1, &fd_read, NULL, NULL, &time_out );
        if( -1 == ret )
        {
            perror( "select socket error" );
            break;
        }
        else if( 0 == ret )
        {
            //perror( "select time out" );
            continue;
        }
        
        //printf( "[DEBUG] testing readable!\n" );
        if( FD_ISSET(sock, &fd_read) )
        {
            //printf( "client can read!\n" );
            memset( recv_buffer, 0, BUFF_SIZE );
            ret = recv( sock, recv_buffer, BUFF_SIZE, 0 );
            if( ret > 0 )
            {
                //printf( "%s", recv_buffer );
                //printf( "recv %d bytes from client.\n", ret );
                ret = send( real_server_sock, recv_buffer, ret, 0 );
                if( ret == -1 )
                {
                    perror( "send data to real server error" );
                    break;
                }
                //printf( "send %d bytes to client!\n", ret );
            }
            else if( ret == 0 )
            {
                //printf( "client close socket.\n" );
                break;
            }
            else
            {
                //perror( "recv from client error" );
                break;
            }
        }
        
        else if( FD_ISSET(real_server_sock, &fd_read) )
        {
            //printf( "real server can read!\n" );
            memset( recv_buffer, 0, BUFF_SIZE );
            ret = recv( real_server_sock, recv_buffer, BUFF_SIZE, 0 );
            if( ret > 0 )
            {
                //printf( "%s", recv_buffer );
                //printf( "recv %d bytes from real server.\n", ret );
                ret = send( sock, recv_buffer, ret, 0 );
                if( ret == -1 )
                {
                    perror( "send data to client error" );
                    break;
                }
            }
            else if( ret == 0 )
            {
                //printf( "real server close socket.\n" );
                break;
            }
            else
            {
                perror( "recv from real server error" );
                break;
            }
        }
    }
    
    return 0;
}

int    Socks5( void *client_sock )
{
    int     sock = *(int *)client_sock;

    if( SelectMethod( sock ) == -1 )
    {
        //printf( "socks version error\n" );
        return -1;
    }
    
    if( AuthPassword( sock ) == -1 )
    {
        //printf( "auth password error\n" );
        return -1;
    }
    
    int real_server_sock = ParseCommand( sock );
    if( real_server_sock == -1 )
    {
        //printf( "parse command error.\n" );
        return -1;
    }
    
    ForwardData( sock, real_server_sock );

    close( sock );
    close( real_server_sock );
    
    return 0;
}

int     main( int argc, char *argv[] )
{
    if( argc != 2 )
    {
        printf( "Socks5 proxy for test,code by YunShu\n" );
        printf( "Usage: %s   <proxy_port>\n", argv[0] );
        printf( "Options:\n" );
        printf( "        <proxy_port>     ---which  port of this proxy server will listen.\n" );
                
        return 1;
    }

    struct sockaddr_in      sin;

    memset( (void *)&sin, 0, sizeof( struct sockaddr_in) );
    sin.sin_family = AF_INET;
    sin.sin_port = htons( atoi(argv[1]) );
    sin.sin_addr.s_addr = htonl(INADDR_ANY);

    int     listen_sock = socket( AF_INET, SOCK_STREAM, 0 );
    if( listen_sock < 0 )
    {
        perror( "Socket creation failed\n");
        return -1;
    }

    int opt = SO_REUSEADDR;
    setsockopt( listen_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt) );

    if( bind( listen_sock, (struct sockaddr*)&sin, sizeof(struct sockaddr_in) ) < 0 )
    {
        perror( "Bind error" );
        return -1;
    }

    if( listen( listen_sock, MAX_USER ) < 0 )
    {
        perror( "Listen error" );
        return -1;
    }

    struct  sockaddr_in     cin;
    int       client_sock;
    int       client_len = sizeof( struct sockaddr_in );

    while( client_sock = accept( listen_sock, (struct sockaddr *)&cin, (socklen_t *)&client_len ) )
    {
        printf( "Connected from %s, processing\n", inet_ntoa( cin.sin_addr ) );

        pthread_t       work_thread;
        if( pthread_create( &work_thread, NULL, (void *)Socks5, (void *)&client_sock ) )
        {
            perror( "Create thread error" );
            close( client_sock );
        }
        else
        {
            pthread_detach( work_thread );
        }
    }
} 

[News]幻影新气象，2008新的祝福

Dear,all

大家新年好，先补上2008迟到的祝福，感谢大家一直以来对幻影的支持！

在新的一年里，幻影也将陆陆续续的开展一些新的业务。

-------------------- 这是新年祝福的分割线-------------------------------------

首先是blog将持续一贯以来路线，争取发好文，新文，紧密跟踪安全趋势和动态。

其次就是邮件列表亦是重要发展的一项业务。目前邮件列表的注册用户已经超过了1000，并且每天都在持续增长中。

希望邮件列表能够在2008年成为一个大的安全社区，让这个社区成为中国安全界的中坚力量之一。

邮件列表目前启用了新的域名： http://bbs.ph4nt0m.org 也更方便大家记忆

接下来要报告大家的是，幻影已经恢复了新的首页，虽然很简单。

大家可以直接用域名： www.ph4nt0m.org 来访问我们的新首页。

在新首页中可以直接订阅邮件列表

我们的各项业务也在首页中有所体现

由于新首页使用的是google的服务，所以必须要求能够访问google，才能访问新首页。

---------------------------- 这是自豪的分割线 ------------------------------

在2008年，我们新开展了PLANET业务

PLANET是一个rss的聚合，以前kkqq曾经做过，但是他的planet后来由于种种原因夭折了。

幻影决定做一个PLANET，并且开展下去

大家可以通过域名： http://planet.ph4nt0m.org

来访问planet

目前planet里聚合了一些中国安全界的知名人士的blog。他们的blog有什么及时的更新，都会通过rss被planet抓取到。

如果planet里没有收集你的blog，你也可以在planet中提交。

我们希望在以后的planet升级版本里，制作一个英文版的planet，用以聚合国外知名人士的blog，让大家了解最新的安全动态和研究方向。

欢迎大家订阅我们的planet！

----------------------------- 这是充满希望的分割线 --------------------------

另外一项新的业务就是，webzine。

幻影决定办webzine，就是网络杂志。 我们将制作一个完全免费的非商业性的杂志，关注于安全的所有方面。

文章以高、精、新为主。一年四期左右，也是为了保证质量。

Webzine面向所有人征稿。 更具体的细节可以访问： http://webzine.ph4nt0m.org

Phrack是我们心目中不灭的圣火，我们不奢望能像phrack一样影响深远，但phrack是我们前进的方向，我们希望webzine能好好

发展，照亮安全界的一方水土。

-------------------- 这是客户第一的分割线 -----------------------

除了以上说的，我们还利用google自定义搜索服务，定制了针对安全界的搜索。

这项业务我暂时定名为：Ph4nt0m Security World Search Engine

大家可以通过 http://search.ph4nt0m.org 来进行访问，在首页上也可以直接搜索该服务

这个搜索是针对安全技术的，精简了搜索范围，就是说你在这里搜索的都是安全网站里的内容，不会有乱七八糟的网站搜索结果进来干扰你。

希望这项业务能够给大家带来最好的搜索体验。

我们也欢迎大家加入一起来扩大搜索范围。

---------------------- 这是合作的分割线 ------------------------

最后，我们还不定期的有些Projects, 目前正在进行中的Project是superhei的XSSDB项目，似乎他已经完成了一个版本的开发，这个项目是

旨在建立一个XSS Payload的framework，让大家可以更加方便快捷的构造XSS Payload。

大家可以直接联系他获取更多的信息。

希望大家有什么好点子都可以和我们共享，一起开展一些新的projects！

---------------------------- 这是友好的分割线 ----------------------------

幻影虽然是一个team，但是我们不局限于一个team。

我们希望以这个team为接口，建立一个社区，开展多项服务，让大家都加入到这个大家庭中来。

你也是幻影中的一员！

Enjoy Yourself Here!

刺

2008-1-14