ГАЙД: КАК СДЕЛАТЬ ВАЛХАК (ESP) ДЛЯ CS:GO на ЯЗЫКЕ C++

a1987zz · 21 май 2020

Всем привет! Решил написать свой собственный ГАЙД для Glow ESP. Сегодня вас научу (покажу), как создать свой собственный ESP, он же WallHack.
Если что не понятно - спрашивайте.

1. Открываем Visual Studio Community 2019 и создаем консольное приложение, называем как угодно.

Рис. 1.

Рис. 2.

2. Далее открываем настройки проекта и устанавливаем так, как показано на рисунках Рис. 3, Рис. 4.
Важно: проект должен быть установлен как Release x86.

Рис. 3.

Рис. 4.

Рис. 5.

3. Собственно, сам код.
#include <windows.h>
#include <TlHelp32.h>
#include <iostream>

typedef unsigned char uint8_t; // тут определенно uint8_t как unsigned char

template <typename T, size_t N>

size_t countof(T(&array)[N])
{
return N;
}

DWORD dwLocalPlayer; //will be scanned
DWORD dwEntityList; //will be scanned
DWORD dwGlow; //will be scanned

DWORD dwTeam = 0xF4;
DWORD dwDormant = 0xED;

struct PModule
{
DWORD dwBase;
DWORD dwSize;
};

/* Debugger/Process API implementation class */
class process
{

public:
bool Attach(const char* pName, DWORD rights)
{
HANDLE handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, '\0');
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(const 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 '\0';
}

for (DWORD i = 0; i < size; i++) {
if (DataCompare((const BYTE*)(data + i), (const BYTE*)sig, mask)) {
return start + i;
}
}
return '\0';
}

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, int);
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 == 0); // == 0 - это NULL бывшее. 0 работает в dev-cpp только
}
};

/* New Glow Object structure in csgo */
struct glow_t
{
char pad_0000[8]; //0x0000
float r;
float g;
float b;
float a;
char pad_0018[16]; //0x0018
bool renderOccluded; //0x0028
bool renderUnoccluded; //0x0029
};

//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[14];
//};

/* Entity structure in csgo */
struct Entity
{
DWORD dwBase;
int team;
bool is_dormant;
};

/* Player structure in csgo */
struct Player
{
int dwBase;
bool isDormant;
};

process memory;
process _modClient;
process* mem;
PModule modClient;

int iFriendlies;
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 = memory.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, "xxx????xxxxx????????", 20, 0x0F, 0x11, 0x05, 0x0, 0x0, 0x0, 0x0, 0x83, 0xC8, 0x01, 0xC7, 0x05, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0);
dwGlow = mem->Read<DWORD>(gpStart + 3) - 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) {
Sleep(1);
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 == 0)
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 + 0x8, r);
memory.Write<float>(mObj + 0xC, g);
memory.Write<float>(mObj + 0x10, b);
memory.Write<float>(mObj + 0x14, 1.0f);
memory.Write<int>(mObj + 0x28, 1);
}
/* 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("csgo.exe", PROCESS_ALL_ACCESS)) {
Sleep(100);
}
do {
Sleep(1000);
offset::get_offset(&memory);
} while (dwLocalPlayer < 65535);
CreateThread('\0', '\0', &offset::scan_offsets, '\0', '\0', '\0'); // '\0' - это NULL
}

static unsigned long __stdcall esp_thread(void*)
{
int objectCount;
DWORD pointerToGlow;
Entity* Player = NULL;
float Friend = SanitizeColor(600);
float Enemy = SanitizeColor(614);

while (true)
{
Sleep(1);
pointerToGlow = memory.Read<DWORD>(GetClientModule()->dwBase + dwGlow);
objectCount = memory.Read<DWORD>(GetClientModule()->dwBase + dwGlow + 0x4);
/* std::cout << objectCount << std::endl;*/
/* std::cout << sizeof(glow_t) << std::endl;*/
if (pointerToGlow != 0 && objectCount > 0)
{
for (int i = 0; i < objectCount; i++)
{
DWORD mObj = pointerToGlow + i * 0x38; //читает из памяти размер sizeof(glow_t)

glow_t glowObject = memory.Read<glow_t>(mObj);
// int glowObject = memory.Read<int>(GetClientModule()->dwBase + 0x5320758);
Player = GetEntityByBase(glowObject.dwBase);
// dtd::cout << Player->dwBase << std::endl;

//if (glowObject.dwBase == 0 || Player == nullptr || Player->is_dormant) {
// continue;
//}
if (me.team == 2) { // тут должна быть проверка Player->dwBase я ее не добавлял, нихочу разбираться.
glow_player(mObj, 0, 0, Friend);
}
else {
glow_player(mObj, Enemy, 0, 0);
}
}
}
}

return EXIT_SUCCESS;
}
};

int main()
{
SetConsoleTitle("GlowESP by (Your credentionals)");
bool enabled = false;
HANDLE ESP = NULL;

virtualesp::start_engine();

std::cout << "Game found, starting GlowESP!" << std::endl;
Sleep(400);
std::cout << "Press F1 to toggle GlowESP." << std::endl;
while (TRUE)
{
Sleep(100);
if (GetAsyncKeyState(VK_F1) & 1) {
enabled = !enabled;
if (enabled) {
std::cout << "Glow: Enabled" << std::endl;
ESP = CreateThread('\0', '\0', &virtualesp::esp_thread, '\0', '\0', '\0');
}
else {
std::cout << "Glow: Disabled" << std::endl;
TerminateThread(ESP, 0);
CloseHandle(ESP);
}
}
}
}

C
#include <windows.h>

#include <TlHelp32.h>

#include <iostream>



typedef unsigned char uint8_t; // тут определенно uint8_t как unsigned char



template <typename T, size_t N>



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

{

    return N;

}



DWORD dwLocalPlayer; //will be scanned

DWORD dwEntityList;  //will be scanned

DWORD dwGlow;        //will be scanned



DWORD dwTeam = 0xF4;

DWORD dwDormant = 0xED;



struct PModule

{

    DWORD dwBase;

    DWORD dwSize;

};



/* Debugger/Process API implementation class */

class process

{



public:

    bool Attach(const char* pName, DWORD rights)

    {

        HANDLE handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, '\0');

        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(const 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 '\0';

        }



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

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

                return start + i;

            }

        }

        return '\0';

    }



    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, int);

            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 == 0); // == 0 - это NULL бывшее. 0 работает в dev-cpp только

    }

};



/* New Glow Object structure in csgo */

struct glow_t

{

    char pad_0000[8]; //0x0000

    float r;

    float g;

    float b;

    float a;

    char pad_0018[16]; //0x0018

    bool renderOccluded; //0x0028

    bool renderUnoccluded; //0x0029

};



//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[14];

//};





/* Entity structure in csgo */

struct Entity

{

    DWORD dwBase;

    int team;

    bool is_dormant;

};



/* Player structure in csgo */

struct Player

{

    int dwBase;

    bool isDormant;

};



process memory;

process _modClient;

process* mem;

PModule modClient;



int iFriendlies;

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 = memory.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, "xxx????xxxxx????????", 20, 0x0F, 0x11, 0x05, 0x0, 0x0, 0x0, 0x0, 0x83, 0xC8, 0x01, 0xC7, 0x05, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0);

        dwGlow = mem->Read<DWORD>(gpStart + 3) - 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) {

            Sleep(1);

            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 == 0)

                    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 + 0x8, r);

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

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

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

        memory.Write<int>(mObj + 0x28, 1);

    }

   /* 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("csgo.exe", PROCESS_ALL_ACCESS)) {

            Sleep(100);

        }

        do {

         Sleep(1000);

         offset::get_offset(&memory);

        } while (dwLocalPlayer < 65535);

        CreateThread('\0', '\0', &offset::scan_offsets, '\0', '\0', '\0'); // '\0' - это NULL

    }



    static unsigned long __stdcall esp_thread(void*)

    {

       int objectCount;

        DWORD pointerToGlow;

        Entity* Player = NULL;

        float Friend = SanitizeColor(600);

        float Enemy = SanitizeColor(614);



        while (true)

        {

            Sleep(1);

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

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

          /*  std::cout << objectCount << std::endl;*/

           /* std::cout << sizeof(glow_t) << std::endl;*/

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

            {

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

                {

                    DWORD mObj = pointerToGlow + i * 0x38; //читает из памяти размер sizeof(glow_t)



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

                  //  int glowObject = memory.Read<int>(GetClientModule()->dwBase + 0x5320758);

                  Player = GetEntityByBase(glowObject.dwBase);

                 // dtd::cout << Player->dwBase << std::endl;



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

                   //     continue;

                    //}

                    if (me.team == 2) { // тут должна быть проверка Player->dwBase я ее не добавлял, нихочу разбираться.

                        glow_player(mObj, 0, 0, Friend);

                    }

                    else {

                        glow_player(mObj, Enemy, 0, 0);

                    }

                }

            }

        }



        return EXIT_SUCCESS;

    }

};



int main()

