#include "main.h" #include "Tlhelp32.h" unsigned long lastRecv=0; //Scottgl's constants unsigned char InjectKeyCode[] = { 0x89, 0x55, 0x10, 0x8B, 0x55, 0x08, 0x89, 0x55, 0x08, 0x46, 0x81, 0xE6, 0xFF, 0x00, 0x00, 0x00 }; unsigned char InjectPassCode[] = { 0x8B, 0xEC, 0x81, 0xEC, 0xA0, 0x00, 0x00, 0x00, 0x53, 0x56, 0x8B, 0xD9, 0x57, 0x6A, 0x10 }; unsigned char InjectSendCode[] = { 0x8B, 0xDC, 0x8D, 0x87, 0xA4, 0x02, 0x00, 0x00, 0x53, 0x50, 0x56, 0x8D, 0x8F, 0x9C, 0x01, 0x00, 0x00 }; unsigned char InjectRecvCode[] = { 0x8B, 0xC4, 0x8D, 0x8E, 0x94, 0x00, 0x00, 0x00, 0x50, 0x53, 0x57, 0x89, 0x45, 0x08 }; //My crap GWMEMS memAddrs; int GetNextPacket(DATA *da, int filter, GWMEMS *gw, HANDLE gwHand); int Crypto(char *source, char *dest, char *key, int length); int Crypto2(char *source, char *dest, char *key, int length); HANDLE GuildWars=0; BOOL PauseResumeThreadList(DWORD dwOwnerPID, bool bResumeThread) { HANDLE hThreadSnap = NULL; BOOL bRet = FALSE; THREADENTRY32 te32 = {0}; // Take a snapshot of all threads currently in the system. hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0); if (hThreadSnap == INVALID_HANDLE_VALUE) return (FALSE); // Fill in the size of the structure before using it. te32.dwSize = sizeof(THREADENTRY32); // Walk the thread snapshot to find all threads of the process. // If the thread belongs to the process, add its information // to the display list. if (Thread32First(hThreadSnap, &te32)) { do { if (te32.th32OwnerProcessID == dwOwnerPID) { HANDLE hThread = OpenThread(THREAD_SUSPEND_RESUME, FALSE, te32.th32ThreadID); if (bResumeThread) { //cout << _T("Resuming Thread 0x") << cout.setf( ios_base::hex ) << te32.th32ThreadID << '\n'; ResumeThread(hThread); } else { //cout << _T("Suspending Thread 0x") << cout.setf( ios_base::hex ) << te32.th32ThreadID << '\n'; SuspendThread(hThread); } CloseHandle(hThread); } } while (Thread32Next(hThreadSnap, &te32)); bRet = TRUE; } else bRet = FALSE; // could not walk the list of threads // Do not forget to clean up the snapshot object. CloseHandle (hThreadSnap); return (bRet); } unsigned long FindCodeCave(unsigned long start, HANDLE gwHand) { start=0x00800000; //Create the new buffer to search for long length=3000; unsigned char *codecaveMem=new unsigned char[length]; memset(codecaveMem,0,length); unsigned char *buffer=new unsigned char[length]; //Find the codecave SIZE_T bytesread; while(ReadProcessMemory(gwHand,(void*)start,buffer,length,&bytesread)) { if(!memcmp(codecaveMem,buffer,bytesread) && bytesread==length) { delete [] buffer; delete [] codecaveMem; return start; } else { //Skip ahead to the next string of zeroes bool found=false; for(int i=0; idataSize]; memcpy(temp,s->data,s->dataSize); d->data=temp; return true; } bool FindMemoryLocations(GWMEMS *gw, HANDLE gwHand) { //I mutilated scottgl's code below here xD ~ Theora SIZE_T bytesread = 0; long start=0x00400000; long end=0x00600000; unsigned long size = end-start; unsigned char *data = new unsigned char[size]; //Read in memory we want to scan if (!ReadProcessMemory(gwHand,(void*)start,data,size,&bytesread)) { delete [] data; MessageBox(NULL,"Could not pinpoint memory addresses","Fatal Error",MB_OK | MB_ICONSTOP); return false; } //Scan for the locations for (unsigned long i = 0; i < size; i++) { //KEY INJECTION location if (!memcmp(&data[i],InjectKeyCode,sizeof(InjectKeyCode))) { gw->injectKeyAddr=i+start; } //PASSWORD INJECTION location else if (!memcmp(&data[i],InjectPassCode,sizeof(InjectPassCode))) { gw->injectPassAddr=i+start; } //SEND FLAG INJECTION else if (!memcmp(&data[i],InjectSendCode,sizeof(InjectSendCode))) { gw->injectSendFlagAddr=i+start; } //RECV FLAG INJECTION else if (!memcmp(&data[i],InjectRecvCode,sizeof(InjectRecvCode))) { gw->injectRecvFlagAddr=i+start; } } delete [] data; gw->codeCave=FindCodeCave(start,gwHand); //Make sure we have a memory location for each if(gw->codeCave==0 || gw->injectKeyAddr==0 || gw->injectPassAddr==0 || gw->injectRecvFlagAddr==0 || gw->injectSendFlagAddr==0) { MessageBox(NULL,"Could not pinpoint memory addresses","Fatal Error",MB_OK | MB_ICONSTOP); return false; } //DEBUG: output the memory addresses char notice[500]; sprintf(notice,"CodeCave: 0x%X \n InjectKey: 0x%X \n InjectPass: 0x%X \n InjectRecv: 0x%X \n InjectSend: 0x%X",gw->codeCave,gw->injectKeyAddr,gw->injectPassAddr,gw->injectRecvFlagAddr,gw->injectSendFlagAddr); //MessageBox(NULL,notice,"Memory Addresses",MB_OK);//*/ } int InjectPacketDump(int filter, int (*dumpProcessing)(DATA *d)) { //Attempt to find Guild Wars while(MACRO_IFNOGW) { Sleep(10); } HWND gwWindow=FindWindowEx(NULL, NULL, "ArenaNet_Dx_Window_Class", NULL); if(gwWindow==NULL) { gwWindow=FindWindowEx(NULL, NULL, "ArenaNet_Dialog_Class", NULL); } //Open GW so we can inject our code DWORD gwPid; GetWindowThreadProcessId(gwWindow, &gwPid); HANDLE gwHand; if ((gwHand = OpenProcess(PROCESS_ALL_ACCESS,FALSE,gwPid)) == NULL) { MessageBox(NULL,"Failed to open GW.","Fatal Error",MB_OK | MB_ICONSTOP); return -9999; } GuildWars=gwHand; //Pause Guild Wars PauseResumeThreadList(gwPid,false); FindMemoryLocations(&memAddrs,gwHand); UpdateASM(&memAddrs); //We should now have the memory locations DWORD oldWrite; //write out packet dump function into memory if(!InjectCode(gwHand,memAddrs.codeCave,SIZE_FUNCTION_PCKDUMP,ASMFunctionPckDump)) return -9999; //write the send flag function into memory if(!InjectCode(gwHand,memAddrs.codeCave+SEND_FLAG_CODE_OFFSET,SIZE_FUNCTION_SENDFLAG,ASMFunctionSendFlag)) return -9999; //write the send flag function into memory if(!InjectCode(gwHand,memAddrs.codeCave+RECV_FLAG_CODE_OFFSET,SIZE_FUNCTION_RECVFLAG,ASMFunctionRecvFlag)) return -9999; //write out the packet dump function call into memory if(!InjectCodeRestore(gwHand,memAddrs.injectKeyAddr,SIZE_FUNCCALL_ASM,ASMFunctionCall)) return -9999; //write out the send flag function call into memory if(!InjectCodeRestore(gwHand,memAddrs.injectSendFlagAddr,SIZE_FUNCCALL_SENDFLAG,ASMFunctionCallSendFlag)) return -9999; //write out the recv flag function call into memory if(!InjectCodeRestore(gwHand,memAddrs.injectRecvFlagAddr,SIZE_FUNCCALL_RECVFLAG,ASMFunctionCallRecvFlag)) return -9999; //Done writing the code into GW PauseResumeThreadList(gwPid,true); //////////////////////// ///////////////////////// //////////////////////// //check the flag to see if there is data waiting to be processed int fileCounter=0; while(true) { DATA dd; dd.data=NULL; if(GetNextPacket(&dd,filter, &memAddrs, gwHand)==-1) { return -99999; } if(lastRecv!=0 && dd.encrypted){dd.timeSinceLastPck=TimerGetTime()-lastRecv;} else{dd.timeSinceLastPck=0;} if(dd.encrypted){lastRecv=TimerGetTime();} //Call the processing function int ret=0; if((ret=(*dumpProcessing)(&dd))<0) { if(dd.data!=NULL) { delete [] dd.data; dd.data=NULL; } return ret; } if(dd.data!=NULL) { delete [] dd.data; dd.data=NULL; } } return true; } int GetNextPacket(DATA *da, int filter, GWMEMS *gw, HANDLE gwHand) { char t=0; while(t!=1 && t!=5) { Sleep(10); if(ReadProcessMemory(gwHand, (void*)(gw->codeCave+PCKD_DATA_AVAILABLE), &t, 1, NULL)==0) { CloseHandle(gwHand); return -1; } //there is data waiting to be processed if(t==1) { long keyAddr=0; long dataAddr=0; long dataSize=0; char encrypted=0; unsigned char *oldData=0; //fill in the above values //read in the key address if(ReadProcessMemory(gwHand, (void*)(gw->codeCave+PCKD_KEY_ADDR), &keyAddr, 4, NULL)==0) { CloseHandle(gwHand); return -1; } //read in the data address if(ReadProcessMemory(gwHand, (void*)(gw->codeCave+PCKD_DATA_ADDR), &dataAddr, 4, NULL)==0) { CloseHandle(gwHand); return -1; } //read in the data size if(ReadProcessMemory(gwHand, (void*)(gw->codeCave+PCKD_DATA_SIZE), &dataSize, 4, NULL)==0) { CloseHandle(gwHand); return -1; } //read in the encrypted flag if(ReadProcessMemory(gwHand, (void*)(gw->codeCave+DATA_OFFSET), &encrypted, 1, NULL)==0) { CloseHandle(gwHand); return -1; } //read in the data from the addresses provided unsigned char *data=new unsigned char[dataSize]; //read in the data if(ReadProcessMemory(gwHand, (LPCVOID)(((void*)dataAddr)), data, dataSize, NULL)==0) { CloseHandle(gwHand); return -1; } if(true) { char key[264]; //read in the key if(ReadProcessMemory(gwHand, (LPCVOID)((void*)(keyAddr)), key, 264, NULL)==0) { CloseHandle(gwHand); return -1; } memcpy(da->key,key,264); } //if this packet is encrypted(i.e. it came from the server) the grab the key and decrypt it if(encrypted==1) { char key[264]; //read in the key if(ReadProcessMemory(gwHand, (LPCVOID)((void*)(keyAddr)), key, 264, NULL)==0) { CloseHandle(gwHand); return -1; } memcpy(da->key,key,264); //decrypt the data using the key unsigned char *ddata=new unsigned char[dataSize]; Crypto((char*)data,(char*)ddata,key,dataSize); oldData=data; data=ddata; ddata=0; } bool savePacket=true; t=0; if(!WriteProcessMemory(gwHand,(void*)(gw->codeCave+PCKD_DATA_AVAILABLE),&t,1,0)) { CloseHandle(gwHand); return -1; } if(filter==REPORT_CLIENT && encrypted==0 && savePacket) { delete [] data; if(oldData!=0){delete [] oldData;} t=5; } else if(filter==IGNORE_CLIENT && encrypted==0) { delete [] data; if(oldData!=0){delete [] oldData;} } else if(filter==IGNORE_SERVER && encrypted==1) { delete [] data; if(oldData!=0){delete [] oldData;} } else if(!savePacket) { delete [] data; if(oldData!=0){delete [] oldData;} } else { da->data=data; da->dataSize=dataSize; da->encrypted=encrypted; t=1; } } } //Hash the data and store the hash if(t==1) { return 0; } else { return (int)t; } } int Crypto(char *source, char *dest, char *key, int length) { //start decrypting unsigned int offset1=key[0];//esi unsigned int offset2=key[4];//edi unsigned int dl; for(int i=0; i