Socks5 proxy maker

#define WIN32_LEAN_AND_MEAN
#include <winsock2.h>
#include <stdio.h>
#include <stdlib.h>

#define NO_AUTH		0x00
#define GSSAPI		0x01
#define UN_PW		0x02
#define IANA_B		0x03
#define IANA_E		0x7F
#define PRIV_B	    0x80
#define PRIV_E		0xFE
#define NO_USABLE	0xFF


#define SUCCESS		0x00
#define FAILURE		0x01
#define RULESET		0x02
#define N_URA		0x03
#define H_URA		0x04
#define REFUSED		0x05
#define TTL_R		0x06
#define N_SUP		0x07
#define AN_SUP		0x08


#define CONNECT		0x01
#define BIND		0x02
#define UDP			0x03


#define IP4			0x01
#define DOMAIN		0x03
#define IP6			0x04

#define BUFF_SIZE 1024

typedef struct _TCPINIT {
	BYTE ver;
	BYTE nmethods;
	BYTE *methods;
} TCPINIT;

typedef struct _TCPCLIENT {
	SOCKET sock;

	HANDLE hOut;

	char user[35];
	char pass[35];
} TCPCLIENT;

typedef struct _UNPWAUTH {
	BYTE ver;

	BYTE ulen;
	char *cname;

	BYTE plen;
	char *pword;
} UNPWAUTH;

typedef struct _TCPREQUEST {
	BYTE ver;
	BYTE cmd;
	BYTE reserved;
	BYTE atype;
	long addr;
	short port;
} TCPREQUEST;

typedef struct _SOCKS5 {
	char cID[35];
	char cPass[35];
	USHORT uPort;

	SOCKET sock;
	char cUser[34];
	sockaddr_in *remote;
} SOCKS5;

unsigned long __stdcall fTcpServerThread(void *pInfo);

#define sendv(s,data,len) send(s,(char *)data,len,0)
#ifdef DBG
int output(HANDLE hOut,char *szFormat,...) {
	char cBuff[5*1024];

	char *args;
	va_start(args,szFormat);
	vsprintf(cBuff,szFormat,args);
	va_end(args);

	DWORD dwWritten;
	WriteFile(hOut,cBuff,strlen(cBuff)+1,&dwWritten,0);

	return dwWritten;
}


char *host(DWORD dwIP) {
	in_addr a;
	a.S_un.S_addr = dwIP;

	return inet_ntoa(a);
}

unsigned long resolve(char *szHost) {
	unsigned long ulRet = inet_addr(szHost);
	if (ulRet != INADDR_NONE)
		return ulRet;
	PHOSTENT h = gethostbyname(szHost);
	return *(long int *)h->h_addr_list[0];
}

#endif

int transmit(SOCKET s1,SOCKET s2,HANDLE hOut) {
	char *cBuff = new char[BUFF_SIZE];

	fd_set fd;
	int iRecvLen;

	while (1) {
		FD_ZERO(&fd);

		FD_SET(s1,&fd);
		FD_SET(s2,&fd);

		select(0,&fd,0,0,0);

		if (FD_ISSET(s1,&fd)) {
			iRecvLen = recv(s1,cBuff,BUFF_SIZE,0);
			if (iRecvLen < 1)
				break;
			output(hOut,"<%d>%s",s1,cBuff);
			if (send(s2,cBuff,iRecvLen,0) < 1)
				break;
		}

		if (FD_ISSET(s2,&fd)) {
			iRecvLen = recv(s2,cBuff,BUFF_SIZE,0);
			if (iRecvLen < 1)
				break;
				output(hOut,"<%d>%s",s2,cBuff);
			if (send(s1,cBuff,iRecvLen,0) < 1)
				break;
		}
	}

	output(hOut,"connection closed\r\n");
	shutdown(s1,SD_BOTH);
	return shutdown(s2,SD_BOTH);
}

