Problema del paquete IP de C++
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
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
}