0
c++ csgo wall hack

#define C_P

typedef unsigned char uint8_t;

template <typename T, size_t N>

size_t countof(T(&array)[N])

{

 return N;

}

DWORD (void)dwLocalPlayer; //will be scanned

DWORD (void)dwEntityList; //will be scanned

DWORD (void)dwGlow; //will be scanned

DWORD dwTeam = 0xF0;

DWORD dwDormant = 0xE9;

struct PModule

{

 DWORD dwBase;

 DWORD dwSize;

};

/* Debugger/Process API implementation class */

class process

{

public:

 bool Attach(char* pName, DWORD rights)

 {

  HANDLE handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);

  PROCESSENTRY32 entry;

  entry.dwSize = sizeof(entry);

  do

   if (!strcmp(entry.szExeFile, pName)) {

    pID = entry.th32ProcessID;

    CloseHandle(handle);

    _process = OpenProcess(rights, false, pID);

    return true;

   }

  while (Process32Next(handle, &entry));

  return false;

 }

 PModule GetModule(char* moduleName) {

  HANDLE module = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pID);

  MODULEENTRY32 mEntry;

  mEntry.dwSize = sizeof(mEntry);

  do {

   if (!strcmp(mEntry.szModule, (LPSTR)moduleName)) {

    CloseHandle(module);

    PModule mod = { (DWORD)mEntry.hModule, mEntry.modBaseSize };

    return mod;

   }

  } while (Module32Next(module, &mEntry));

  PModule mod = { (DWORD)false, (DWORD)false };

  return mod;

 }

 template <class T>

 T Read(DWORD addr) {

  T _read;

  ReadProcessMemory(_process, (LPVOID)addr, &_read, sizeof(T), NULL);

  return _read;

 }

 template <class T>

 void Write(DWORD addr, T val) {

  WriteProcessMemory(_process, (LPVOID)addr, &val, sizeof(T), NULL);

 }

 DWORD FindPattern(DWORD start, DWORD size, const char* sig, const char* mask) {

  BYTE* data = new BYTE[size];

  unsigned long bytesRead;

  if (!ReadProcessMemory(_process, (LPVOID)start, data, size, &bytesRead)) {

   return NULL;

  }

  for (DWORD i = 0; i < size; i++) {

   if (DataCompare((const BYTE*)(data + i), (const BYTE*)sig, mask)) {

    return start + i;

   }

  }

  return NULL;

 }

 DWORD FindPatternArray(DWORD start, DWORD size, const char* mask, int count, ...) {

  char* sig = new char[count + 1];

  va_list ap;

  va_start(ap, count);

  for (int i = 0; i < count; i++) {

   char read = va_arg(ap, char);

   sig[i] = read;

  }

  va_end(ap);

  sig[count] = '\0';

  return FindPattern(start, size, sig, mask);

 }

private:

 HANDLE _process;

 DWORD pID;

 bool DataCompare(const BYTE* pData, const BYTE* pMask, const char* pszMask) {

  for (; *pszMask; ++pszMask, ++pData, ++pMask) {

   if (*pszMask == 'x' && *pData != *pMask) {

    return false;

   }

  }

  return (*pszMask == NULL);

 }

};

/* Glow Object structure in csgo */

struct glow_t

{

 DWORD dwBase;

 float r;

 float g;

 float b;

 float a;

 uint8_t unk1[16];

 bool m_bRenderWhenOccluded;

 bool m_bRenderWhenUnoccluded;

 bool m_bFullBloom;

 uint8_t unk2[10];

};

/* Entity structure in csgo */

struct Entity

{

 DWORD dwBase;

 int team;

 bool is_dormant;

};

/* Player structure in csgo */

struct Player

{

 DWORD dwBase;

 bool isDormant;

};

#ifdef C_P

#error C_P

#endif

process memory;

process _modClient;

process* mem;

PModule modClient;

int int iFriendlies;

int int iEnemies;

Entity entEnemies[32];

Entity entFriendlies[32];

Entity me;