int SocksUDP(SOCKET cSock,sockaddr_in *inaddr,HANDLE hOut,TCPREQUEST *req)
{
	output(hOut,"UDP associate request\r\n");

	sockaddr_in laddr;
	int iSize = sizeof(laddr);
	getsockname(cSock,(sockaddr *)&laddr,&iSize);

	sockaddr_in raddr = (*(sockaddr_in *)inaddr);

	SOCKET usock = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);

	char *cBuff = new char[BUFF_SIZE];

	int iRecv;
	while (1)
	{
		iSize = sizeof(raddr);
		iRecv = recvfrom(usock,cBuff,BUFF_SIZE,0,(sockaddr *)&raddr,&iSize);

		sendto(usock,cBuff,iRecv,0,(sockaddr *)&laddr,sizeof(laddr));

		if (iRecv < 1)
			break;

		iSize = sizeof(laddr);


		iRecv = recvfrom(usock,cBuff,BUFF_SIZE,0,(sockaddr *)&laddr,&iSize);
		if (iRecv < 1)
			break;
		sendto(usock,cBuff,iRecv,0,(sockaddr *)&raddr,sizeof(raddr));
	}

	output(hOut,"connection closed\r\n");
	shutdown(usock,SD_BOTH);
	return closesocket(usock);
}

int SocksBind(SOCKET cSock,sockaddr_in *inaddr,HANDLE hOut,TCPREQUEST *req) {

	output(hOut,"bind request\r\n");
	SOCKET ssock = WSASocket(AF_INET,SOCK_STREAM,IPPROTO_TCP,0,0,0);
	SOCKET clsock;

	sockaddr_in sbind = (*(sockaddr_in *)inaddr);

	if (bind(ssock,(sockaddr *)&sbind,sizeof(sbind))) {
		req->cmd = FAILURE;
		sendv(cSock,req,sizeof(TCPREQUEST));
		return closesocket(cSock);
	}
	if (listen(ssock,1)) {
		req->cmd = FAILURE;
		sendv(cSock,req,sizeof(TCPREQUEST));
		return closesocket(cSock);
	}

	clsock = accept(ssock,0,0);
	req->cmd = SUCCESS;
	sendv(cSock,req,sizeof(TCPREQUEST));
	transmit(clsock,cSock,hOut);
	return 0;
}

int SocksConnect(SOCKET cSock,sockaddr_in *inaddr,HANDLE hOut,TCPREQUEST *req) {
	SOCKET rsock = WSASocket(AF_INET,SOCK_STREAM,IPPROTO_TCP,0,0,0);

	if (connect(rsock,(sockaddr *)inaddr,sizeof(SOCKADDR_IN))) {
#ifdef DBG
		output(hOut,"<%d> error connecting to %s:%d\r\n",cSock,host(req->addr),ntohs(req->port));
#endif
		req->cmd = H_URA;
		sendv(cSock,req,sizeof(TCPREQUEST));
		return closesocket(cSock);
	}

	sockaddr_in bindaddr;
	int iSize = sizeof(bindaddr);
	getpeername(rsock,(sockaddr *)&bindaddr,&iSize);

	req->addr = bindaddr.sin_addr.S_un.S_addr;
	req->port = bindaddr.sin_port;

	req->cmd = SUCCESS;
	int iLen = sendv(cSock,req,sizeof(TCPREQUEST));
	if (iLen < 1) {
		closesocket(cSock);
		return closesocket(rsock);
	}

	output(hOut,"iLen = %d\r\nsizeof(req) = %d\r\n",iLen,sizeof(TCPREQUEST));
#ifdef DBG
	output(hOut,"<%d> connected to %s:%d\r\nstarting transmit...\r\n",cSock,host(req->addr),ntohs(req->port));
#endif
	transmit(cSock,rsock,hOut);
#ifdef DBG
	CloseHandle(hOut);
#endif
	closesocket(rsock);
	return closesocket(cSock);
}

