Red de conocimiento informático - Computadora portátil - Problema del paquete IP de C++

Problema del paquete IP de C++

Función API HOOK, las funciones enviar y enviar a en la función SOCKET, la primera es la función de envío del protocolo TCP y la segunda es la función de envío del protocolo UDP. Reemplace las direcciones de entrada de estas dos funciones con sus propias direcciones de entrada de funciones (como MySend, MySendTo), de modo que todos los mensajes que desee enviar no ingresen a la función original al llamar a Send o SendTo, pero ejecutarán sus funciones de reemplazo. como MiEnviar.

Basándose en este principio, VS Battle Platform y Fang Hao Battle Platform modificaron el paquete de protocolo IPX original en un paquete de protocolo TCP/UDP con función de envío HOOK y lo enviaron. Una vez que la otra parte recibe el paquete de datos, se restaura al paquete de datos del protocolo IPX y luego el juego lo procesa.

El siguiente código se transfiere desde Internet:

# include & ltWinsock2.h & gt

# include & ltstdio.h & gt

# pragma argsused

//Estructura APIHOOK personalizada

estructura typedef

{

FARPROC funcaddr

BYTE datos antiguos[5];

BYTE datos nuevos[5];

} HOOKSTRUCT

HHOOK g _ hHook

HINSTANCE g _ hinstDll

HMODULE hModule

Procesar g_hForm//Recibir identificador de ventana de información

DWORD dwIdOld, dwIdNew

// -

//Debido a que es necesario interceptar funciones en dos bibliotecas, se definen dos estructuras de enlace para cada función.

//Debido a que este problema no se consideró durante el proceso de programación, muchos paquetes de datos no fueron interceptados.

//Más tarde pensé que Brother Bing cortó cada función dos veces en el programa que imitaba a SOCKCAP para entenderlo.

//Uno es wsock32.dll, el otro es ws2_32.dll

// -

HOOKSTRUCT recvapi

hook struct rec vapi 1;

HOOKSTRUCT sendapi

gancho struct sendapi 1;

HOOKSTRUCT sendapi

gancho struct sendapi 1;

HOOKSTRUCT WSASendapi

enganche vacío activado();

enganche vacío desactivado();

Init booleano();

externo " C " _ _ declspec(exportación dll)_ stdcall

BOOL install hook();

extern " C " _ _ declspec(exportación dll)_ stdcall

BOOL uninstall hook();

BOOL hookapi(char *dllname, char *procname, DWORD myfuncaddr, hook struct * hook func);

int WINAPI Myrecv(SOCKET s, char FAR *buf, int len, int flags);

int WINAPI Myrecv1(SOCKET s, char FAR *buf, int len, int flags);

int WINAPI Mysend( SOCKET s, char FAR *buf, int len, int flags);

int WINAPI Mysend1 (SOCKET s, char FAR *buf, int len, int flags);

int WINAPI Mysendto); (SOCKET s, const char FAR * buf, int len,

int flags, const struct sockaddr FAR * to,

int WINAPI mysendto 1(SOCKET s, const); char FAR * buf, int len,

int flags, const struct sockaddr FAR * to, int tolen

int WINAPI MyWSASend(

socket s,

LPWSABUF lpBuffers,

DWORD dwBufferCount,

LPDWORD lpNumberOfBytesSent,

DWORD dwFlags,

LPWSAOVERLAPPED lpOverlapped,

lpwsaooverlapped _ COMPLETION _ ROUTINE lpCompletionRoutine

);

void snd msg(char * buf);

// -< / p>

//Función de entrada

//Realiza la interceptación de API tan pronto como se carga la biblioteca.

//Restaurar cuando se publique

// -

int WINAPI DllEntryPoint(hin instancia hinst, motivo largo sin firmar, void* lpReserved)

{

Cambiar (motivo)

{

Caso DLL_PROCESS_ATTACH:

g _ hinstDll = hinst

g_hForm = FindWindow(NULL, "ZwellL");

If (!Init())

{

MessageBoxA(NULL, "Init", " ERROR",MB_OK);

Devolución (Falso);

}

Interrupción;

Caso DLL_THREAD_ATTACH:

Break;

Caso DLL_THREAD_DETACH:

Break;

Caso DLL_PROCESS_DETACH:

desinstalar gancho();

Interrupción;

}

Devuelve VERDADERO

}

// -

BOOL Init ()

{

hookapi("wsock32.dll", "recv", (DWORD)Myrecv y amprecvapi);

hookapi("ws2_32. dll " , " recv ", (DWORD)Myrecv1, ​​​​&recvapi 1);

hookapi("wsock32.dll", "enviar", (DWORD)Mysend, &sendapi);

hookapi("ws2_32.dll", "enviar", (DWORD)Mysend1, &senda pi 1);

hookapi("wsock32.dll", "sendto", (DWORD)Mysendto,& ampsendtoapi);

hookapi("ws2_32.dll","sendto",(DWORD)Mysendto1,&sendtoapi 1);

hookapi("wsock32.dll","WSASend" , (DWORD) MyWSASend, & ampWSASendapi);

dwIdNew = GetCurrentProcessId() //Obtiene el ID del proceso al que pertenece.

dwIdOld = dwIdNew

HookOn(); //Iniciar interceptación

Retorno (verdadero);

}

// -

LRESULT WINAPI gancho(int nCode, WPARAM wParam, LPARAM lParam)

{

return(CallNextHookEx(g_hHook, nCode, wParam, lParam));

}

// -

extern " C " _ _ declspec(dll export)_ stdcall

BOOL InstallHook()

{

g _ hHook = SetWindowsHookEx(WH _ GETMESSAGE, (HOOKPROC)Hook, g_hinstDll,

if (!g_hHook)

{

MessageBoxA(NULL, "Configuración de error", "Error", MB_OK

Retorno (falso); }

Retorno (verdadero);

}

// -

extern " C " _ _ declspec(exportación dll)_ stdcall

BOOL UninstallHook()

{

descolgar();

if(g_hHook == NULL)

Devuelve verdadero

return(UnhookWindowsHookEx(g _ hHook));

}

// -

/ /Interceptar API basada en estructura de entrada

// -

BOOL hookapi(char *dllname, char *procname, DWORD myfuncaddr, HOOKSTRUCT *hookfunc)

{< / p>

hm odule = LoadLibrary(dllname);

func del gancho-& gt; addr func = GetProcAddress(hModule, procname);

if(func del gancho-& gt ;funcaddr == NULL)

Devuelve falso

memcpy(hook func-& gt;olddata, gancho func-& gt;funcaddr, 6);

función de gancho-& gt; nuevos datos[0]= 0xe 9;

DWORD jmp addr = myfuncaddr-(DWORD)func de gancho-& gt;func addr-5;

memcpy (& función de gancho->newdata[1],&jmpaddr,5);

Devuelve verdadero

}

// -

void gancho en uno (estructura de gancho * función de gancho)

{

Proceso hProc

dwIdOld = dwIdNew

hProc = abrir PROCESO( PROCESO _ TODO _ ACCESO, 0, dwIdOld);

VirtualProtectEx(hProc, función de gancho-> funcaddr, 5, PÁGINA

_ leer escribir & dwIdOld);

WriteProcessMemory(hProc, función de gancho-> funcaddr, función de gancho-> newdata, 5, 0);

VirtualProtectEx( hProc, gancho func-> funcaddr, 5, dwIdOld & dwIdOld);

}

// -

Gancho no válido()

p>

{

HookOnOne(& recvapi);

HookOnOne(& sendapi);

HookOnOne(& sendtoapi) ;

HookOnOne (& recvapi 1);

HookOnOne(& sendapi 1);

HookOnOne(& sendtoapi 1);

HookOnOne(& WSASendapi);

}

// -

anular el gancho de uno (estructura del gancho * función del gancho)

{

Proceso hProc

dwIdOld = dwIdNew

hProc = open PROCESS(PROCESS _ ALL _ ACCESS, 0, dwIdOld) ;

VirtualProtectEx(hProc,hook func->funcaddr ,5,PAGE_read write&dwIdOld);

WriteProcessMemory(hProc,hook func->funcaddr ,hook func->datos antiguos,5,0);

VirtualProtectEx(hProc ,func de gancho->funcaddr,5,dwIdOld &dwIdOld);

}

// -

Gancho no válido()

{

descolgar uno(& recvapi);

descolgar uno(& sendapi);

descolgar uno(& sendtoapi);

descolgar uno(& recvapi 1);

descolgar uno(& sendapi 1);

descolgar uno(& sendtoapi 1);

cuelgue uno(& WSASendapi);

}

// -

int WINAPI Myrecv(SOCKET s, char FAR *buf, int len, int flags)

{

int nReturn

colgar uno(& recvapi);

nReturn = recv(s, buf,len,flags);

HookOnOne(& recvapi);

char * tmpbuf = new char[len+100];

memset(tmpbuf, 0, tamaño de (tmpbuf ));

spri

ntf(tmpbuf, " recv|%d|%d|%s ",

GetCurrentProcessId(),

línea,

buf); >

snd msg(tmpbuf);

Eliminar tmpbuf

return(n return);

}

// -

int WINAPI Myrecv1(SOCKET s, char FAR *buf, int len, int flags)

{

int nReturn

hook off one(& recvapi 1);

nReturn = recv(s, buf, len, flags);

HookOnOne(& recvapi 1);

char * tmpbuf = new char[len+100];

memset(tmpbuf, 0, sizeof(tmpbuf));

sprintf(tmpbuf, " recv1|%d |%d| %s ",

GetCurrentProcessId(),

línea,

buf);

snd msg(tmpbuf);

Eliminar tmpbuf

return(n return);

}

// -

int WINAPI Mysend(SOCKET s , char FAR *buf, int len, int flags)

{

int nReturn

desconecta uno(& sendapi

nReturn = enviar(s, buf, len, flags);

HookOnOne(& sendapi>char * tmpbuf = new char[len +100];

memset(tmpbuf, 0, sizeof(tmpbuf));

sprintf(tmpbuf, " enviar|%d|%d|%s ",

GetCurrentProcessId(),

línea,

buf);

snd msg(tmpbuf);

Eliminar tmpbuf

return( n return);

}

// -

int WINAPI Mysend1(SOCKET s, char FAR *buf, int len, int flags)

{

int nReturn

desconecta uno(& senda pi 1);

nReturn = send(s,buf,len,flags) ;

HookOnOne(& senda pi 1);

char * tmpbuf = new char[len+100];

memset(tmpbuf, 0, sizeof( tmpbuf));

sprintf(tmpbuf, " send1|%d|%d|%s ",

GetCurrentProcessId() ,

Carril,

buf);

snd msg(tmpbuf);

Eliminar tmpbuf

return (n re

turn);

}

// -

int WINAPI Mysendto(SOCKET s, const char FAR * buf, int len,

int flags, const struct sockaddr FAR * to, int tolen)

{

int nReturn

desconecta uno(& sendtoapi);

p>

nReturn = sendto(s,buf,len,flags,to,tolen);

HookOnOne(& sendtoapi);

char * tmpbuf = nuevo char [len+100];

memset(tmpbuf, 0, sizeof(tmpbuf));

sprintf(tmpbuf, " sendto|%d|%d|%s ",

GetCurrentProcessId(),

línea,

buf);

snd msg(tmpbuf);

Eliminar tmpbuf

return(n return);

}

// -

int WINAPI mysendto 1(SOCKET s, const char FAR * buf, int len,

int flags, const struct sockaddr FAR * to, int tolen)

{

int nReturn

enganchar uno(& sendtoapi 1);

nReturn = sendto(s, buf, len, flags, to, tolen);

HookOnOne(& sendtoapi 1) ;

char * tmpbuf = new char[len+100];

memset(tmpbuf, 0, sizeof(tmpbuf));

sprintf(tmpbuf, " sendto1| %d|%d|%s ",

GetCurrentProcessId(),

línea,

buf);

snd msg( tmpbuf);

Eliminar tmpbuf

return(n return);

}

// -

int WINAPI MyWSASend(

sockets,

LPWSABUF lpBuffers,

DWORD dwBufferCount,

LPDWORD lpNumberOfBytesSent,

DWORD dwFlags,

LPWSAOVERLAPPED lpOverlapped,

lpwsaooverlapped _ COMPLETION _ ROUTINE lpCompletionRoutine

)

{

int nReturn

desconecta uno(& WSASendapi);

nReturn = WSASend(s, lpBuffers, dwBufferCount,

lpNumberOfBytesSent, dwFlags, lpOverlapped

, lpCompletionRoutine);

HookOnOne(& WSASendapi);

char * tmpbuf = new char[* lpNumberOfBytesSent+100];

memset(tmpbuf, 0, sizeof(tmpbuf));

sprintf(tmpbuf, " WSASend|%d|%d|%s ",

GetCurrentProcessId(),

lpNumberOfBytesSent,

búferes LP-& gt;buf);

snd msg(tmpbuf);

Eliminar tmpbuf

return(n return) ;

}

// -

//Enviar un mensaje a la ventana

//Considerando la simplicidad, utilice la estructura COPYDATASTRUCT.

//Debería ser más rápido usar el mapeo de memoria.

// -

void sndmsg(char *buf)

{

CD COPYDATASTRUCT

CD. dw datos = sizeof(COPYDATASTRUCT);

CD datos = strlen(buf);

CD datos = buf;

SendMessage(g_hForm, WM_COPYDATA, (WPARAM) NULL, (LPARAM) y CD

}