[C++]RemoteFunction

[Lindeth]

Ayyıldız2 | 2008 TR Yapısı • 1-99 Orta Emek Destan • Oto Avsız • 10 Temmuz 21:00 HEMEN TIKLA!

• Farklı bir işlemden Metin2 fonksiyonu çağırmak için kendi kodlamış olduğum class'dır. Bu class ile client'e herhangi bir dosya inject etmeden SendAttackPacket fonksiyonunu çağırabilirsiniz.
  
  Class WoM2 client'inde test edilmiştir. Dolayısıyla address, pointer ve offsetler WoM2 client'inden alınmıştır. Kod daha da geliştirilebilir ve tabi ki bu size bağlı.
  
  Remote.h
  

  /*
  * @file Remote.h
  * @author Lindeth/lindeth.net
  *
  * Classes, etc.
  */
  
  #ifndef __REMOTE_HEADER__
  #define __REMOTE_HEADER__
  
  class CMemory
  {
  public:
  void* Alloc(HANDLE hProcess, size_t Size);
  void* Commit(HANDLE hProcess, void* Data, size_t Size);
  void Free(HANDLE hProcess, void* Data, size_t Size);
  
  template <class Data>
  Data Read(HANDLE hProcess, DWORD dwAddress)
  {
  Data ReadVal;
  ReadProcessMemory(hProcess, (LPVOID)dwAddress, &ReadVal, sizeof(Data), NULL);
  return ReadVal;
  }
  };
  
  class CProcess {
  public:
  HANDLE GetRemoteProcessHandleA(const char *pszProcessName);
  HMODULE GetRemoteModuleHandleA(HANDLE hProcess, const char *szModule);
  };
  
  class Metin2 {
  public:
  DWORD GetTargetVID(HANDLE hProcess);
  void SendAttackPacket(HANDLE hProcess, DWORD dwVIDVictim);
  private:
  //Bu address, pointer ve offset'ler WoM2 client'inden alınmıştır. 24.09.2017
  DWORD CPythonPlayerPtr = 0x0160E238;
  DWORD TargetVIDOffset = 0x13E28;
  DWORD CPythonNetworkPtr = 0x016105C4;
  DWORD SendAttackPacketAddr = 0x006A3130;
  };
  
  extern CMemory Memory;
  extern CProcess Process;
  extern Metin2 M2;
  
  #endif //__REMOTE_HEADER__

  
  Remote.cpp
  

  /*
  * @file Remote.cpp
  * @author Lindeth/lindeth.net
  *
  * Classes, etc.
  */
  
  #include "Remote.h"
  #include <Windows.h>
  #include <TlHelp32.h>
  
  CMemory Memory;
  CProcess Process;
  Metin2 M2;
  
  void* CMemory::Alloc(HANDLE hProcess, size_t Size)
  {
  return VirtualAllocEx(hProcess, NULL, Size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
  }
  
  void* CMemory::Commit(HANDLE hProcess, void* Data, size_t Size)
  {
  void* AllocatedPointer = Alloc(hProcess, Size);
  
  if (AllocatedPointer)
  {
  if (WriteProcessMemory(hProcess, AllocatedPointer, Data, Size, NULL) == TRUE)
  {
  return AllocatedPointer;
  }
  
  Free(hProcess, AllocatedPointer, Size);
  }
  
  return NULL;
  }
  
  void CMemory::Free(HANDLE hProcess, void* Data, size_t Size)
  {
  VirtualFreeEx(hProcess, Data, Size, MEM_RELEASE);
  }
  
  HANDLE CProcess::GetRemoteProcessHandleA(const char *pszProcessName)
  {
  HANDLE tlh = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
  
  PROCESSENTRY32 proEntry;
  
  proEntry.dwSize = sizeof(PROCESSENTRY32);
  
  Process32First(tlh, &proEntry);
  do
  {
  if (_stricmp(pszProcessName, proEntry.szExeFile) == 0)
  {
  CloseHandle(tlh);
  
  return OpenProcess(PROCESS_ALL_ACCESS, FALSE, proEntry.th32ProcessID);
  }
  } while (Process32Next(tlh, &proEntry));
  
  CloseHandle(tlh);
  
  return INVALID_HANDLE_VALUE;
  }
  
  HMODULE CProcess::GetRemoteModuleHandleA(HANDLE hProcess, const char *szModule)
  {
  HANDLE tlh = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, GetProcessId(hProcess));
  
  MODULEENTRY32 modEntry;
  
  modEntry.dwSize = sizeof(MODULEENTRY32);
  
  Module32First(tlh, &modEntry);
  do
  {
  if (_stricmp(szModule, modEntry.szModule) == 0)
  {
  CloseHandle(tlh);
  
  return modEntry.hModule;
  }
  } while (Module32Next(tlh, &modEntry));
  
  CloseHandle(tlh);
  
  return NULL;
  }
  
  DWORD Metin2::GetTargetVID(HANDLE hProcess){
  DWORD CPythonPlayer = Memory.Read<DWORD>(hProcess, CPythonPlayerPtr);
  return Memory.Read<DWORD>(hProcess, CPythonPlayer+TargetVIDOffset);
  }
  
  void Metin2::SendAttackPacket(HANDLE hProcess, DWORD dwVIDVictim)
  {
  unsigned char SendAttackPacketThreadBuffer[21] =
  {
  0x8B, 0x0D, 0x00, 0x00, 0x00, 0x00, //mov ecx, classPtr
  0x68, 0x00, 0x00, 0x00, 0x00, //push dwVIDVictim
  0x6A, 0x00, //push 0
  0xB8, 0x00, 0x00, 0x00, 0x00, //mov eax, SendAttackPacketAddr
  0xFF, 0xD0, //call eax
  0xC3 //ret
  };
  
  *(DWORD*)(SendAttackPacketThreadBuffer + 0x02) = (DWORD)CPythonNetworkPtr;
  *(DWORD*)(SendAttackPacketThreadBuffer + 0x07) = (DWORD)(dwVIDVictim << 32); 
  *(DWORD*)(SendAttackPacketThreadBuffer + 0xE) = (DWORD)SendAttackPacketAddr;
  
  void* RemoteBufferToWrite = Memory.Commit(hProcess, SendAttackPacketThreadBuffer, sizeof(SendAttackPacketThreadBuffer));
  
  if (RemoteBufferToWrite)
  {
  HANDLE hSpawnedThread = CreateRemoteThread(hProcess, 0, 0, (LPTHREAD_START_ROUTINE)RemoteBufferToWrite, 0, 0, 0);
  
  WaitForSingleObject(hSpawnedThread, INFINITE);
  
  Memory.Free(hProcess, RemoteBufferToWrite, 0);
  }
  }

  
  Aşağıda gösterdiğim gibi kullanabilirsiniz.
  
  Main.cpp
  

  #include <Windows.h>
  #include "Remote.h"
  
  int main(int argc, const char * argv[]) {
  HANDLE hProcess = Process.GetRemoteProcessHandleA("metin2client.bin"); //handle al, eğer client dosyasının adı farklıysa uzantısıyla beraber metin2client.bin ile değiştirin
  
  while (true) {//sonsuz döngü başlat
  if (hProcess) {//handle alınabilmiş mi kontrol et
  DWORD TargetVID = M2.GetTargetVID(hProcess); //Hedef alınmış objenin sanal id'sini local değişkene aktar
  if (TargetVID != 0) {//değişkendeki sanal id'yi kontrol et
  M2.SendAttackPacket(hProcess, TargetVID);//saldırı fonksiyonunu çağır
  } 
  Sleep(500);//500 ms. bekle, her döngüde boş beklenen süre(millisecond bazında)
  }
  } 
  
  return 0;
  }

  
  Fikir için @Wieve2 'ye teşekkürler. Umarım birilerinin işine yarar ve sadece kullanmak yerine geliştirir. Son olarak konu ile ilgili sorularınızı cevaplamayacağım. Şimdiden belirteyim.
  
  İyi kodlamalar.

 

[Wieve2]

Gelişmek isteyen arkadaşlar için güzel kaynak olacaktır

 

[yekta2711]

teşekkürler kankacım beyni olanların işine yarıyacaktır

 

[Wieve2]

Yanılmamışım sürü gibisiniz
Yararlı konu +1

Yararlan knk sizin için açtık konuyu .d

 

[dreamfancy]

Sabit için uygun görüldü, teşekkürler @Lindeth;