unsigned long __stdcall fTcpClientThread(void *pInfo) {
	TCPCLIENT client = (*(TCPCLIENT *)pInfo);

	SOCKET sock = client.sock;
	HANDLE hOut = client.hOut;

	char szUser[35];
	strcpy(szUser,client.user);

	char szPass[35];
	strcpy(szPass,client.pass);

	TCPINIT init;

	if (recv(sock,(char *)&init,2,0) < 1)
		return closesocket(sock);

	init.methods = new BYTE[init.nmethods];
	recv(sock,(char *)init.methods,init.nmethods,0);
	output(hOut,"<%d> recieved tcp init packet (%d,%d,%x)\r\n",sock,init.ver,init.nmethods,init.methods[init.nmethods]);

	output(hOut,"<%d> checking version...\r\n",sock);
	if (init.ver != 5) {
		output(hOut,"not v5, closing\r\n",sock);
		return closesocket(sock);
	}

	output(hOut,"<%d> checking 0x02 (USER/PASS) auth...\r\n",sock);
	bool bHasAuth = false;
	for (int i = 0;i < init.nmethods;i++) {
		if ((init.methods[i] == UN_PW)) {
			bHasAuth = true;
			break;
		}
	}
	if (!bHasAuth) {
		output(hOut,"<%d> no usable auth found, exiting\r\n",sock);
		init.nmethods = NO_USABLE;
		sendv(sock,&init,2);
		return closesocket(sock);
	}

	init.nmethods = UN_PW;
	sendv(sock,&init,2);

	UNPWAUTH auth;

	output(hOut,"<%d> recieving authentication...\r\n",sock);
	recv(sock,(char *)&auth,sizeof(auth.ver)+sizeof(auth.ulen),0);

	if (auth.ver != 0x01) {
		output(hOut,"<%d> auth.ver != 0x01,closing socket\r\n",sock);
		auth.ulen = NO_USABLE;
		sendv(sock,&auth,2);
		return closesocket(sock);
	}
	output(hOut,"username len = %d, allocating\r\n",auth.ulen);
	auth.cname = new char[auth.ulen+1];
	auth.cname[auth.ulen] = 0;
	recv(sock,auth.cname,auth.ulen,0);

	recv(sock,(char *)&auth.plen,sizeof(auth.plen),0);
	output(hOut,"password len = %d, allocating\r\n",auth.plen);

	auth.pword = new char[auth.plen+1];
	auth.pword[auth.plen] = 0;
	recv(sock,auth.pword,auth.plen,0);

	output(hOut,"<%d> user authed (%s,%s)\r\n",sock,auth.cname,auth.pword);
	output(hOut,"<%d> add auth check later...\r\n",sock);

	if ((!cmp(auth.cname,szUser)) || (!cmp(auth.pword,szPass)))
	{
		auth.ulen = FAILURE;
		sendv(sock,&auth,2);
		closesocket(sock);
		return 0;
	}

	auth.ulen = SUCCESS;
	sendv(sock,&auth,2);

	delete auth.cname;
	delete auth.pword;

	TCPREQUEST req;

	output(hOut,"<%d> recieving TCPREQUEST\r\n",sock);

	recv(sock,(char *)&req,4,0);

	if (req.ver != 0x05) {
		output(hOut,"<%d> ver != 0x05\r\n",sock);
		closesocket(sock);
	}

	if ((req.atype != IP4) && (req.atype != DOMAIN)) {
		output(hOut,"<%d> req.atype != 0x01 or 0x03\r\n",sock);
		req.cmd = AN_SUP;
		sendv(sock,&req,sizeof(req));
		closesocket(sock);
	}

	sockaddr_in local;

	if (req.atype == IP4) {
		output(hOut,"atype = IPv4\r\n");
		recv(sock,(char *)&req+4,6,0);
		local.sin_addr.S_un.S_addr = req.addr;
	} else
	if (req.atype == DOMAIN) {
		output(hOut,"atype = domain\r\n");
		char cDomainSize = 0;
		recv(sock,&cDomainSize,sizeof(cDomainSize),0);
		char *szDomain = new char[cDomainSize+1];

		szDomain[cDomainSize] = 0;
		recv(sock,szDomain,cDomainSize,0);

		output(hOut,"domain = %s\r\n",szDomain);

		recv(sock,(char *)&req.port,sizeof(req.port),0);
		PHOSTENT h = gethostbyname(szDomain);
		if (!h)
			return closesocket(sock);
		local.sin_addr.S_un.S_addr = (*(unsigned long *)h->h_addr_list[0]);
#ifdef DBG
		output(hOut,"resolved to %s\r\n",host(local.sin_addr.S_un.S_addr));
#endif
		req.atype = IP4;
		req.addr = local.sin_addr.S_un.S_addr;

		h = 0;

		delete szDomain;
	}
	local.sin_family = 2;
	local.sin_port = req.port;

	switch (req.cmd) {
	case CONNECT:
		SocksConnect(sock,&local,hOut,&req);
		break;
	case BIND:
		SocksBind(sock,&local,hOut,&req);
		break;
	case UDP:
		SocksUDP(sock,&local,hOut,&req);
		break;
	}
}