void update_entity_data(Entity* e, DWORD dwBase)

{

 int dormant = memory.Read<int>(dwBase + dwDormant);

 e->dwBase = dwBase;

 e->team = memory.Read<int>(dwBase + dwTeam);

 e->is_dormant = dormant == 1;

}

/* Get Pointer To Client.dll*/

PModule* GetClientModule() {

 if (modClient.dwBase == 0 && modClient.dwSize == 0) {

  modClient = memory.GetModule("client.dll");

 }

 return &modClient;

}

Entity* GetEntityByBase(DWORD dwBase) {

 for (int i = 0; i < iFriendlies; i++) {

  if (dwBase == entFriendlies[i].dwBase) {

   return &entFriendlies[i];

  }

 }

 for (int i = 0; i < iEnemies; i++) {

  if (dwBase == entEnemies[i].dwBase) {

   return &entEnemies[i];

  }

 }

 return nullptr;

}

/* offset updating class, that uses patterns to find memory addresses */

class offset

{

private:

 static void update_local_player() {

  DWORD lpStart = mem->FindPatternArray(modClient.dwBase, modClient.dwSize, "xxx????xx????xxxxx?", 19, 0x8D, 0x34, 0x85, 0x0, 0x0, 0x0, 0x0, 0x89, 0x15, 0x0, 0x0, 0x0, 0x0, 0x8B, 0x41, 0x8, 0x8B, 0x48, 0x0);

  DWORD lpP1 = mem->Read<DWORD>(lpStart + 3);

  BYTE lpP2 = mem->Read<BYTE>(lpStart + 18);

  dwLocalPlayer = (lpP1 + lpP2) - modClient.dwBase;

 }

 static void update_entity_list() {

  DWORD elStart = mem->FindPatternArray(modClient.dwBase, modClient.dwSize, "x????xx?xxx", 11, 0x5, 0x0, 0x0, 0x0, 0x0, 0xC1, 0xE9, 0x0, 0x39, 0x48, 0x4);

  DWORD elP1 = mem->Read<DWORD>(elStart + 1);

  BYTE elP2 = mem->Read<BYTE>(elStart + 7);

  dwEntityList = (elP1 + elP2) - modClient.dwBase;

 }

 static void update_glow() {

  DWORD gpStart = mem->FindPatternArray(modClient.dwBase, modClient.dwSize, "xx????x????xxx????xx????xx", 27, 0x8D, 0x8F, 0, 0, 0, 0, 0xA1, 0, 0, 0, 0, 0xC7, 0x4, 0x2, 0, 0, 0, 0, 0x89, 0x35, 0x0, 0x0, 0x0, 0x0, 0x8B, 0x51);

  dwGlow = mem->Read<DWORD>(gpStart + 7) - modClient.dwBase;

 }

public:

 static void get_offset(process* m) {

  mem = m;

  modClient = mem->GetModule("client.dll");

  update_local_player();

  update_entity_list();

  update_glow();

 }

 //constantly scanning & updating our offsets

 static DWORD WINAPI scan_offsets(LPVOID PARAM)

 {

  Entity players[64];

  while (true) {

   DWORD playerBase = memory.Read<DWORD>(GetClientModule()->dwBase + dwLocalPlayer);

   int cp = 0;

   update_entity_data(&me, playerBase);

   for (int i = 1; i < 64; i++) {

    DWORD entBase = memory.Read<DWORD>((GetClientModule()->dwBase + dwEntityList) + i * 0x10);

    if (entBase == NULL)

     continue;

    update_entity_data(&players[cp], entBase);

    cp++;

   }

   int cf = 0, ce = 0;

   for (int i = 0; i < cp; i++) {

    if (players[i].team == me.team) {

     entFriendlies[cf] = players[i];

     cf++;

    }

    else {

     entEnemies[ce] = players[i];

     ce++;

    }

   }

   iEnemies = ce;

   iFriendlies = cf;

  }

 }

};

class virtualesp

{

private:

 static void glow_player(DWORD mObj, float r, float g, float b)