{

    SetConsoleTitle("GlowESP by (Your credentionals)");

    bool enabled = false;

    HANDLE ESP = NULL;



    virtualesp::start_engine();



    std::cout << "Game found, starting GlowESP!" << std::endl;

    Sleep(400);

    std::cout << "Press F1 to toggle GlowESP." << std::endl;

    while (TRUE)

    {

        Sleep(100);

        if (GetAsyncKeyState(VK_F1) & 1) {

            enabled = !enabled;

            if (enabled) {

                std::cout << "Glow: Enabled" << std::endl;

                ESP = CreateThread('\0', '\0', &virtualesp::esp_thread, '\0', '\0', '\0');

            }

            else {

                std::cout << "Glow: Disabled" << std::endl;

                TerminateThread(ESP, 0);

                CloseHandle(ESP);

            }

        }

    }

}
4. Далее собираем проект. Жмем сочетание клавиш «CTRL+SHIFT+B».
5. Идем в расположение проекта, указанного на Рис. 2. (у вас будет свой путь). Находим там папку "Release" (их в проекте будет две, нужно открыть самую первую), там, собственно, и находится наш exe файл.
6. Запускаем игру.
7. Запускаем наш экзешник от имени администратора или обычного пользователя.
8. F2 Вкл/Выкл программы.
9. Радуемся, что все работает!

Поздравляю! Вы написали свой собственный ESP!

Если что не понятно, то вот готовый экзешник: https://cloud.mail.ru/public/4kHm/Ko1HY8zSJ
Ссылка на virustotal: https://www.virustotal.com/gui/file...fd8f2936cd7539ac1d5af4f5e93491c3fe3/detection

NUR_Design · 21 май 2020

Нихуя не понял, но очень интересно

Nordia · 26 май 2020

Объяснять ничего не буду, т.к. тема не для этого.

ФСО · 31 май 2020

Ток седня начал изучать C++ и понял что тут интересно, но сложна :D

kardan35 · 3 июн 2020

Можно и комментировать строки !

Davinci · 3 июн 2020

Нихуя не понял но очень интересно

Quadro_inactive3261035 · 3 июн 2020

а потом бан , класс

CLOWNSQUAD · 3 июн 2020

Зачем это публиковать в 2021

timoxa20102010_inactive12054 · 7 июл 2020

да автору респект тоже начел учить с++

0deleted0 · 8 июл 2020

Так ты же просто сурсы выложил получается

id327576231 · 27 янв 2021

Дай свой вк

--- Сообщение объединено с предыдущим 9 июл 2020
У меня вопросов много

--- Сообщение объединено с предыдущим 9 июл 2020
пж

artmfdg · 20 фев 2021

полная хуйня.
гайд -- скинул готовый код, ничего не объяснив.
желаю научится автору отличать float от double

savagegod0 · 19 май 2022

не работает чета

Bunnyscript · 20 май 2022

Как-то криво пофиксил. Там все сбилось, нужно разбираться.

Menatalitet · 20 май 2022

Интересно спасибо

hayk4500 · 1 июн 2022

А смысл просто кода без объяснений и вообще понимания этого кода? Это просто копипаста, это не программирование, это не кодерство и даже не написание своего чита, это просто копипаста

unnamed001 · 5 июн 2022

за такие приколы с прямым измение памяти ты будешь попадатся тоже с читерами)

a1987zz · 10 июн 2022

Добавил исходник под dev-cpp компилировал экзешник там же, проще было фиксить ошибки, под vs не проверял. Я не стал заморачиваться с esp. Код сырой, работает. Что непонятно спрашивайте, постараюсь ответить. Для работы чита нужно отключить антивирус и защитник виндовс.

Vlevent · 26 авг 2022

сработает на игры кроме CS:GO? Например, игра Stalcraft, слышал игра сделана на Java, этот чит сработает с ней?

Yukki01 · 28 авг 2022

Vlevent, на java нет. Java совсем другой движок.

Animate ProgressBar

Помогите пожалуйста с компиляцией

Нужно ли знать C для C++

Ldplayer overlay

В чем разница winapi ntdll syscall

Сделаю бесплатно С++ / практика

Как получить steamLoginSecure от Стима через С++?

Как подключить esc к бессколеторному мотору

Замена оффсетов через адб?

Помогите с sfml

C ошибка считавание строк

Почему не работает светодиод?

C++ UAC Bypass // 12+ Methods

Как подключить к плате stm32 датчики

Какой фреймворк лучше использовать для написания тестов сайта/ботов.

ГАЙД: КАК СДЕЛАТЬ ВАЛХАК (ESP) ДЛЯ CS:GO на ЯЗЫКЕ C++

Ищу желающих выучить Cairo

Не понимаю как работает многопоточность

Помогите советом для изучения С++

Что изучать после ООП

Лоадер (С++)

Посоветуйте есть ли какой-то готовый байпас изи анти чита

Люди пишут как гпт ?

Помогите пж

Посоветуйте книгу для stm32

У меня есть такие файлы, как их запустить ваще

Есть какие-нибудь проекты на C++

Проблема с код x32 инжектора PE

Что такое Debug и Release в VS ?

Как перевести русские символы в верхний регистр

ГАЙД: КАК СДЕЛАТЬ ВАЛХАК (ESP) ДЛЯ CS:GO на ЯЗЫКЕ C++