unsigned long __stdcall fTcpServerThread(void *pInfo) {
	SOCKS5 set = (*(SOCKS5 *)pInfo);

	HANDLE hOut = 0;

	output(hOut,"server thread started\r\n");

	SOCKET ssock = WSASocket(2,1,6,0,0,0);
	sockaddr_in local;

	local.sin_addr.S_un.S_addr = INADDR_ANY;
	local.sin_family = 2;
	local.sin_port = set.uPort;

	if (bind(ssock,(sockaddr *)&local,sizeof(local)))
	{
#ifdef DBG
		return output(hOut,"error on bind (%d)\r\n",WSAGetLastError());
#else
		return 0;
#endif
	}

	if (listen(ssock,10))
	{
#ifdef DBG
		return output(hOut,"error on listen (%d)\r\n",WSAGetLastError());
#else
		return 0;
#endif
	}

	TCPCLIENT client;
#ifdef DBG
	client.hOut = hOut;
#endif

	DWORD dwThreadID;

	int iLen = sizeof(sockaddr_in);
	getsockname(ssock,(sockaddr *)&local,&iLen);
	*set.remote = local;
#ifdef DBG
	TCPREQUEST tcp;
	output(hOut,"server listening on port %d\r\n",ntohs(local.sin_port));
	output(hOut,"sizeof's: \r\n"
      "TPCINIT:%d\r\n"
      "TCPCLINET:%d\r\n"
      "UNPWAUTH:%d\r\n"
      "TCPREQUEST:%d\r\ntest: %d\r\n\r\n",sizeof(TCPINIT),sizeof(TCPCLIENT),sizeof(UNPWAUTH),sizeof(TCPREQUEST),(sizeof(BYTE)*4)+sizeof(DWORD)+sizeof(WORD));
	output(hOut,"TCPCLIENT:%d\r\n%d\r\n%d\r\n%d\r\n%d\r\n%d\r\n",sizeof(tcp.ver),sizeof(tcp.cmd),sizeof(tcp.reserved),sizeof(tcp.atype),sizeof(tcp.addr),sizeof(tcp.port));
#endif

	int iSize = strlen(set.cID)+1;
	char *szUser = new char[iSize];
	strcpy(szUser,set.cID);

	iSize = strlen(set.cPass)+1;
	char *szPass = new char[iSize];
	strcpy(szPass,set.cPass);

	zerod(&client,sizeof(client));

	strcpy(client.user,szUser);
	strcpy(client.pass,szPass);
	while (1) {
		client.sock = accept(ssock,0,0);
		if (client.sock == INVALID_SOCKET)
			break;
		CreateThread(0,0,fTcpClientThread,(void *)&client,0,&dwThreadID);
		output(hOut,"\r\ntcp client connected\r\n");
	}

	output(hOut,"closing server socket\r\n");
	return closesocket(ssock);
}