Эксперт
-
Автор темы
- #1
Всем привет, решил начать писать External софт на C++, буду учить вас и учиться вместе с вами, ибо раньше сидел только на интерналах.
Начнем с простенького Glow ESP.
Создаем консольное приложение и сразу создаем два файла - memory.cpp и memory.hpp.
В них будет храниться наш класс для работы с памятью игры.
в memory.hpp пихаем
в memory.cpp добавляем
Итак, мы создали наш класс для управления памятью процесса, теперь добавим два файла globals.cpp и globals.hpp в которых будут храниться наши глобальные переменные. Фактически это будет просто namespace, можно обойтись без него, но мне так удобнее.
в globals.hpp:
в globals.cpp:
Подключаем memory.hpp и globals.hpp к файлу main.cpp
Дальше чтобы, когда мы начали писать GlowESP не писать память много раз опишем структуру:
Описав структуру можем начать писать сам Glow ESP
Так как в чите будет не только Glow ESP, но и другие функции то вынесем GlowESP в отдельный поток, для этого нам нужно подключить к main.cpp инклуд <thread> и пропишем использование литералов из std::chrono_literals - using namespace std::chrono_literals;
Теперь действуем внутри функции main.cpp:
Первым делом давайте скроем саму консоль и для этого используем:
Теперь получаем всю нужную нам информацию:
Теперь объявим функцию для GlowESP:
И в эту функцию пока что ничего не добавляем, возвращаемся к main.cpp
Создаем и запускаем наш поток:
С этим все просто
И создадим пока что пустой цикл(мы заполним его в будущем)
ну и в конце функции добавляем
Теперь перейдем к объявленной функции GlowESP и начнем писать саму начинку:
Так же создадим там цикл
и начнем его заполнять:
сначала нам нужно получить GlowObjectManager для этого нам нужно прочитать память по определенному адресу, к счастью для вас есть hazedumper и все оффсеты(смещения) получить сможете вы там(надеюсь добавить отдельный файлик под них и просто переименовать неймспейсы каждый сможет), как мы будем получать GlowObjectManager? У нас для этого есть специальный класс, давайте им и воспользуемся:
и так же нам нужно получить нашу команду:
после этого создаем цикл на всех игроков:
В нем нам нужно получить сначала игрока для этого используем
но игрока под номером i может и не быть, поэтому чтобы отсеять пустые слоты делаем простую проверку
так же нам не нужно, чтобы glow применялся и на нас, поэтому немного изменим нашу проверку и получим вот это:
Дальше нам нужно получить GlowIndex игрока и его команду для этого снова читаем память
Создаем переменную
и читаем в нее память
дальше делаем простую проверку на команду и устанавливаем нужные цвета:
после этого нужно установить два bool значения и записать измененную структуру в память игры
и после цикла на всех игроков добавляем sleep на 1 мс, у нас же не компутеры для взлома пентагонов
На этом все, подведем итоги:
Мы сделали простенький класс для чтения/записи памяти, сделали GlowESP с всего лишь одной записью памяти(все благодаря структуре), а не шестью, если бы мы записывали по отдельности, сделали отключение нашего чита по горячей клавише, на этом все, не болейте, ждите следующий урок, он наверное будет(пока не уверен, но если это вам зайдет - то продолжение точно будет!)
Начнем с простенького Glow ESP.
Создаем консольное приложение и сразу создаем два файла - memory.cpp и memory.hpp.
В них будет храниться наш класс для работы с памятью игры.
в memory.hpp пихаем
Код:
#pragma once
class Memory
{
public:
Memory();
~Memory();
template <class value>
value read(DWORD addr)
{
value x; // Создаем переменную, куда попадет полученное при чтении памяти значение
ReadProcessMemory(handle, (LPBYTE*)addr, &x, sizeof(x), NULL); // Читаем из памяти процесса
return x; // Возвращаем значение, полученное после чтения памяти
}
template <class value>
void write(DWORD addr, value x)
{
WriteProcessMemory(handle, (LPBYTE*)addr, &x, sizeof(x), NULL); // Записываем в память процесса
}
uintptr_t GetProcess(const wchar_t*); // При помощи этой функции мы будем получать ID процесса
uintptr_t GetModule(uintptr_t, const wchar_t*); // При помощи этой функции мы будем получать модуль процесса
private:
HANDLE handle; // Ну и хэндл для чтения/записи памяти
};
extern Memory* Mem;
Код:
#include "memory.hpp"
Memory* mem = new Memory();
Memory::Memory()
{
handle = NULL;
}
Memory::~Memory()
{
CloseHandle(handle); // Закрываем наш хэндл
}
uintptr_t Memory::GetProcess(const wchar_t* procName)
{
HANDLE hProcessId = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); //Создаем snapshot всех запущенных в данный момент процессов
uintptr_t process;
PROCESSENTRY32 pEntry; // Переменная для хранения информации о процессе
pEntry.dwSize = sizeof(pEntry);
do
{
if (!_wcsicmp(pEntry.szExeFile, proc))
{
process = pEntry.th32ProcessID; // Получение ID процесса
CloseHandle(hProcessId); // Закрываем хендл, который мы создавали в начале этой функции
handle = OpenProcess(PROCESS_ALL_ACCESS, false, process); //Открываем наш хендл при помощи которого мы будем читать и писать память процесса
}
} while (Process32Next(hProcessId, &pEntry)); // Цикл для поиска процесса
return process; //Возврат ID процесса
}
uintptr_t Memory::GetModule(uintptr_t procId, const wchar_t* modName) // Здесь все тоже самое, что и с процессами, повторно описывать не буду
{
HANDLE hModule = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, procId);
MODULEENTRY32 mEntry;
mEntry.dwSize = sizeof(mEntry);
do
{
if (!_wcsicmp(mEntry.szModule, modName))
{
CloseHandle(hModule);
return (uintptr_t)mEntry.hModule;
}
} while (Module32Next(hModule, &mEntry));
return 0;
}в globals.hpp:
Код:
#pragma once
namespace globals
{
extern int processID; // Здесь будет храниться ID нашего процесса
extern uintptr_t clientModule; // Здесь хранится адрес модуля client_panorama.dll
extern uintptr_t engineModule; // Здесь будет храниться адрес модуля engine.dll (На будущее создал функцию!)
extern uintptr_t localplayer; // Указатель на нашего персонажа
extern uintptr_t entitylist; // Список entity
}
Код:
namespace globals
{
int processID = NULL;
uintptr_t clientModule = NULL;
uintptr_t engineModule = NULL;
uintptr_t localplayer = NULL;
uintptr_t entitylist = NULL;
}Дальше чтобы, когда мы начали писать GlowESP не писать память много раз опишем структуру:
Код:
struct GlowStruct
{
BYTE base[0x4]; //Пропускаем 4 байта
float red; // Красный цвет
float green; // Зеленый цвет
float blue; // Синий цвет
float alpha; // Прозрачность
BYTE pad[0x10]; //Пропускаем 16 байтов
bool renderWhenOccluded; // С этим пока не разобрался
bool renderWhenUnoccluded; // С этим пока не разобрался
bool fullBloom; // Заливка всей модельки
BYTE pad1[0x5]; // Пропускаем 5 байтов
int glowStyle; // Стиль Glow ESP
} Glow;Так как в чите будет не только Glow ESP, но и другие функции то вынесем GlowESP в отдельный поток, для этого нам нужно подключить к main.cpp инклуд <thread> и пропишем использование литералов из std::chrono_literals - using namespace std::chrono_literals;
Теперь действуем внутри функции main.cpp:
Первым делом давайте скроем саму консоль и для этого используем:
Код:
ShowWindow(GetConsoleWindow(), SW_HIDE); // с помощью GetConsoleWindow() получаем указатель на консольное окно и при помощи ShowWindow его скрываем
Код:
globals::processID = Mem->GetProcess(L"csgo.exe"); // ID процесса
globals::clientModule = Mem->GetModule(globals::processID, L"client_panorama.dll"); // Модуль client_panorama.dll
while (!globals::localplayer)
globals::localplayer = Mem->read<DWORD>(globals::clientModule + Offsets::dwLocalPlayer); // Указатель на нашего персонажа
Код:
void GlowThread()
{
}Создаем и запускаем наш поток:
Код:
std::thread tGlow(GlowThread);
tGlow.detach();И создадим пока что пустой цикл(мы заполним его в будущем)
Код:
while (!GetAsyncKeyState(VK_DELETE)) // нужно, чтобы мы могли выключить наш чит по нажатии на клавишу DELETE
{
std::this_thread::sleep_for(1ms);
}
Код:
return 0;Так же создадим там цикл
Код:
while(!GetAsyncKeyState(VK_DELETE))
{
}сначала нам нужно получить GlowObjectManager для этого нам нужно прочитать память по определенному адресу, к счастью для вас есть hazedumper и все оффсеты(смещения) получить сможете вы там(надеюсь добавить отдельный файлик под них и просто переименовать неймспейсы каждый сможет), как мы будем получать GlowObjectManager? У нас для этого есть специальный класс, давайте им и воспользуемся:
Код:
uintptr_t glowObject = Mem->read<uintptr_t>(globals::clientModule + Offsets::dwGlowObjectManager);
Код:
int localTeam = Mem->read<int>(globals::localplayer + Netvars::m_iTeamNum);
Код:
for(BYTE i = 0; i < 64; i++)
{
}
Код:
uintptr_t entity = Mem->read<uintptr_t>(globals::clientModule + Offsets::dwEntityList + i * 0x10);
Код:
if (!entity)
continue;
Код:
if (!entity || globals::localplayer == entity)
continue;
Код:
int glowIndex = Mem->read<int>(entity + Netvars::m_iGlowIndex);
int entityTeam = Mem->read<int>(entity + Netvars::m_iTeamNum);
Код:
GlowStruct Glow;
Код:
Glow = Mem->read<GlowStruct>(glowObject + (glowIndex * 0x38));
Код:
if (localTeam != entityTeam)
{
Glow.red = 1.f;
Glow.green = 0.f;
Glow.blue = 0.f;
Glow.alpha = 1.f;
}
else
{
Glow.red = 0.f;
Glow.green = 0.f;
Glow.blue = 1.f;
Glow.alpha = 1.f;
}
Код:
Glow.renderWhenOccluded = true;
Glow.renderWhenUnoccluded = false;
Mem->write<GlowStruct>(glowObject + (glowIndex * 0x38), Glow);
Код:
std::this_thread::sleep_for(1ms);Мы сделали простенький класс для чтения/записи памяти, сделали GlowESP с всего лишь одной записью памяти(все благодаря структуре), а не шестью, если бы мы записывали по отдельности, сделали отключение нашего чита по горячей клавише, на этом все, не болейте, ждите следующий урок, он наверное будет(пока не уверен, но если это вам зайдет - то продолжение точно будет!)
Последнее редактирование:
