SHARE
TWEET

Untitled

a guest Aug 13th, 2017 51 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. // My MINIsocks v 0.01 coded by Gar|k 2010
  2.  
  3. #pragma comment(linker,"/ENTRY:New_Main")
  4. #pragma comment(linker, "/MERGE:.data=.text")
  5. #pragma comment(linker, "/MERGE:.rdata=.text")
  6. #pragma comment(linker, "/SECTION:.text,EWR")
  7. #ifndef _DEBUG
  8. #pragma comment(linker,"/SUBSYSTEM:windows")
  9. #endif
  10.  
  11. #include <winsock2.h> // Wincosk2.h äîëćĺí áűňü đŕíüřĺ windows!
  12. #pragma comment(lib, "ws2_32.lib")
  13. #include <windows.h>
  14. #ifdef _DEBUG
  15. #include <stdio.h>
  16. #endif
  17.  
  18. #include "serv.h"
  19.  
  20. extern "C" void __cdecl _chkstk() {
  21.     __asm {
  22.         push ebp
  23.             sub eax, 4
  24.             xchg [esp+4], ebp
  25.             sub esp, eax
  26.             xchg [esp], ebp
  27.             mov ebp, esp
  28.             add ebp, eax
  29.             mov ebp, [ebp]
  30.     }
  31. }
  32.  
  33. // ńîçäŕíčĺ tcp ńĺđâĺđŕ
  34. SOCKET tcp_server(USHORT port,int max_client)
  35. {
  36.     SOCKET sock=INVALID_SOCKET;
  37.     struct sockaddr_in addr;
  38.  
  39.     sock = socket(AF_INET, SOCK_STREAM, 0);
  40.     if(sock!=INVALID_SOCKET)
  41.     {
  42. #ifdef _DEBUG
  43.         printf("[+] Open socket\n");
  44. #endif
  45.         addr.sin_family = AF_INET;
  46.         addr.sin_port = HTONS(port); // íĺ çŕáűâŕĺě î ńĺňĺâîě ďîđ˙äęĺ!!!
  47.         addr.sin_addr.s_addr = 0; // ńĺđâĺđ ďđčíčěŕĺň ďîäęëţ÷ĺíč˙ íŕ âńĺ ńâîč IP ŕäđĺńŕ
  48.  
  49.         if (!(bind(sock, (struct sockaddr *)&addr, sizeof(addr))))
  50.         {
  51. #ifdef _DEBUG
  52.             printf("[+] Bind %d port\n",port);
  53. #endif
  54.             if (listen(sock, max_client))
  55.             {
  56.                 closesocket(sock);
  57.                 sock=INVALID_SOCKET;
  58.             }
  59.  
  60. #ifdef _DEBUG
  61.             if(sock!=INVALID_SOCKET){
  62.                 printf("[+] Listen...\n",port);}
  63. #endif
  64.         }
  65.         else{
  66.             closesocket(sock);
  67.             sock=INVALID_SOCKET;
  68.         }
  69.     }
  70.     return sock;
  71. }
  72.  
  73. #define SEND 0
  74. #define RECV 1
  75. int tcp_rs(char type,SOCKET s, char *buf, int len, int flags) {
  76.     int total = 0;
  77.     int n;
  78.     if(type==SEND) {
  79.         tcp_func=(int (__stdcall *)(SOCKET,char *,int,int))&send; } else
  80.         {
  81.             tcp_func=(int (__stdcall *)(SOCKET,char *,int,int))&recv;
  82.         }
  83.         while(total < len) {
  84.             n = tcp_func(s, buf+total, len-total, flags);
  85.  
  86.             if(n>0) { total += n; }
  87.             else if(n == 0) {
  88.                 //Reconnect(opt);
  89.                 closesocket(s);
  90.                 return 0;
  91.             }
  92.             else {
  93.  
  94.                 n=WSAGetLastError();
  95.                 closesocket(s);
  96.                 return (!n+1);
  97.  
  98.                 // 10054 Connection reset by peer
  99.             }
  100.         }
  101.  
  102.         return total;
  103. }
  104.  
  105. ULONG Host2Ip(char * host)
  106. {
  107.     struct hostent * p;
  108.     ULONG ret;
  109.     if (inet_addr(host) != INADDR_NONE) { ret = inet_addr(host); return ret; }
  110.  
  111.     p = gethostbyname(host);
  112.     if (p) { ret = *(ULONG*)(p->h_addr); }
  113.     else { ret = INADDR_NONE; }
  114.     return ret;
  115. }
  116.  
  117.  
  118.  
  119. int socks5_server(SOCKET client){
  120.     struct _S5_METHOD_REQ s5m_req;
  121.     struct _S5_METHOD_RESP s5m_resp={0x05,0xFF};
  122.     struct _S5_REQ s5_req;
  123.     int k=0,len=0;
  124.     char buf[4096];
  125.     struct fd_set fds_read;
  126.     struct timeval tv={0,0};
  127.  
  128.     ULONG ip;
  129.     USHORT port;
  130.     struct sockaddr_in dst_addr;
  131.     SOCKET dst_socket;
  132.  
  133.     // ďîäęëţ÷ĺíčĺ ęëčĺíňŕ
  134.     RtlZeroMemory(&s5m_req,sizeof(S5_METHOD_REQ));
  135.     if(tcp_rs(RECV,client,(char *)&s5m_req,2,0)!=2) return -1;
  136.     if(tcp_rs(RECV,client,(char *)&s5m_req.methods,s5m_req.nmethods,0)!=s5m_req.nmethods) return -1;
  137.     //s5m_resp.method=0xFF;
  138.     for(k=0;k<s5m_req.nmethods;k++) {
  139.         if(s5m_req.methods[k]==0x00 || s5m_req.methods[k]==0x02)
  140.         { s5m_resp.method=s5m_req.methods[k]; break; }
  141.     } // âńĺ ěĺňîä âűáđŕí
  142.  
  143.     if(tcp_rs(SEND,client,(char *)&s5m_resp,2,0)!=2) return -1; // řëĺě îňâĺň
  144.  
  145.     // ňĺďĺđü ďîëó÷ŕĺě ęîěěŕíäó
  146.     RtlZeroMemory(&s5_req,sizeof(S5_REQ));
  147.     if(tcp_rs(RECV,client,(char *)&s5_req,4,0)!=4) return -1;
  148.     if(s5_req.atype==3)
  149.     {
  150.         if(tcp_rs(RECV,client,(char *)&s5_req.ADDR_TYPE.ADDR_HOST.nlen,1,0)!=1) return -1;
  151.         if(tcp_rs(RECV,client,s5_req.ADDR_TYPE.ADDR_HOST.host,s5_req.ADDR_TYPE.ADDR_HOST.nlen,0)!=s5_req.ADDR_TYPE.ADDR_HOST.nlen) return -1;
  152.         if(tcp_rs(RECV,client,(char *)&port,2,0)!=2) return -1;
  153.         k=5+s5_req.ADDR_TYPE.ADDR_HOST.nlen+2;
  154.         ip=Host2Ip(s5_req.ADDR_TYPE.ADDR_HOST.host);
  155.         if(ip==INADDR_NONE)
  156.         {
  157.             // îřčáęŕ SOCKS5_REPLY_HOST_UNACCESSIBLE
  158.             //printf("[-]ERR 4\n");
  159.             s5_req.command=SOCKS5_REPLY_HOST_UNACCESSIBLE;
  160.             tcp_rs(SEND,client,(char *)&s5_req,k,0);
  161.             closesocket(client);
  162.             return SOCKS5_REPLY_HOST_UNACCESSIBLE;
  163.  
  164.         }
  165.     }
  166.     // ďîëó÷čëč ňĺďĺđü ńěîňđě ęîěŕíäó
  167.     if(s5_req.command==1) // connect
  168.     {
  169.         dst_socket=socket(AF_INET, SOCK_STREAM, 0);
  170.         dst_addr.sin_family=AF_INET;
  171.         dst_addr.sin_addr.S_un.S_addr=ip;
  172.         dst_addr.sin_port=port;
  173.         if (connect(dst_socket, (struct sockaddr *)&dst_addr, sizeof(dst_addr)))
  174.         {
  175.             closesocket(dst_socket);
  176.             s5_req.command=SOCKS5_REPLY_ERROR_CONNECT;
  177.             tcp_rs(SEND,client,(char *)&s5_req,k,0);
  178.             closesocket(client);
  179.             return SOCKS5_REPLY_ERROR_CONNECT;
  180.         }
  181.         // ďîäęëţ÷čëčńü
  182.         s5_req.command=SOCKS5_REPLY_OK;
  183.         if(tcp_rs(SEND,client,(char *)&s5_req,k,0)!=k) return -1;
  184.         //sendall(client,(char *)&port,2,0);
  185.  
  186.         // ňĺďĺđü íŕäî îáěĺí ěĺćäó ęëčĺíňîě č ńĺđâĺđîě îđăŕíčçîâŕňü
  187.         while(1)
  188.         {
  189.             fds_read.fd_count=2;
  190.             fds_read.fd_array[0] = client;
  191.             fds_read.fd_array[1] = dst_socket;
  192.  
  193.             // çŕďđîńčě číôó î ńîńňî˙íčč
  194.             k = select(0, &fds_read, 0, 0, &tv);
  195.             if (k > 0) // ĺńëč ÷ňîňî čçěĺíčëîńü
  196.             {
  197.                 if (__WSAFDIsSet(client, &fds_read)) // ĺńëč ďĺđâűé ńîęĺň î÷óőŕëń˙
  198.                 {
  199.                     len=recv(client,buf,4096,MSG_PEEK);
  200.                     if(!len) break;
  201.                     else {
  202.                         if(tcp_rs(RECV,client,buf,len,0)>0) {
  203.  
  204.                             if(tcp_rs(SEND,dst_socket,buf,len,0)<=0) break;
  205.  
  206.                         } else break; }
  207.                 }
  208.                 if (__WSAFDIsSet(dst_socket, &fds_read)) // ĺńëč ďĺđâűé ńîęĺň î÷óőŕëń˙
  209.                 {
  210.                     len=recv(dst_socket,buf,4096,MSG_PEEK);
  211.                     if(!len) break;
  212.                     else { if(tcp_rs(RECV,dst_socket,buf,len,0)>0) {
  213.  
  214.                         if(tcp_rs(SEND,client,buf,len,0)<=0) break;
  215.  
  216.                     } else break; }
  217.                 }
  218.             }
  219.         Sleep(50); // íĺ îňíčěŕĺě ó ďđîöŕ đĺńóđńű
  220.         }
  221.     }
  222.  
  223.     return 0;
  224. }
  225.  
  226. int wtoi(wchar_t *str)
  227. {
  228.     int i, n;
  229.     char s[10];
  230.     CharToOemW(str,s);
  231.  
  232.     for(i=0, n=0; s[i]>='0' && s[i]<='9'; i++) n = n*10 + (s[i] - '0');
  233.     return n;
  234. }
  235.  
  236. void New_Main()
  237. {
  238.     SOCKET server_socket;
  239.     SOCKET client_socket; // ńîęĺň äë˙ ęëčĺíňŕ
  240.     struct sockaddr_in client_addr; // ŕäđĺń ęëčĺíňŕ (çŕďîëí˙ĺňń˙ ńčńňĺěîé)
  241.     int client_addr_size = sizeof(client_addr);
  242.     static struct tcp_keepalive alive={1,5*60*1000,10000}; // ŕâňîďčíă ÷ĺđĺç 5 ěčíóň ń číňĺđâŕëîě â 10 ńĺę
  243.  
  244.     WSADATA ws;
  245.     LPWSTR *argv; int argc;
  246.  
  247.     argv = CommandLineToArgvW(GetCommandLineW(), &argc);
  248.     if(argc!=2) goto ex;
  249.     WSAStartup(0x202, &ws);
  250.     RtlZeroMemory = (void (__stdcall *)(void *dst, int count))GetProcAddress(GetModuleHandle("KERNEL32.DLL"), "RtlZeroMemory");
  251.  
  252.     if((server_socket=tcp_server(wtoi(argv[1]),1))!=INVALID_SOCKET) {
  253.         while ((client_socket = accept(server_socket, (struct sockaddr *)&client_addr, &client_addr_size)))
  254.         {
  255.             if((WSAIoctl(client_socket, SIO_KEEPALIVE_VALS, &alive, sizeof(alive),NULL, 0, (LPDWORD)&ws, NULL, NULL))!= SOCKET_ERROR) {
  256.                 socks5_server(client_socket); }
  257.             client_socket=INVALID_SOCKET;
  258.         }
  259.     }
  260.     WSACleanup();
  261. ex:
  262.     ExitProcess(0);
  263. }
RAW Paste Data
Top