 {

  memory.Write<float>(mObj + 0x4, r);

  memory.Write<float>(mObj + 0x8, g);

  memory.Write<float>(mObj + 0xC, b);

  memory.Write<float>(mObj + 0x10, 1.0f);

  memory.Write<BOOL>(mObj + 0x24, true);

  memory.Write<BOOL>(mObj + 0x25, false);

 }

 static float SanitizeColor(int value)

 {

  if (value > 255) value = 255;

  if (value < 0) value = 0;

  return (float)value / 255;

 }

public:

 static void start_engine() {

  while (!memory.Attach((void)"csgo.exe", PROCESS_ALL_ACCESS)) {

   Sleep(100);

  }

  do {

   Sleep(1000);

   offset::get_offset(&memory);

  } while (dwLocalPlayer < 65535);

  CreateThread(NULL, NULL, &offset::scan_offsets, NULL, NULL, NULL);

 }

 static unsigned long __stdcall esp_thread(void*)

 {

  int objectCount;

  DWORD pointerToGlow;

  Entity* Player = NULL;

  float Friend = SanitizeColor(100);

  float Enemy = SanitizeColor(140);

  while (true)

  {

   Sleep(10000000);

   pointerToGlow = memory.Read<DWORD>(GetClientModule()->dwBase + dwGlow);

   objectCount = memory.Read<DWORD>(GetClientModule()->dwBase + dwGlow + 0x4);

   if (pointerToGlow != NULL && objectCount > 0)

   {

    for (int i = 0; i < objectCount; i++)

    {

     DWORD mObj = pointerToGlow + i * sizeof(glow_t);

     glow_t glowObject = memory.Read<glow_t>(mObj);

     Player = GetEntityByBase(glowObject.dwBase);

     if (glowObject.dwBase == NULL || Player == nullptr || Player->is_dormant) {

      continue;

     }

     if (me.team == Player->team) {

      glow_player(mObj, 0, 0, Friend);

     }

     else {

      glow_player(mObj, Enemy, 0, 0);

     }

    }

   }

  }

  return EXIT_SUCCESS;

 }

};

int entryfunction(int arg, char* argv[INFINITE])

{

 bool enabled = false;

 HANDLE ESP = NULL;

 virtualesp::start_engine();

 while (TRUE)

 {

  if (GetAsyncKeyState(VK_F1) & 1) {

   enabled = !enabled;

   if (enabled) {

    std::cout << "ESP: on" << std::endl;

    ESP = CreateThread(NULL, NULL, &virtualesp::esp_thread, NULL, NULL, NULL);

   }

   else {

    std::cout << "ESP: off" << std::endl;

    TerminateThread(ESP, 0);

    CloseHandle(ESP);

   }

  }

 }

}

  • 1
    theixone 9 ay önce
    Dayıcım bune ? :)
    0
    whoami225 9 ay önce
    COUNTER STRİKE GLOBAL OFFENSİVE OYUNUNDA DUVARDAN ADAMLARI GÖRMENİ SAĞLIYAN BİR HİLENİN KODLARI
  • 0
    bohac 9 ay önce
    "I'm on VACation"


  • karışık

    Karışık

    23 takipçi

  • abone ol

  • moderatörler

    gaddarus

    oxygen
    tombalaci
    kaygusuzyazar
    ilteris
  • bölüm kuralları

    - bölümü takip etmeyi unutmayınız..

    aklınıza bölüm ismi gelmediyse bu bölüme ekleyebilirsiniz..

    ekleyeceğiniz bölümü bulamadıysanız bu bölüme ekleyebilirsiniz..

    bölüm seçmek istemeden koymak istiyorsanız bu bölüme ekleyebilirsiniz..

    başlık fark etmez istediğiniz başlıkta açabilirsiniz..

    - reklam yapmak yasaktır..

popi yükleniyor...

popi yükleniyor...

pupu yükleniyor...

pupu yükleniyor...

tepe yükleniyor...

tepe yükleniyor...