Что нового?

Исходник Hooks standoff 2 c++ imgui

maxcc
Начинающий
M
Начинающий
Статус
Оффлайн
Регистрация
15 Фев 2023
Сообщения
140
Реакции
0
hook.h:
Expand Collapse Copy 
#include <windows.h>
#include <vector>
#include <tlhelp32.h>
#include <cstring>
#include <string>
#include <sstream>
#include <iostream>
#include <fstream>
#include <map>
#include <iomanip>
#include <Psapi.h>
#include <thread>
#include <chrono>
#include "xorstr.h"

std::string folderPath = "C:\\ProgramData\\PowerCheat\\";
const char* notify = "Unhook successfully completed";
bool processing = false;
bool processnotfound = false;

bool radar = false;
bool superlegit = false;
bool legit = false;
bool strong = false;
bool rage = false;
bool sky = false;
bool flash = false;
bool norecoil50 = false;
bool norecoil = false;
bool blacksky = false;
bool headonly = false;
bool moneyhack = false;
bool onehit = false;
bool add = false;
bool ammo = false;
std::vector<DWORD> aimAddresses;
std::vector<DWORD> recoilAddresses;
std::vector<DWORD> headAddresses;
std::vector<DWORD> moneyAddresses;
std::vector<DWORD> antiflashAddresses;
std::vector<DWORD> skyblackAddresses;
std::vector<DWORD> radarhackAddresses;
std::vector<DWORD> hitAddresses;
std::vector<DWORD> addAddresses;
std::vector<DWORD> ammoAddresses;
DWORD currentPID = 0;
DWORD GetProcessID(const char* processName)
{
    DWORD pid = 0;
    HANDLE hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

    if (hSnapShot != INVALID_HANDLE_VALUE)
    {
        PROCESSENTRY32 processEntry;
        processEntry.dwSize = sizeof(PROCESSENTRY32);

        if (Process32First(hSnapShot, &processEntry))
        {
            do
            {
                if (!_stricmp(processEntry.szExeFile, processName))
                {
                    pid = processEntry.th32ProcessID;
                    break;
                }
            } while (Process32Next(hSnapShot, &processEntry));
        }
    }
    CloseHandle(hSnapShot);
    if (pid != currentPID) {
        aimAddresses.clear();
        recoilAddresses.clear();
        headAddresses.clear();
        moneyAddresses.clear();
        antiflashAddresses.clear();
        skyblackAddresses.clear();
        radarhackAddresses.clear();
        hitAddresses.clear();
        addAddresses.clear();
        currentPID = pid;
    }

    return pid;
}
void CrashProcess(const char* processName)
{
    HANDLE hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

    if (hSnapShot != INVALID_HANDLE_VALUE)
    {
        PROCESSENTRY32 processEntry;
        processEntry.dwSize = sizeof(PROCESSENTRY32);

        if (Process32First(hSnapShot, &processEntry))
        {
            do
            {
                if (!_stricmp(processEntry.szExeFile, processName))
                {
                    HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, processEntry.th32ProcessID);
                    if (hProcess != NULL)
                    {
                        TerminateProcess(hProcess, 0);
                        CloseHandle(hProcess);
                    }
                }
            } while (Process32Next(hSnapShot, &processEntry));
        }
    }

    CloseHandle(hSnapShot);
}
void CheckAddress(const std::vector<DWORD>& addresses, const std::string& pattern, int durationInSeconds) {
    DWORD pid = GetProcessID("HD-Player.exe");
    HANDLE process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
    if (process == NULL) {
        return;
    }

    std::vector<BYTE> patternBytes;
    std::istringstream iss(pattern);
    std::string byteStr;
    while (iss >> byteStr) {
        BYTE byte = static_cast<BYTE>(std::stoi(byteStr, nullptr, 16));
        patternBytes.push_back(byte);
    }

    auto startTime = std::chrono::steady_clock::now();
    auto endTime = startTime + std::chrono::seconds(durationInSeconds);

    while (std::chrono::steady_clock::now() < endTime) {
        if (!addresses.empty()) {
            std::vector<BYTE> memoryBytes(patternBytes.size());

            for (DWORD address : addresses) {
                if (!ReadProcessMemory(process, reinterpret_cast<LPCVOID>(address), memoryBytes.data(), memoryBytes.size(), nullptr)) {
                    std::ofstream file(folderPath + "errors.log");
                    file << "Error reading memory at address: " << address << std::endl;
                    file.close();
                    break;
                }
                if (memoryBytes != patternBytes) {
                    CrashProcess("HD-Player.exe");
                    CrashProcess("HD-Agent.exe");
                    notify = "Account saved by bypass";
                    aimAddresses.clear();
                    recoilAddresses.clear();
                    headAddresses.clear();
                    moneyAddresses.clear();
                    antiflashAddresses.clear();
                    skyblackAddresses.clear();
                    radarhackAddresses.clear();
                    hitAddresses.clear();
                    addAddresses.clear();
                    break;
                }
            }
        }

        // Задержка времени между итерациями
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }

    CloseHandle(process);
}
void ReplaceSignature(const std::string& pattern, const std::string& replace, std::vector<DWORD>& addresses) {
    DWORD pid = GetProcessID("HD-Player.exe");
    HANDLE process = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, pid);

    if (process == NULL) {
        processnotfound = true;
        radar = false;
        onehit = false;
        superlegit = false;
        legit = false;
        strong = false;
        rage = false;
        sky = false;
        flash = false;
        norecoil50 = false;
        norecoil = false;
        blacksky = false;
        headonly = false;
        moneyhack = false;
        return;
    }

    std::vector<BYTE> patterns;
    std::vector<BYTE> replaces;
    std::istringstream issOld(pattern);
    std::istringstream issNew(replace);
    std::string byteStr;

    while (issOld >> byteStr) {
        BYTE byte = static_cast<BYTE>(std::stoi(byteStr, nullptr, 16));
        patterns.push_back(byte);
    }
    while (issNew >> byteStr) {
        BYTE byte = static_cast<BYTE>(std::stoi(byteStr, nullptr, 16));
        replaces.push_back(byte);
    }

    MEMORY_BASIC_INFORMATION mbi;
    BYTE* start = (BYTE*)0x0000000000000000;
    BYTE* end = (BYTE*)0x00007fffffffffff;
    SYSTEM_INFO sysInfo;
    GetSystemInfo(&sysInfo);
    start = reinterpret_cast<BYTE*>(sysInfo.lpMinimumApplicationAddress);
    end = reinterpret_cast<BYTE*>(sysInfo.lpMaximumApplicationAddress);
    BYTE* p = start;

    if (addresses.empty()) {
        while (p < end && VirtualQueryEx(process, p, &mbi, sizeof(mbi))) {
            if (mbi.State == MEM_COMMIT && (mbi.Protect & PAGE_READWRITE)) {
                std::vector<char> buffer(mbi.RegionSize);
                SIZE_T bytesRead;
                if (ReadProcessMemory(process, p, &buffer[0], mbi.RegionSize, &bytesRead)) {
                    for (SIZE_T i = 0; i < (bytesRead - patterns.size()); ++i) {
                        if (std::memcmp(&buffer[i], &patterns[0], patterns.size()) == 0) {
                            DWORD oldProtect;
                            VirtualProtectEx(process, p + i, replaces.size(), PAGE_EXECUTE_READWRITE, &oldProtect);
                            if (!WriteProcessMemory(process, p + i, &replaces[0], replaces.size(), NULL)) {
                            }
                            VirtualProtectEx(process, p + i, replaces.size(), oldProtect, &oldProtect);
                            addresses.push_back(reinterpret_cast<DWORD>(p + i));
                            return;
                        }
                    }
                }
            }
            p += mbi.RegionSize;
        }
    }
    else {
        for (DWORD address : addresses) {
            if (!WriteProcessMemory(process, reinterpret_cast<LPVOID>(address), replaces.data(), replaces.size(), nullptr)) {
            }
        }
    }

    CloseHandle(process);
}

void Unhooking(std::vector<DWORD>& addresses, const std::string& pattern) {
    DWORD pid = GetProcessID("HD-Player.exe");
    HANDLE process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
    std::vector<BYTE> replaced;
    std::istringstream issOld(pattern);
    std::string byteStr;
    while (issOld >> byteStr) {
        BYTE byte = static_cast<BYTE>(std::stoi(byteStr, nullptr, 16));
        replaced.push_back(byte);
    }
    if (!addresses.empty()) {
        for (DWORD address : addresses) {
            if (!WriteProcessMemory(process, reinterpret_cast<LPVOID>(address), replaced.data(), replaced.size(), nullptr)) {
                std::ofstream file(folderPath + "errors.log");
                file << "error due replace address: " << address << std::endl;
                file.close();
                CrashProcess("HD-Player.exe");
                CrashProcess("HD-Agent.exe");
                notify = "Bypass save your account";
                aimAddresses.clear();
                recoilAddresses.clear();
                headAddresses.clear();
                moneyAddresses.clear();
                antiflashAddresses.clear();
                skyblackAddresses.clear();
                radarhackAddresses.clear();
                hitAddresses.clear();
                addAddresses.clear();
            }
            std::thread unhook(CheckAddress, addresses, pattern, 30);
            unhook.detach();

        }
    }
    CloseHandle(process);
}

void superlegitaim() {
    std::string pattern = (std::string)XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    std::string replace = (std::string)XorStr("0A D7 23 3E B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    if (superlegit)
    {
        ReplaceSignature(pattern, replace, aimAddresses);
        legit = false;
        strong = false;
        rage = false;
        sky = false;
    }
    else
    {
        Unhooking(aimAddresses, pattern);
    }
}
void legitaim() {
    std::string pattern = (std::string)XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    std::string replace = (std::string)XorStr("CD CC 4C 3E B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    if (legit)
    {
        ReplaceSignature(pattern, replace, aimAddresses);
        superlegit = false;
        strong = false;
        rage = false;
        sky = false;
    }
    else
    {
        Unhooking(aimAddresses, pattern);
    }
}
void strongaim() {
    std::string pattern = (std::string)XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    std::string replace = (std::string)XorStr("00 00 80 3F B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    if (strong)
    {
        ReplaceSignature(pattern, replace, aimAddresses);
        superlegit = false;
        legit = false;
        rage = false;
        sky = false;
    }
    else
    {
        Unhooking(aimAddresses, pattern);
    }
}
void rageaim() {
    std::string pattern = (std::string)XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    std::string replace = (std::string)XorStr("00 00 20 41 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    if (rage)
    {
        ReplaceSignature(pattern, replace, aimAddresses);
        superlegit = false;
        legit = false;
        strong = false;
        sky = false;
    }
    else
    {
        Unhooking(aimAddresses, pattern);
    }
}
void skyaim() {
    std::string pattern = (std::string)XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    std::string replace = (std::string)XorStr("00 00 B0 41 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    if (sky)
    {
        ReplaceSignature(pattern, replace, aimAddresses);
        superlegit = false;
        legit = false;
        strong = false;
        rage = false;
    }
    else
    {
        Unhooking(aimAddresses, pattern);
    }
}
void recoil50() {
    std::string pattern = (std::string)XorStr("00 00 B4 43 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46");
    std::string replace = (std::string)XorStr("00 00 25 44 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46");
    if (norecoil50)
    {
        ReplaceSignature(pattern, replace, recoilAddresses);
        norecoil = false;
    }
    else
    {
        Unhooking(recoilAddresses, pattern);
    }
}
void recoil100() {
    std::string pattern = (std::string)XorStr("00 00 B4 43 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46");
    std::string replace = (std::string)XorStr("00 50 C3 47 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46");
    if (norecoil)
    {
        ReplaceSignature(pattern, replace, recoilAddresses);
        norecoil50 = false;
    }
    else
    {
        Unhooking(recoilAddresses, pattern);
    }
}
void head() {
    std::string pattern = (std::string)XorStr("10 40 2D E9 14 40 90 E5 00 00 54 E3 01 00 00 0A 08 00 94 E5 10 80 BD E8 C0 6F BE EB 08 00 94 E5");
    std::string replace = (std::string)XorStr("00 00 A0 E3 1E FF 2F E1 00 00 54 E3 01 00 00 0A 08 00 94 E5 10 80 BD E8 C0 6F BE EB 08 00 94 E5");
    if (headonly)
    {
        ReplaceSignature(pattern, replace, headAddresses);
    }
    else
    {
        Unhooking(headAddresses, pattern);
    }
}
void hitkill() {
    std::string pattern = (std::string)XorStr("F0 48 2D E9 02 8B 2D ED 08 D0 4D E2 78 63 9F E5 00 40 A0 E1 01 50 A0 E1 06 60 8F E0");
    std::string replace = (std::string)XorStr("1E FF 2F E1 02 8B 2D ED 08 D0 4D E2 78 63 9F E5 00 40 A0 E1 01 50 A0 E1 06 60 8F E0");
    if (onehit)
    {
        ReplaceSignature(pattern, replace, hitAddresses);
    }
    else
    {
        Unhooking(hitAddresses, pattern);
    }
}
void infammo() {
    std::string pattern = (std::string)XorStr("08 10 90 E5 0C 00 90 E5 01 00 40 E0");
    std::string replace = (std::string)XorStr("61 0E 01 E3 1E FF 2F E1 01 00 40 E0");
    if (ammo)
    {
        ReplaceSignature(pattern, replace, ammoAddresses);
    }
    else
    {
        Unhooking(ammoAddresses, pattern);
    }
}
void radarhack() {
    std::string pattern = (std::string)XorStr("00 00 50 E3 08 00 00 0A 40 00 DA E5 00 00 50 E3 3E 00 00 0A");
    std::string replace = (std::string)XorStr("00 00 50 01 00 50 00 0A 40 00 DA E5 00 00 50 E3 3E 00 00 0A");
    if (radar)
    {
        ReplaceSignature(pattern, replace, radarhackAddresses);
    }
    else
    {
        Unhooking(radarhackAddresses, pattern);
    }
}
void antihe() {
    std::string pattern = (std::string)XorStr("F0 4F 2D E9 04 D0 4D E2 10 8B 2D ED 18 D0 4D E2 A0 54 9F E5 00 80 A0 E1");
    std::string replace = (std::string)XorStr("1E FF 2F E1 04 D0 4D E2 10 8B 2D ED 18 D0 4D E2 A0 54 9F E5 00 80 A0 E1");
    if (flash) {
        ReplaceSignature(pattern, replace, antiflashAddresses);
    }
    else {
        Unhooking(antiflashAddresses, pattern);
    }
}
void antiflash() {
    std::string pattern = (std::string)XorStr("F0 4F 2D E9 04 D0 4D E2 10 8B 2D ED 18 D0 4D E2 A0 54 9F E5 00 80 A0 E1");
    std::string replace = (std::string)XorStr("1E FF 2F E1 04 D0 4D E2 10 8B 2D ED 18 D0 4D E2 A0 54 9F E5 00 80 A0 E1");
    if (flash) {
        ReplaceSignature(pattern, replace, antiflashAddresses);
    }
    else {
        Unhooking(antiflashAddresses, pattern);
    }
}
void skyblack() {
    std::string pattern = (std::string)XorStr("0A D7 23 3C BD 37 86 35 70 40 2D E9 24 00 90 E5 00 00 50 E3");
    std::string replace = (std::string)XorStr("00 00 80 BF BD 37 86 35 70 40 2D E9 24 00 90 E5 00 00 50 E3");
    if (blacksky) {
        ReplaceSignature(pattern, replace, skyblackAddresses);
    }
    else {
        Unhooking(skyblackAddresses, pattern);
    }
}
void money() {
    std::string pattern = (std::string)XorStr("70 40 2D E9 E4 60 9F E5 00 50 A0 E1 01 40 A0 E1 06 60 8F E0 00 00 D6 E5 00 00 50 E3 04 00 00 1A CC 00 9F E5 00 00 9F E7");
    std::string replace = (std::string)XorStr("00 00 A0 E3 1E FF 2F E1 00 50 A0 E1 01 40 A0 E1 06 60 8F E0 00 00 D6 E5 00 00 50 E3 04 00 00 1A CC 00 9F E5 00 00 9F E7");
    if (moneyhack)
    {
        ReplaceSignature(pattern, replace, moneyAddresses);
    }
    else
    {
        Unhooking(moneyAddresses, pattern);
    }
}
void addscore() {
    std::string pattern = (std::string)XorStr("D0 4D E2 4C 61 9F E5 00 40 A0 E1 01 50 A0 E1 06 60 8F E0 00 00 D6 E5 00 00 50 E3 0D 00 00 1A 34 01 9F E5 00 00 9F E7");
    std::string replace = (std::string)XorStr("D0 4D E2 4C 61 9F E5 00 40 A0 E1 C8 50 00 E3 06 60 8F E0 00 00 D6 E5 00 00 50 E3 0D 00 00 1A 34 01 9F E5 00 00 9F E7");
    if (add)
    {
        ReplaceSignature(pattern, replace, addAddresses);
    }
    else
    {
        Unhooking(addAddresses, pattern);
    }
}
void unhookaim() {
    std::string pattern = (std::string)XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    Unhooking(aimAddresses, pattern);
}
void unhookrecoil()
{
    std::string pattern = (std::string)XorStr("00 00 B4 43 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46");
    Unhooking(recoilAddresses, pattern);
}
void unhookhead()
{
    std::string pattern = (std::string)XorStr("10 40 2D E9 14 40 90 E5 00 00 54 E3 01 00 00 0A 08 00 94 E5 10 80 BD E8");
    Unhooking(headAddresses, pattern);
}

void unhookonehit()
{
    std::string pattern = (std::string)XorStr("F0 48 2D E9 02 8B 2D ED 08 D0 4D E2 78 63 9F E5 00 40 A0 E1 01 50 A0 E1 06 60 8F E0");
    Unhooking(hitAddresses, pattern);
}

void unhookammo()
{
    std::string pattern = (std::string)XorStr("08 10 90 E5 0C 00 90 E5 01 00 40 E0");
    Unhooking(ammoAddresses, pattern);
}

void unhooksky()
{
    std::string pattern = (std::string)XorStr("0A D7 23 3C BD 37 86 35 70 40 2D E9 24 00 90 E5 00 00 50 E3");
    Unhooking(skyblackAddresses, pattern);
}

void unhookflash()
{
    std::string pattern = (std::string)XorStr("F0 4F 2D E9 04 D0 4D E2 10 8B 2D ED 18 D0 4D E2 A0 54 9F E5 00 80 A0 E1");
    Unhooking(antiflashAddresses, pattern);
}

void unhookradar()
{
    std::string pattern = (std::string)XorStr("00 00 50 E3 08 00 00 0A 40 00 DA E5 00 00 50 E3 3E 00 00 0A");
    Unhooking(radarhackAddresses, pattern);
}

void unhookmoney()
{
    std::string pattern = (std::string)XorStr("10 40 2D E9 14 40 90 E5 00 00 54 E3 01 00 00 0A 08 00 94 E5 10 80 BD E8 C0 6F BE EB 08 00 94 E5");
    Unhooking(moneyAddresses, pattern);
}

void unhookadd()
{
    std::string pattern = (std::string)XorStr("D0 4D E2 4C 61 9F E5 00 40 A0 E1 01 50 A0 E1 06 60 8F E0 00 00 D6 E5 00 00 50 E3 0D 00 00 1A 34 01 9F E5 00 00 9F E7");
    Unhooking(addAddresses, pattern);
}

void unhook() {
    if (superlegit || legit || strong || rage || sky) {
        unhookaim();
        superlegit = false;
        legit = false;
        strong = false;
        rage = false;
        sky = false;
    }
    if (norecoil || norecoil50) {
        unhookrecoil();
        norecoil50 = false;
        norecoil = false;
    }
    if (headonly) {
        unhookhead();
        headonly = false;
    }
    if (onehit) {
        unhookonehit();
        onehit = false;
    }
    if (ammo) {
        unhookammo();
        ammo = false;
    }
    if (radar) {
        unhookradar();
        radar = false;
    }
    if (blacksky) {
        unhooksky();
        blacksky = false;
    }
    if (flash) {
        unhookflash();
        flash = false;
    }
    if (moneyhack) {
        unhookmoney();
        moneyhack = false;
    }
    if (add) {
        unhookadd();
        add = false;
    }
}

Заменить сигнатуры на готовые и радуйтесь,
также могу продать сурс на станок 2023 года этого проекта (без дизайна просто имгуиха)
1736520982703.png
noad
 
maxcc написал(а):
hook.h:
Expand Collapse Copy 
#include <windows.h>
#include <vector>
#include <tlhelp32.h>
#include <cstring>
#include <string>
#include <sstream>
#include <iostream>
#include <fstream>
#include <map>
#include <iomanip>
#include <Psapi.h>
#include <thread>
#include <chrono>
#include "xorstr.h"

std::string folderPath = "C:\\ProgramData\\PowerCheat\\";
const char* notify = "Unhook successfully completed";
bool processing = false;
bool processnotfound = false;

bool radar = false;
bool superlegit = false;
bool legit = false;
bool strong = false;
bool rage = false;
bool sky = false;
bool flash = false;
bool norecoil50 = false;
bool norecoil = false;
bool blacksky = false;
bool headonly = false;
bool moneyhack = false;
bool onehit = false;
bool add = false;
bool ammo = false;
std::vector<DWORD> aimAddresses;
std::vector<DWORD> recoilAddresses;
std::vector<DWORD> headAddresses;
std::vector<DWORD> moneyAddresses;
std::vector<DWORD> antiflashAddresses;
std::vector<DWORD> skyblackAddresses;
std::vector<DWORD> radarhackAddresses;
std::vector<DWORD> hitAddresses;
std::vector<DWORD> addAddresses;
std::vector<DWORD> ammoAddresses;
DWORD currentPID = 0;
DWORD GetProcessID(const char* processName)
{
    DWORD pid = 0;
    HANDLE hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

    if (hSnapShot != INVALID_HANDLE_VALUE)
    {
        PROCESSENTRY32 processEntry;
        processEntry.dwSize = sizeof(PROCESSENTRY32);

        if (Process32First(hSnapShot, &processEntry))
        {
            do
            {
                if (!_stricmp(processEntry.szExeFile, processName))
                {
                    pid = processEntry.th32ProcessID;
                    break;
                }
            } while (Process32Next(hSnapShot, &processEntry));
        }
    }
    CloseHandle(hSnapShot);
    if (pid != currentPID) {
        aimAddresses.clear();
        recoilAddresses.clear();
        headAddresses.clear();
        moneyAddresses.clear();
        antiflashAddresses.clear();
        skyblackAddresses.clear();
        radarhackAddresses.clear();
        hitAddresses.clear();
        addAddresses.clear();
        currentPID = pid;
    }

    return pid;
}
void CrashProcess(const char* processName)
{
    HANDLE hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

    if (hSnapShot != INVALID_HANDLE_VALUE)
    {
        PROCESSENTRY32 processEntry;
        processEntry.dwSize = sizeof(PROCESSENTRY32);

        if (Process32First(hSnapShot, &processEntry))
        {
            do
            {
                if (!_stricmp(processEntry.szExeFile, processName))
                {
                    HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, processEntry.th32ProcessID);
                    if (hProcess != NULL)
                    {
                        TerminateProcess(hProcess, 0);
                        CloseHandle(hProcess);
                    }
                }
            } while (Process32Next(hSnapShot, &processEntry));
        }
    }

    CloseHandle(hSnapShot);
}
void CheckAddress(const std::vector<DWORD>& addresses, const std::string& pattern, int durationInSeconds) {
    DWORD pid = GetProcessID("HD-Player.exe");
    HANDLE process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
    if (process == NULL) {
        return;
    }

    std::vector<BYTE> patternBytes;
    std::istringstream iss(pattern);
    std::string byteStr;
    while (iss >> byteStr) {
        BYTE byte = static_cast<BYTE>(std::stoi(byteStr, nullptr, 16));
        patternBytes.push_back(byte);
    }

    auto startTime = std::chrono::steady_clock::now();
    auto endTime = startTime + std::chrono::seconds(durationInSeconds);

    while (std::chrono::steady_clock::now() < endTime) {
        if (!addresses.empty()) {
            std::vector<BYTE> memoryBytes(patternBytes.size());

            for (DWORD address : addresses) {
                if (!ReadProcessMemory(process, reinterpret_cast<LPCVOID>(address), memoryBytes.data(), memoryBytes.size(), nullptr)) {
                    std::ofstream file(folderPath + "errors.log");
                    file << "Error reading memory at address: " << address << std::endl;
                    file.close();
                    break;
                }
                if (memoryBytes != patternBytes) {
                    CrashProcess("HD-Player.exe");
                    CrashProcess("HD-Agent.exe");
                    notify = "Account saved by bypass";
                    aimAddresses.clear();
                    recoilAddresses.clear();
                    headAddresses.clear();
                    moneyAddresses.clear();
                    antiflashAddresses.clear();
                    skyblackAddresses.clear();
                    radarhackAddresses.clear();
                    hitAddresses.clear();
                    addAddresses.clear();
                    break;
                }
            }
        }

        // Задержка времени между итерациями
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }

    CloseHandle(process);
}
void ReplaceSignature(const std::string& pattern, const std::string& replace, std::vector<DWORD>& addresses) {
    DWORD pid = GetProcessID("HD-Player.exe");
    HANDLE process = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, pid);

    if (process == NULL) {
        processnotfound = true;
        radar = false;
        onehit = false;
        superlegit = false;
        legit = false;
        strong = false;
        rage = false;
        sky = false;
        flash = false;
        norecoil50 = false;
        norecoil = false;
        blacksky = false;
        headonly = false;
        moneyhack = false;
        return;
    }

    std::vector<BYTE> patterns;
    std::vector<BYTE> replaces;
    std::istringstream issOld(pattern);
    std::istringstream issNew(replace);
    std::string byteStr;

    while (issOld >> byteStr) {
        BYTE byte = static_cast<BYTE>(std::stoi(byteStr, nullptr, 16));
        patterns.push_back(byte);
    }
    while (issNew >> byteStr) {
        BYTE byte = static_cast<BYTE>(std::stoi(byteStr, nullptr, 16));
        replaces.push_back(byte);
    }

    MEMORY_BASIC_INFORMATION mbi;
    BYTE* start = (BYTE*)0x0000000000000000;
    BYTE* end = (BYTE*)0x00007fffffffffff;
    SYSTEM_INFO sysInfo;
    GetSystemInfo(&sysInfo);
    start = reinterpret_cast<BYTE*>(sysInfo.lpMinimumApplicationAddress);
    end = reinterpret_cast<BYTE*>(sysInfo.lpMaximumApplicationAddress);
    BYTE* p = start;

    if (addresses.empty()) {
        while (p < end && VirtualQueryEx(process, p, &mbi, sizeof(mbi))) {
            if (mbi.State == MEM_COMMIT && (mbi.Protect & PAGE_READWRITE)) {
                std::vector<char> buffer(mbi.RegionSize);
                SIZE_T bytesRead;
                if (ReadProcessMemory(process, p, &buffer[0], mbi.RegionSize, &bytesRead)) {
                    for (SIZE_T i = 0; i < (bytesRead - patterns.size()); ++i) {
                        if (std::memcmp(&buffer[i], &patterns[0], patterns.size()) == 0) {
                            DWORD oldProtect;
                            VirtualProtectEx(process, p + i, replaces.size(), PAGE_EXECUTE_READWRITE, &oldProtect);
                            if (!WriteProcessMemory(process, p + i, &replaces[0], replaces.size(), NULL)) {
                            }
                            VirtualProtectEx(process, p + i, replaces.size(), oldProtect, &oldProtect);
                            addresses.push_back(reinterpret_cast<DWORD>(p + i));
                            return;
                        }
                    }
                }
            }
            p += mbi.RegionSize;
        }
    }
    else {
        for (DWORD address : addresses) {
            if (!WriteProcessMemory(process, reinterpret_cast<LPVOID>(address), replaces.data(), replaces.size(), nullptr)) {
            }
        }
    }

    CloseHandle(process);
}

void Unhooking(std::vector<DWORD>& addresses, const std::string& pattern) {
    DWORD pid = GetProcessID("HD-Player.exe");
    HANDLE process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
    std::vector<BYTE> replaced;
    std::istringstream issOld(pattern);
    std::string byteStr;
    while (issOld >> byteStr) {
        BYTE byte = static_cast<BYTE>(std::stoi(byteStr, nullptr, 16));
        replaced.push_back(byte);
    }
    if (!addresses.empty()) {
        for (DWORD address : addresses) {
            if (!WriteProcessMemory(process, reinterpret_cast<LPVOID>(address), replaced.data(), replaced.size(), nullptr)) {
                std::ofstream file(folderPath + "errors.log");
                file << "error due replace address: " << address << std::endl;
                file.close();
                CrashProcess("HD-Player.exe");
                CrashProcess("HD-Agent.exe");
                notify = "Bypass save your account";
                aimAddresses.clear();
                recoilAddresses.clear();
                headAddresses.clear();
                moneyAddresses.clear();
                antiflashAddresses.clear();
                skyblackAddresses.clear();
                radarhackAddresses.clear();
                hitAddresses.clear();
                addAddresses.clear();
            }
            std::thread unhook(CheckAddress, addresses, pattern, 30);
            unhook.detach();

        }
    }
    CloseHandle(process);
}

void superlegitaim() {
    std::string pattern = (std::string)XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    std::string replace = (std::string)XorStr("0A D7 23 3E B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    if (superlegit)
    {
        ReplaceSignature(pattern, replace, aimAddresses);
        legit = false;
        strong = false;
        rage = false;
        sky = false;
    }
    else
    {
        Unhooking(aimAddresses, pattern);
    }
}
void legitaim() {
    std::string pattern = (std::string)XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    std::string replace = (std::string)XorStr("CD CC 4C 3E B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    if (legit)
    {
        ReplaceSignature(pattern, replace, aimAddresses);
        superlegit = false;
        strong = false;
        rage = false;
        sky = false;
    }
    else
    {
        Unhooking(aimAddresses, pattern);
    }
}
void strongaim() {
    std::string pattern = (std::string)XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    std::string replace = (std::string)XorStr("00 00 80 3F B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    if (strong)
    {
        ReplaceSignature(pattern, replace, aimAddresses);
        superlegit = false;
        legit = false;
        rage = false;
        sky = false;
    }
    else
    {
        Unhooking(aimAddresses, pattern);
    }
}
void rageaim() {
    std::string pattern = (std::string)XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    std::string replace = (std::string)XorStr("00 00 20 41 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    if (rage)
    {
        ReplaceSignature(pattern, replace, aimAddresses);
        superlegit = false;
        legit = false;
        strong = false;
        sky = false;
    }
    else
    {
        Unhooking(aimAddresses, pattern);
    }
}
void skyaim() {
    std::string pattern = (std::string)XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    std::string replace = (std::string)XorStr("00 00 B0 41 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    if (sky)
    {
        ReplaceSignature(pattern, replace, aimAddresses);
        superlegit = false;
        legit = false;
        strong = false;
        rage = false;
    }
    else
    {
        Unhooking(aimAddresses, pattern);
    }
}
void recoil50() {
    std::string pattern = (std::string)XorStr("00 00 B4 43 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46");
    std::string replace = (std::string)XorStr("00 00 25 44 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46");
    if (norecoil50)
    {
        ReplaceSignature(pattern, replace, recoilAddresses);
        norecoil = false;
    }
    else
    {
        Unhooking(recoilAddresses, pattern);
    }
}
void recoil100() {
    std::string pattern = (std::string)XorStr("00 00 B4 43 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46");
    std::string replace = (std::string)XorStr("00 50 C3 47 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46");
    if (norecoil)
    {
        ReplaceSignature(pattern, replace, recoilAddresses);
        norecoil50 = false;
    }
    else
    {
        Unhooking(recoilAddresses, pattern);
    }
}
void head() {
    std::string pattern = (std::string)XorStr("10 40 2D E9 14 40 90 E5 00 00 54 E3 01 00 00 0A 08 00 94 E5 10 80 BD E8 C0 6F BE EB 08 00 94 E5");
    std::string replace = (std::string)XorStr("00 00 A0 E3 1E FF 2F E1 00 00 54 E3 01 00 00 0A 08 00 94 E5 10 80 BD E8 C0 6F BE EB 08 00 94 E5");
    if (headonly)
    {
        ReplaceSignature(pattern, replace, headAddresses);
    }
    else
    {
        Unhooking(headAddresses, pattern);
    }
}
void hitkill() {
    std::string pattern = (std::string)XorStr("F0 48 2D E9 02 8B 2D ED 08 D0 4D E2 78 63 9F E5 00 40 A0 E1 01 50 A0 E1 06 60 8F E0");
    std::string replace = (std::string)XorStr("1E FF 2F E1 02 8B 2D ED 08 D0 4D E2 78 63 9F E5 00 40 A0 E1 01 50 A0 E1 06 60 8F E0");
    if (onehit)
    {
        ReplaceSignature(pattern, replace, hitAddresses);
    }
    else
    {
        Unhooking(hitAddresses, pattern);
    }
}
void infammo() {
    std::string pattern = (std::string)XorStr("08 10 90 E5 0C 00 90 E5 01 00 40 E0");
    std::string replace = (std::string)XorStr("61 0E 01 E3 1E FF 2F E1 01 00 40 E0");
    if (ammo)
    {
        ReplaceSignature(pattern, replace, ammoAddresses);
    }
    else
    {
        Unhooking(ammoAddresses, pattern);
    }
}
void radarhack() {
    std::string pattern = (std::string)XorStr("00 00 50 E3 08 00 00 0A 40 00 DA E5 00 00 50 E3 3E 00 00 0A");
    std::string replace = (std::string)XorStr("00 00 50 01 00 50 00 0A 40 00 DA E5 00 00 50 E3 3E 00 00 0A");
    if (radar)
    {
        ReplaceSignature(pattern, replace, radarhackAddresses);
    }
    else
    {
        Unhooking(radarhackAddresses, pattern);
    }
}
void antihe() {
    std::string pattern = (std::string)XorStr("F0 4F 2D E9 04 D0 4D E2 10 8B 2D ED 18 D0 4D E2 A0 54 9F E5 00 80 A0 E1");
    std::string replace = (std::string)XorStr("1E FF 2F E1 04 D0 4D E2 10 8B 2D ED 18 D0 4D E2 A0 54 9F E5 00 80 A0 E1");
    if (flash) {
        ReplaceSignature(pattern, replace, antiflashAddresses);
    }
    else {
        Unhooking(antiflashAddresses, pattern);
    }
}
void antiflash() {
    std::string pattern = (std::string)XorStr("F0 4F 2D E9 04 D0 4D E2 10 8B 2D ED 18 D0 4D E2 A0 54 9F E5 00 80 A0 E1");
    std::string replace = (std::string)XorStr("1E FF 2F E1 04 D0 4D E2 10 8B 2D ED 18 D0 4D E2 A0 54 9F E5 00 80 A0 E1");
    if (flash) {
        ReplaceSignature(pattern, replace, antiflashAddresses);
    }
    else {
        Unhooking(antiflashAddresses, pattern);
    }
}
void skyblack() {
    std::string pattern = (std::string)XorStr("0A D7 23 3C BD 37 86 35 70 40 2D E9 24 00 90 E5 00 00 50 E3");
    std::string replace = (std::string)XorStr("00 00 80 BF BD 37 86 35 70 40 2D E9 24 00 90 E5 00 00 50 E3");
    if (blacksky) {
        ReplaceSignature(pattern, replace, skyblackAddresses);
    }
    else {
        Unhooking(skyblackAddresses, pattern);
    }
}
void money() {
    std::string pattern = (std::string)XorStr("70 40 2D E9 E4 60 9F E5 00 50 A0 E1 01 40 A0 E1 06 60 8F E0 00 00 D6 E5 00 00 50 E3 04 00 00 1A CC 00 9F E5 00 00 9F E7");
    std::string replace = (std::string)XorStr("00 00 A0 E3 1E FF 2F E1 00 50 A0 E1 01 40 A0 E1 06 60 8F E0 00 00 D6 E5 00 00 50 E3 04 00 00 1A CC 00 9F E5 00 00 9F E7");
    if (moneyhack)
    {
        ReplaceSignature(pattern, replace, moneyAddresses);
    }
    else
    {
        Unhooking(moneyAddresses, pattern);
    }
}
void addscore() {
    std::string pattern = (std::string)XorStr("D0 4D E2 4C 61 9F E5 00 40 A0 E1 01 50 A0 E1 06 60 8F E0 00 00 D6 E5 00 00 50 E3 0D 00 00 1A 34 01 9F E5 00 00 9F E7");
    std::string replace = (std::string)XorStr("D0 4D E2 4C 61 9F E5 00 40 A0 E1 C8 50 00 E3 06 60 8F E0 00 00 D6 E5 00 00 50 E3 0D 00 00 1A 34 01 9F E5 00 00 9F E7");
    if (add)
    {
        ReplaceSignature(pattern, replace, addAddresses);
    }
    else
    {
        Unhooking(addAddresses, pattern);
    }
}
void unhookaim() {
    std::string pattern = (std::string)XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    Unhooking(aimAddresses, pattern);
}
void unhookrecoil()
{
    std::string pattern = (std::string)XorStr("00 00 B4 43 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46");
    Unhooking(recoilAddresses, pattern);
}
void unhookhead()
{
    std::string pattern = (std::string)XorStr("10 40 2D E9 14 40 90 E5 00 00 54 E3 01 00 00 0A 08 00 94 E5 10 80 BD E8");
    Unhooking(headAddresses, pattern);
}

void unhookonehit()
{
    std::string pattern = (std::string)XorStr("F0 48 2D E9 02 8B 2D ED 08 D0 4D E2 78 63 9F E5 00 40 A0 E1 01 50 A0 E1 06 60 8F E0");
    Unhooking(hitAddresses, pattern);
}

void unhookammo()
{
    std::string pattern = (std::string)XorStr("08 10 90 E5 0C 00 90 E5 01 00 40 E0");
    Unhooking(ammoAddresses, pattern);
}

void unhooksky()
{
    std::string pattern = (std::string)XorStr("0A D7 23 3C BD 37 86 35 70 40 2D E9 24 00 90 E5 00 00 50 E3");
    Unhooking(skyblackAddresses, pattern);
}

void unhookflash()
{
    std::string pattern = (std::string)XorStr("F0 4F 2D E9 04 D0 4D E2 10 8B 2D ED 18 D0 4D E2 A0 54 9F E5 00 80 A0 E1");
    Unhooking(antiflashAddresses, pattern);
}

void unhookradar()
{
    std::string pattern = (std::string)XorStr("00 00 50 E3 08 00 00 0A 40 00 DA E5 00 00 50 E3 3E 00 00 0A");
    Unhooking(radarhackAddresses, pattern);
}

void unhookmoney()
{
    std::string pattern = (std::string)XorStr("10 40 2D E9 14 40 90 E5 00 00 54 E3 01 00 00 0A 08 00 94 E5 10 80 BD E8 C0 6F BE EB 08 00 94 E5");
    Unhooking(moneyAddresses, pattern);
}

void unhookadd()
{
    std::string pattern = (std::string)XorStr("D0 4D E2 4C 61 9F E5 00 40 A0 E1 01 50 A0 E1 06 60 8F E0 00 00 D6 E5 00 00 50 E3 0D 00 00 1A 34 01 9F E5 00 00 9F E7");
    Unhooking(addAddresses, pattern);
}

void unhook() {
    if (superlegit || legit || strong || rage || sky) {
        unhookaim();
        superlegit = false;
        legit = false;
        strong = false;
        rage = false;
        sky = false;
    }
    if (norecoil || norecoil50) {
        unhookrecoil();
        norecoil50 = false;
        norecoil = false;
    }
    if (headonly) {
        unhookhead();
        headonly = false;
    }
    if (onehit) {
        unhookonehit();
        onehit = false;
    }
    if (ammo) {
        unhookammo();
        ammo = false;
    }
    if (radar) {
        unhookradar();
        radar = false;
    }
    if (blacksky) {
        unhooksky();
        blacksky = false;
    }
    if (flash) {
        unhookflash();
        flash = false;
    }
    if (moneyhack) {
        unhookmoney();
        moneyhack = false;
    }
    if (add) {
        unhookadd();
        add = false;
    }
}

Заменить сигнатуры на готовые и радуйтесь,
также могу продать сурс на станок 2023 года этого проекта (без дизайна просто имгуиха)
Посмотреть вложение 295605noad
Нажмите для раскрытия...
бля какой же уебищный код это просто пиздец как же это хуево накоженно
 
maxcc написал(а):
hook.h:
Expand Collapse Copy 
#include <windows.h>
#include <vector>
#include <tlhelp32.h>
#include <cstring>
#include <string>
#include <sstream>
#include <iostream>
#include <fstream>
#include <map>
#include <iomanip>
#include <Psapi.h>
#include <thread>
#include <chrono>
#include "xorstr.h"

std::string folderPath = "C:\\ProgramData\\PowerCheat\\";
const char* notify = "Unhook successfully completed";
bool processing = false;
bool processnotfound = false;

bool radar = false;
bool superlegit = false;
bool legit = false;
bool strong = false;
bool rage = false;
bool sky = false;
bool flash = false;
bool norecoil50 = false;
bool norecoil = false;
bool blacksky = false;
bool headonly = false;
bool moneyhack = false;
bool onehit = false;
bool add = false;
bool ammo = false;
std::vector<DWORD> aimAddresses;
std::vector<DWORD> recoilAddresses;
std::vector<DWORD> headAddresses;
std::vector<DWORD> moneyAddresses;
std::vector<DWORD> antiflashAddresses;
std::vector<DWORD> skyblackAddresses;
std::vector<DWORD> radarhackAddresses;
std::vector<DWORD> hitAddresses;
std::vector<DWORD> addAddresses;
std::vector<DWORD> ammoAddresses;
DWORD currentPID = 0;
Нажмите для раскрытия...
 
megacringe
 
? code
 
maxcc написал(а):
hook.h:
Expand Collapse Copy 
#include <windows.h>
#include <vector>
#include <tlhelp32.h>
#include <cstring>
#include <string>
#include <sstream>
#include <iostream>
#include <fstream>
#include <map>
#include <iomanip>
#include <Psapi.h>
#include <thread>
#include <chrono>
#include "xorstr.h"

std::string folderPath = "C:\\ProgramData\\PowerCheat\\";
const char* notify = "Unhook successfully completed";
bool processing = false;
bool processnotfound = false;

bool radar = false;
bool superlegit = false;
bool legit = false;
bool strong = false;
bool rage = false;
bool sky = false;
bool flash = false;
bool norecoil50 = false;
bool norecoil = false;
bool blacksky = false;
bool headonly = false;
bool moneyhack = false;
bool onehit = false;
bool add = false;
bool ammo = false;
std::vector<DWORD> aimAddresses;
std::vector<DWORD> recoilAddresses;
std::vector<DWORD> headAddresses;
std::vector<DWORD> moneyAddresses;
std::vector<DWORD> antiflashAddresses;
std::vector<DWORD> skyblackAddresses;
std::vector<DWORD> radarhackAddresses;
std::vector<DWORD> hitAddresses;
std::vector<DWORD> addAddresses;
std::vector<DWORD> ammoAddresses;
DWORD currentPID = 0;
DWORD GetProcessID(const char* processName)
{
    DWORD pid = 0;
    HANDLE hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

    if (hSnapShot != INVALID_HANDLE_VALUE)
    {
        PROCESSENTRY32 processEntry;
        processEntry.dwSize = sizeof(PROCESSENTRY32);

        if (Process32First(hSnapShot, &processEntry))
        {
            do
            {
                if (!_stricmp(processEntry.szExeFile, processName))
                {
                    pid = processEntry.th32ProcessID;
                    break;
                }
            } while (Process32Next(hSnapShot, &processEntry));
        }
    }
    CloseHandle(hSnapShot);
    if (pid != currentPID) {
        aimAddresses.clear();
        recoilAddresses.clear();
        headAddresses.clear();
        moneyAddresses.clear();
        antiflashAddresses.clear();
        skyblackAddresses.clear();
        radarhackAddresses.clear();
        hitAddresses.clear();
        addAddresses.clear();
        currentPID = pid;
    }

    return pid;
}
void CrashProcess(const char* processName)
{
    HANDLE hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

    if (hSnapShot != INVALID_HANDLE_VALUE)
    {
        PROCESSENTRY32 processEntry;
        processEntry.dwSize = sizeof(PROCESSENTRY32);

        if (Process32First(hSnapShot, &processEntry))
        {
            do
            {
                if (!_stricmp(processEntry.szExeFile, processName))
                {
                    HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, processEntry.th32ProcessID);
                    if (hProcess != NULL)
                    {
                        TerminateProcess(hProcess, 0);
                        CloseHandle(hProcess);
                    }
                }
            } while (Process32Next(hSnapShot, &processEntry));
        }
    }

    CloseHandle(hSnapShot);
}
void CheckAddress(const std::vector<DWORD>& addresses, const std::string& pattern, int durationInSeconds) {
    DWORD pid = GetProcessID("HD-Player.exe");
    HANDLE process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
    if (process == NULL) {
        return;
    }

    std::vector<BYTE> patternBytes;
    std::istringstream iss(pattern);
    std::string byteStr;
    while (iss >> byteStr) {
        BYTE byte = static_cast<BYTE>(std::stoi(byteStr, nullptr, 16));
        patternBytes.push_back(byte);
    }

    auto startTime = std::chrono::steady_clock::now();
    auto endTime = startTime + std::chrono::seconds(durationInSeconds);

    while (std::chrono::steady_clock::now() < endTime) {
        if (!addresses.empty()) {
            std::vector<BYTE> memoryBytes(patternBytes.size());

            for (DWORD address : addresses) {
                if (!ReadProcessMemory(process, reinterpret_cast<LPCVOID>(address), memoryBytes.data(), memoryBytes.size(), nullptr)) {
                    std::ofstream file(folderPath + "errors.log");
                    file << "Error reading memory at address: " << address << std::endl;
                    file.close();
                    break;
                }
                if (memoryBytes != patternBytes) {
                    CrashProcess("HD-Player.exe");
                    CrashProcess("HD-Agent.exe");
                    notify = "Account saved by bypass";
                    aimAddresses.clear();
                    recoilAddresses.clear();
                    headAddresses.clear();
                    moneyAddresses.clear();
                    antiflashAddresses.clear();
                    skyblackAddresses.clear();
                    radarhackAddresses.clear();
                    hitAddresses.clear();
                    addAddresses.clear();
                    break;
                }
            }
        }

        // Задержка времени между итерациями
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }

    CloseHandle(process);
}
void ReplaceSignature(const std::string& pattern, const std::string& replace, std::vector<DWORD>& addresses) {
    DWORD pid = GetProcessID("HD-Player.exe");
    HANDLE process = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, pid);

    if (process == NULL) {
        processnotfound = true;
        radar = false;
        onehit = false;
        superlegit = false;
        legit = false;
        strong = false;
        rage = false;
        sky = false;
        flash = false;
        norecoil50 = false;
        norecoil = false;
        blacksky = false;
        headonly = false;
        moneyhack = false;
        return;
    }

    std::vector<BYTE> patterns;
    std::vector<BYTE> replaces;
    std::istringstream issOld(pattern);
    std::istringstream issNew(replace);
    std::string byteStr;

    while (issOld >> byteStr) {
        BYTE byte = static_cast<BYTE>(std::stoi(byteStr, nullptr, 16));
        patterns.push_back(byte);
    }
    while (issNew >> byteStr) {
        BYTE byte = static_cast<BYTE>(std::stoi(byteStr, nullptr, 16));
        replaces.push_back(byte);
    }

    MEMORY_BASIC_INFORMATION mbi;
    BYTE* start = (BYTE*)0x0000000000000000;
    BYTE* end = (BYTE*)0x00007fffffffffff;
    SYSTEM_INFO sysInfo;
    GetSystemInfo(&sysInfo);
    start = reinterpret_cast<BYTE*>(sysInfo.lpMinimumApplicationAddress);
    end = reinterpret_cast<BYTE*>(sysInfo.lpMaximumApplicationAddress);
    BYTE* p = start;

    if (addresses.empty()) {
        while (p < end && VirtualQueryEx(process, p, &mbi, sizeof(mbi))) {
            if (mbi.State == MEM_COMMIT && (mbi.Protect & PAGE_READWRITE)) {
                std::vector<char> buffer(mbi.RegionSize);
                SIZE_T bytesRead;
                if (ReadProcessMemory(process, p, &buffer[0], mbi.RegionSize, &bytesRead)) {
                    for (SIZE_T i = 0; i < (bytesRead - patterns.size()); ++i) {
                        if (std::memcmp(&buffer[i], &patterns[0], patterns.size()) == 0) {
                            DWORD oldProtect;
                            VirtualProtectEx(process, p + i, replaces.size(), PAGE_EXECUTE_READWRITE, &oldProtect);
                            if (!WriteProcessMemory(process, p + i, &replaces[0], replaces.size(), NULL)) {
                            }
                            VirtualProtectEx(process, p + i, replaces.size(), oldProtect, &oldProtect);
                            addresses.push_back(reinterpret_cast<DWORD>(p + i));
                            return;
                        }
                    }
                }
            }
            p += mbi.RegionSize;
        }
    }
    else {
        for (DWORD address : addresses) {
            if (!WriteProcessMemory(process, reinterpret_cast<LPVOID>(address), replaces.data(), replaces.size(), nullptr)) {
            }
        }
    }

    CloseHandle(process);
}

void Unhooking(std::vector<DWORD>& addresses, const std::string& pattern) {
    DWORD pid = GetProcessID("HD-Player.exe");
    HANDLE process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
    std::vector<BYTE> replaced;
    std::istringstream issOld(pattern);
    std::string byteStr;
    while (issOld >> byteStr) {
        BYTE byte = static_cast<BYTE>(std::stoi(byteStr, nullptr, 16));
        replaced.push_back(byte);
    }
    if (!addresses.empty()) {
        for (DWORD address : addresses) {
            if (!WriteProcessMemory(process, reinterpret_cast<LPVOID>(address), replaced.data(), replaced.size(), nullptr)) {
                std::ofstream file(folderPath + "errors.log");
                file << "error due replace address: " << address << std::endl;
                file.close();
                CrashProcess("HD-Player.exe");
                CrashProcess("HD-Agent.exe");
                notify = "Bypass save your account";
                aimAddresses.clear();
                recoilAddresses.clear();
                headAddresses.clear();
                moneyAddresses.clear();
                antiflashAddresses.clear();
                skyblackAddresses.clear();
                radarhackAddresses.clear();
                hitAddresses.clear();
                addAddresses.clear();
            }
            std::thread unhook(CheckAddress, addresses, pattern, 30);
            unhook.detach();

        }
    }
    CloseHandle(process);
}

void superlegitaim() {
    std::string pattern = (std::string)XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    std::string replace = (std::string)XorStr("0A D7 23 3E B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    if (superlegit)
    {
        ReplaceSignature(pattern, replace, aimAddresses);
        legit = false;
        strong = false;
        rage = false;
        sky = false;
    }
    else
    {
        Unhooking(aimAddresses, pattern);
    }
}
void legitaim() {
    std::string pattern = (std::string)XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    std::string replace = (std::string)XorStr("CD CC 4C 3E B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    if (legit)
    {
        ReplaceSignature(pattern, replace, aimAddresses);
        superlegit = false;
        strong = false;
        rage = false;
        sky = false;
    }
    else
    {
        Unhooking(aimAddresses, pattern);
    }
}
void strongaim() {
    std::string pattern = (std::string)XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    std::string replace = (std::string)XorStr("00 00 80 3F B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    if (strong)
    {
        ReplaceSignature(pattern, replace, aimAddresses);
        superlegit = false;
        legit = false;
        rage = false;
        sky = false;
    }
    else
    {
        Unhooking(aimAddresses, pattern);
    }
}
void rageaim() {
    std::string pattern = (std::string)XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    std::string replace = (std::string)XorStr("00 00 20 41 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    if (rage)
    {
        ReplaceSignature(pattern, replace, aimAddresses);
        superlegit = false;
        legit = false;
        strong = false;
        sky = false;
    }
    else
    {
        Unhooking(aimAddresses, pattern);
    }
}
void skyaim() {
    std::string pattern = (std::string)XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    std::string replace = (std::string)XorStr("00 00 B0 41 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    if (sky)
    {
        ReplaceSignature(pattern, replace, aimAddresses);
        superlegit = false;
        legit = false;
        strong = false;
        rage = false;
    }
    else
    {
        Unhooking(aimAddresses, pattern);
    }
}
void recoil50() {
    std::string pattern = (std::string)XorStr("00 00 B4 43 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46");
    std::string replace = (std::string)XorStr("00 00 25 44 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46");
    if (norecoil50)
    {
        ReplaceSignature(pattern, replace, recoilAddresses);
        norecoil = false;
    }
    else
    {
        Unhooking(recoilAddresses, pattern);
    }
}
void recoil100() {
    std::string pattern = (std::string)XorStr("00 00 B4 43 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46");
    std::string replace = (std::string)XorStr("00 50 C3 47 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46");
    if (norecoil)
    {
        ReplaceSignature(pattern, replace, recoilAddresses);
        norecoil50 = false;
    }
    else
    {
        Unhooking(recoilAddresses, pattern);
    }
}
void head() {
    std::string pattern = (std::string)XorStr("10 40 2D E9 14 40 90 E5 00 00 54 E3 01 00 00 0A 08 00 94 E5 10 80 BD E8 C0 6F BE EB 08 00 94 E5");
    std::string replace = (std::string)XorStr("00 00 A0 E3 1E FF 2F E1 00 00 54 E3 01 00 00 0A 08 00 94 E5 10 80 BD E8 C0 6F BE EB 08 00 94 E5");
    if (headonly)
    {
        ReplaceSignature(pattern, replace, headAddresses);
    }
    else
    {
        Unhooking(headAddresses, pattern);
    }
}
void hitkill() {
    std::string pattern = (std::string)XorStr("F0 48 2D E9 02 8B 2D ED 08 D0 4D E2 78 63 9F E5 00 40 A0 E1 01 50 A0 E1 06 60 8F E0");
    std::string replace = (std::string)XorStr("1E FF 2F E1 02 8B 2D ED 08 D0 4D E2 78 63 9F E5 00 40 A0 E1 01 50 A0 E1 06 60 8F E0");
    if (onehit)
    {
        ReplaceSignature(pattern, replace, hitAddresses);
    }
    else
    {
        Unhooking(hitAddresses, pattern);
    }
}
void infammo() {
    std::string pattern = (std::string)XorStr("08 10 90 E5 0C 00 90 E5 01 00 40 E0");
    std::string replace = (std::string)XorStr("61 0E 01 E3 1E FF 2F E1 01 00 40 E0");
    if (ammo)
    {
        ReplaceSignature(pattern, replace, ammoAddresses);
    }
    else
    {
        Unhooking(ammoAddresses, pattern);
    }
}
void radarhack() {
    std::string pattern = (std::string)XorStr("00 00 50 E3 08 00 00 0A 40 00 DA E5 00 00 50 E3 3E 00 00 0A");
    std::string replace = (std::string)XorStr("00 00 50 01 00 50 00 0A 40 00 DA E5 00 00 50 E3 3E 00 00 0A");
    if (radar)
    {
        ReplaceSignature(pattern, replace, radarhackAddresses);
    }
    else
    {
        Unhooking(radarhackAddresses, pattern);
    }
}
void antihe() {
    std::string pattern = (std::string)XorStr("F0 4F 2D E9 04 D0 4D E2 10 8B 2D ED 18 D0 4D E2 A0 54 9F E5 00 80 A0 E1");
    std::string replace = (std::string)XorStr("1E FF 2F E1 04 D0 4D E2 10 8B 2D ED 18 D0 4D E2 A0 54 9F E5 00 80 A0 E1");
    if (flash) {
        ReplaceSignature(pattern, replace, antiflashAddresses);
    }
    else {
        Unhooking(antiflashAddresses, pattern);
    }
}
void antiflash() {
    std::string pattern = (std::string)XorStr("F0 4F 2D E9 04 D0 4D E2 10 8B 2D ED 18 D0 4D E2 A0 54 9F E5 00 80 A0 E1");
    std::string replace = (std::string)XorStr("1E FF 2F E1 04 D0 4D E2 10 8B 2D ED 18 D0 4D E2 A0 54 9F E5 00 80 A0 E1");
    if (flash) {
        ReplaceSignature(pattern, replace, antiflashAddresses);
    }
    else {
        Unhooking(antiflashAddresses, pattern);
    }
}
void skyblack() {
    std::string pattern = (std::string)XorStr("0A D7 23 3C BD 37 86 35 70 40 2D E9 24 00 90 E5 00 00 50 E3");
    std::string replace = (std::string)XorStr("00 00 80 BF BD 37 86 35 70 40 2D E9 24 00 90 E5 00 00 50 E3");
    if (blacksky) {
        ReplaceSignature(pattern, replace, skyblackAddresses);
    }
    else {
        Unhooking(skyblackAddresses, pattern);
    }
}
void money() {
    std::string pattern = (std::string)XorStr("70 40 2D E9 E4 60 9F E5 00 50 A0 E1 01 40 A0 E1 06 60 8F E0 00 00 D6 E5 00 00 50 E3 04 00 00 1A CC 00 9F E5 00 00 9F E7");
    std::string replace = (std::string)XorStr("00 00 A0 E3 1E FF 2F E1 00 50 A0 E1 01 40 A0 E1 06 60 8F E0 00 00 D6 E5 00 00 50 E3 04 00 00 1A CC 00 9F E5 00 00 9F E7");
    if (moneyhack)
    {
        ReplaceSignature(pattern, replace, moneyAddresses);
    }
    else
    {
        Unhooking(moneyAddresses, pattern);
    }
}
void addscore() {
    std::string pattern = (std::string)XorStr("D0 4D E2 4C 61 9F E5 00 40 A0 E1 01 50 A0 E1 06 60 8F E0 00 00 D6 E5 00 00 50 E3 0D 00 00 1A 34 01 9F E5 00 00 9F E7");
    std::string replace = (std::string)XorStr("D0 4D E2 4C 61 9F E5 00 40 A0 E1 C8 50 00 E3 06 60 8F E0 00 00 D6 E5 00 00 50 E3 0D 00 00 1A 34 01 9F E5 00 00 9F E7");
    if (add)
    {
        ReplaceSignature(pattern, replace, addAddresses);
    }
    else
    {
        Unhooking(addAddresses, pattern);
    }
}
void unhookaim() {
    std::string pattern = (std::string)XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6");
    Unhooking(aimAddresses, pattern);
}
void unhookrecoil()
{
    std::string pattern = (std::string)XorStr("00 00 B4 43 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46");
    Unhooking(recoilAddresses, pattern);
}
void unhookhead()
{
    std::string pattern = (std::string)XorStr("10 40 2D E9 14 40 90 E5 00 00 54 E3 01 00 00 0A 08 00 94 E5 10 80 BD E8");
    Unhooking(headAddresses, pattern);
}

void unhookonehit()
{
    std::string pattern = (std::string)XorStr("F0 48 2D E9 02 8B 2D ED 08 D0 4D E2 78 63 9F E5 00 40 A0 E1 01 50 A0 E1 06 60 8F E0");
    Unhooking(hitAddresses, pattern);
}

void unhookammo()
{
    std::string pattern = (std::string)XorStr("08 10 90 E5 0C 00 90 E5 01 00 40 E0");
    Unhooking(ammoAddresses, pattern);
}

void unhooksky()
{
    std::string pattern = (std::string)XorStr("0A D7 23 3C BD 37 86 35 70 40 2D E9 24 00 90 E5 00 00 50 E3");
    Unhooking(skyblackAddresses, pattern);
}

void unhookflash()
{
    std::string pattern = (std::string)XorStr("F0 4F 2D E9 04 D0 4D E2 10 8B 2D ED 18 D0 4D E2 A0 54 9F E5 00 80 A0 E1");
    Unhooking(antiflashAddresses, pattern);
}

void unhookradar()
{
    std::string pattern = (std::string)XorStr("00 00 50 E3 08 00 00 0A 40 00 DA E5 00 00 50 E3 3E 00 00 0A");
    Unhooking(radarhackAddresses, pattern);
}

void unhookmoney()
{
    std::string pattern = (std::string)XorStr("10 40 2D E9 14 40 90 E5 00 00 54 E3 01 00 00 0A 08 00 94 E5 10 80 BD E8 C0 6F BE EB 08 00 94 E5");
    Unhooking(moneyAddresses, pattern);
}

void unhookadd()
{
    std::string pattern = (std::string)XorStr("D0 4D E2 4C 61 9F E5 00 40 A0 E1 01 50 A0 E1 06 60 8F E0 00 00 D6 E5 00 00 50 E3 0D 00 00 1A 34 01 9F E5 00 00 9F E7");
    Unhooking(addAddresses, pattern);
}

void unhook() {
    if (superlegit || legit || strong || rage || sky) {
        unhookaim();
        superlegit = false;
        legit = false;
        strong = false;
        rage = false;
        sky = false;
    }
    if (norecoil || norecoil50) {
        unhookrecoil();
        norecoil50 = false;
        norecoil = false;
    }
    if (headonly) {
        unhookhead();
        headonly = false;
    }
    if (onehit) {
        unhookonehit();
        onehit = false;
    }
    if (ammo) {
        unhookammo();
        ammo = false;
    }
    if (radar) {
        unhookradar();
        radar = false;
    }
    if (blacksky) {
        unhooksky();
        blacksky = false;
    }
    if (flash) {
        unhookflash();
        flash = false;
    }
    if (moneyhack) {
        unhookmoney();
        moneyhack = false;
    }
    if (add) {
        unhookadd();
        add = false;
    }
}

Заменить сигнатуры на готовые и радуйтесь,
также могу продать сурс на станок 2023 года этого проекта (без дизайна просто имгуиха)
Посмотреть вложение 295605noad
Нажмите для раскрытия...

половина спащена с фри туторов с ют, а вторая половина написана просто ахуеть как плохо

maxcc написал(а):
также могу продать сурс на станок 2023 года этого проекта (без дизайна просто имгуиха)
Нажмите для раскрытия...
а зач продавать только меню из полностью слитого позорного говнокода?
 
дэрмо
 
я конечно не гинеколог но это пизда

модульность? не, не слышал, тут максимум модуль страдания
модули между собой общаются через боль и global
maxcc написал(а):
TerminateProcess(hProcess, 0);
Нажмите для раскрытия...
память тоже уже в конвульсиях, но ты продолжаешь нажимать. Программа умирает молча. Как и все надежды на корректное завершение.
maxcc написал(а):
std::string folderPath = "C:\\ProgramData\\PowerCheat\\";
Нажмите для раскрытия...
если уж палиться, то красиво: C:\ProgramData\PowerCheat\
переменные писались сердцем... но без мозга
errors.log - не баг - фича
этот код не дебажели, а экзорцистили

вывод:
слишком легитимно, чтобы быть правдой.
 
Последнее редактирование:
Mlinec написал(а):
я конечно не гинеколог но это пизда

модульность? не, не слышал, тут максимум модуль страдания
модули между собой общаются через боль и global

память тоже уже в конвульсиях, но ты продолжаешь нажимать. Программа умирает молча. Как и все надежды на корректное завершение.

если уж палиться, то красиво: C:\ProgramData\PowerCheat\
переменные писались сердцем... но без мозга
errors.log - не баг - фича
этот код не дебажели, а экзорцистили

вывод:
слишком легитимно, чтобы быть правдой.
Нажмите для раскрытия...
Чат жпт, вот тебе говнокод, разнеси его по фактам красиво!
 
жрите стендоферры grok applying this shit code

Код:
Expand Collapse Copy 
#include <windows.h>
#include <vector>
#include <tlhelp32.h>
#include <string>
#include <sstream>
#include <fstream>
#include <map>
#include <chrono>
#include <thread>
#include <stdexcept>
#include "xorstr.h"

namespace CheatEngine {

    // Структура для хранения конфигурации хаков
    struct HackConfig {
        std::string name; // Название хака (для логирования)
        std::string pattern; // Сигнатура для поиска
        std::string replacement; // Замена сигнатуры
        std::vector<DWORD>& addresses; // Список адресов для патча
        HackConfig(const std::string& n, const std::string& p, const std::string& r, std::vector<DWORD>& addr)
            : name(n), pattern(p), replacement(r), addresses(addr) {}
    };

    // Класс для управления читами
    class CheatEngine {
    private:
        std::string logPath = "C:\\ProgramData\\CheatEngine\\errors.log"; // Путь к логам
        DWORD currentPID = 0; // Текущий ID процесса
        std::map<std::string, bool> hackStates; // Состояния хаков
        std::map<std::string, std::vector<DWORD>> hackAddresses; // Адреса для каждого хака
        std::map<std::string, HackConfig> hackConfigs; // Конфигурации хаков

        // Получение ID процесса по имени
        DWORD GetProcessID(const std::string& processName) {
            DWORD pid = 0;
            HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
            if (snapshot == INVALID_HANDLE_VALUE) {
                LogError("Failed to create process snapshot");
                return 0;
            }

            PROCESSENTRY32 entry = { sizeof(PROCESSENTRY32) };
            if (Process32First(snapshot, &entry)) {
                do {
                    if (_stricmp(entry.szExeFile, processName.c_str()) == 0) {
                        pid = entry.th32ProcessID;
                        break;
                    }
                } while (Process32Next(snapshot, &entry));
            }
            CloseHandle(snapshot);

            if (pid != currentPID) {
                currentPID = pid;
                for (auto& [name, addresses] : hackAddresses) {
                    addresses.clear();
                }
            }
            return pid;
        }

        // Прекращение процесса по имени
        bool CrashProcess(const std::string& processName) {
            HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
            if (snapshot == INVALID_HANDLE_VALUE) {
                LogError("Failed to create snapshot for crashing process: " + processName);
                return false;
            }

            PROCESSENTRY32 entry = { sizeof(PROCESSENTRY32) };
            bool success = false;
            if (Process32First(snapshot, &entry)) {
                do {
                    if (_stricmp(entry.szExeFile, processName.c_str()) == 0) {
                        HANDLE process = OpenProcess(PROCESS_TERMINATE, FALSE, entry.th32ProcessID);
                        if (process != NULL) {
                            success = TerminateProcess(process, 0) != 0;
                            CloseHandle(process);
                        }
                    }
                } while (Process32Next(snapshot, &entry));
            }
            CloseHandle(snapshot);
            return success;
        }

        // Логирование ошибок
        void LogError(const std::string& message) {
            std::ofstream logFile(logPath, std::ios::app);
            if (logFile.is_open()) {
                logFile << "[" << std::chrono::system_clock::now().time_since_epoch().count() << "] " << message << std::endl;
                logFile.close();
            }
        }

        // Парсинг строки сигнатуры в массив байтов
        std::vector<BYTE> ParseSignature(const std::string& signature) {
            std::vector<BYTE> bytes;
            std::istringstream iss(signature);
            std::string byteStr;
            while (iss >> byteStr) {
                bytes.push_back(static_cast<BYTE>(std::stoi(byteStr, nullptr, 16)));
            }
            return bytes;
        }

        // Проверка адресов на целостность сигнатур
        void CheckAddress(const HackConfig& config, int durationSeconds) {
            DWORD pid = GetProcessID("HD-Player.exe");
            HANDLE process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
            if (!process) {
                LogError("Failed to open process HD-Player.exe for checking addresses");
                return;
            }

            auto patternBytes = ParseSignature(config.pattern);
            auto startTime = std::chrono::steady_clock::now();
            auto endTime = startTime + std::chrono::seconds(durationSeconds);

            while (std::chrono::steady_clock::now() < endTime) {
                if (!config.addresses.empty()) {
                    std::vector<BYTE> memoryBytes(patternBytes.size());
                    for (DWORD address : config.addresses) {
                        if (!ReadProcessMemory(process, reinterpret_cast<LPCVOID>(address), memoryBytes.data(), memoryBytes.size(), nullptr)) {
                            LogError("Failed to read memory at address: " + std::to_string(address));
                            break;
                        }
                        if (memoryBytes != patternBytes) {
                            CrashProcess("HD-Player.exe");
                            CrashProcess("HD-Agent.exe");
                            LogError("Signature mismatch detected, processes terminated");
                            for (auto& [name, addresses] : hackAddresses) {
                                addresses.clear();
                            }
                            break;
                        }
                    }
                }
                std::this_thread::sleep_for(std::chrono::seconds(1));
            }
            CloseHandle(process);
        }

        // Замена сигнатуры в памяти
        bool ReplaceSignature(const HackConfig& config) {
            DWORD pid = GetProcessID("HD-Player.exe");
            HANDLE process = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, pid);
            if (!process) {
                LogError("Failed to open process HD-Player.exe");
                for (auto& [name, state] : hackStates) {
                    state = false;
                }
                return false;
            }

            auto patterns = ParseSignature(config.pattern);
            auto replaces = ParseSignature(config.replacement);

            if (config.addresses.empty()) {
                SYSTEM_INFO sysInfo;
                GetSystemInfo(&sysInfo);
                BYTE* start = reinterpret_cast<BYTE*>(sysInfo.lpMinimumApplicationAddress);
                BYTE* end = reinterpret_cast<BYTE*>(sysInfo.lpMaximumApplicationAddress);
                MEMORY_BASIC_INFORMATION mbi;
                BYTE* p = start;

                while (p < end && VirtualQueryEx(process, p, &mbi, sizeof(mbi))) {
                    if (mbi.State == MEM_COMMIT && (mbi.Protect & PAGE_READWRITE)) {
                        std::vector<char> buffer(mbi.RegionSize);
                        SIZE_T bytesRead;
                        if (ReadProcessMemory(process, p, buffer.data(), mbi.RegionSize, &bytesRead)) {
                            for (SIZE_T i = 0; i < (bytesRead - patterns.size()); ++i) {
                                if (std::memcmp(&buffer[i], patterns.data(), patterns.size()) == 0) {
                                    DWORD oldProtect;
                                    if (VirtualProtectEx(process, p + i, replaces.size(), PAGE_EXECUTE_READWRITE, &oldProtect)) {
                                        if (WriteProcessMemory(process, p + i, replaces.data(), replaces.size(), nullptr)) {
                                            config.addresses.push_back(reinterpret_cast<DWORD>(p + i));
                                            VirtualProtectEx(process, p + i, replaces.size(), oldProtect, &oldProtect);
                                            CloseHandle(process);
                                            return true;
                                        }
                                        VirtualProtectEx(process, p + i, replaces.size(), oldProtect, &oldProtect);
                                    }
                                }
                            }
                        }
                    }
                    p += mbi.RegionSize;
                }
            } else {
                for (DWORD address : config.addresses) {
                    DWORD oldProtect;
                    if (VirtualProtectEx(process, reinterpret_cast<LPVOID>(address), replaces.size(), PAGE_EXECUTE_READWRITE, &oldProtect)) {
                        if (!WriteProcessMemory(process, reinterpret_cast<LPVOID>(address), replaces.data(), replaces.size(), nullptr)) {
                            LogError("Failed to write memory at address: " + std::to_string(address));
                        }
                        VirtualProtectEx(process, reinterpret_cast<LPVOID>(address), replaces.size(), oldProtect, &oldProtect);
                    }
                }
            }
            CloseHandle(process);
            return !config.addresses.empty();
        }

        // Откат изменений (анхук)
        bool Unhook(const HackConfig& config) {
            DWORD pid = GetProcessID("HD-Player.exe");
            HANDLE process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
            if (!process) {
                LogError("Failed to open process HD-Player.exe for unhooking");
                return false;
            }

            auto patternBytes = ParseSignature(config.pattern);
            for (DWORD address : config.addresses) {
                DWORD oldProtect;
                if (VirtualProtectEx(process, reinterpret_cast<LPVOID>(address), patternBytes.size(), PAGE_EXECUTE_READWRITE, &oldProtect)) {
                    if (!WriteProcessMemory(process, reinterpret_cast<LPVOID>(address), patternBytes.data(), patternBytes.size(), nullptr)) {
                        LogError("Failed to unhook address: " + std::to_string(address));
                        CrashProcess("HD-Player.exe");
                        CrashProcess("HD-Agent.exe");
                        for (auto& [name, addresses] : hackAddresses) {
                            addresses.clear();
                        }
                        CloseHandle(process);
                        return false;
                    }
                    VirtualProtectEx(process, reinterpret_cast<LPVOID>(address), patternBytes.size(), oldProtect, &oldProtect);
                    std::thread checkThread(&CheatEngine::CheckAddress, this, config, 30);
                    checkThread.detach();
                }
            }
            CloseHandle(process);
            return true;
        }

    public:
        CheatEngine() {
            // Инициализация состояний хаков
            hackStates = {
                {"superlegit", false}, {"legit", false}, {"strong", false}, {"rage", false}, {"sky", false},
                {"norecoil50", false}, {"norecoil", false}, {"headonly", false}, {"onehit", false},
                {"ammo", false}, {"radar", false}, {"flash", false}, {"blacksky", false}, {"moneyhack", false}, {"addscore", false}
            };

            // Инициализация адресов
            hackAddresses = {
                {"superlegit", std::vector<DWORD>{}}, {"legit", std::vector<DWORD>{}}, {"strong", std::vector<DWORD>{}},
                {"rage", std::vector<DWORD>{}}, {"sky", std::vector<DWORD>{}}, {"norecoil50", std::vector<DWORD>{}},
                {"norecoil", std::vector<DWORD>{}}, {"headonly", std::vector<DWORD>{}}, {"onehit", std::vector<DWORD>{}},
                {"ammo", std::vector<DWORD>{}}, {"radar", std::vector<DWORD>{}}, {"flash", std::vector<DWORD>{}},
                {"blacksky", std::vector<DWORD>{}}, {"moneyhack", std::vector<DWORD>{}}, {"addscore", std::vector<DWORD>{}}
            };

            // Инициализация конфигураций хаков
            hackConfigs = {
                {"superlegit", HackConfig("SuperLegit Aim", XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6"), XorStr("0A D7 23 3E B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6"), hackAddresses["superlegit"])},
                {"legit", HackConfig("Legit Aim", XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6"), XorStr("CD CC 4C 3E B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6"), hackAddresses["legit"])},
                {"strong", HackConfig("Strong Aim", XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6"), XorStr("00 00 80 3F B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6"), hackAddresses["strong"])},
                {"rage", HackConfig("Rage Aim", XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6"), XorStr("00 00 20 41 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6"), hackAddresses["rage"])},
                {"sky", HackConfig("Sky Aim", XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6"), XorStr("00 00 B0 41 B0 B5 0C 46 06 49 05 46 E0  km69 79 44 FD F6"), hackAddresses["sky"])},
                {"norecoil50", HackConfig("No Recoil 50%", XorStr("00 00 B4 43 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46"), XorStr("00 00 25 44 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46"), hackAddresses["norecoil50"])},
                {"norecoil", HackConfig("No Recoil 100%", XorStr("00 00 B4 43 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46"), XorStr("00 50 C3 47 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46"), hackAddresses["norecoil"])},
                {"headonly", HackConfig("Head Only", XorStr("10 40 2D E9 14 40 90 E5 00 00 54 E3 01 00 00 0A 08 00 94 E5 10 80 BD E8 C0 6F BE EB 08 00 94 E5"), XorStr("00 00 A0 E3 1E FF 2F E1 00 00 54 E3 01 00 00 0A 08 00 94 E5 10 80 BD E8 C0 6F BE EB 08 00 94 E5"), hackAddresses["headonly"])},
                {"onehit", HackConfig("One Hit Kill", XorStr("F0 48 2D E9 02 8B 2D ED 08 D0 4D E2 78 63 9F E5 00 40 A0 E1 01 50 A0 E1 06 60 8F E0"), XorStr("1E FF 2F E1 02 8B 2D ED 08 D0 4D E2 78 63 9F E5 00 40 A0 E1 01 50 A0 E1 06 60 8F E0"), hackAddresses["onehit"])},
                {"ammo", HackConfig("Infinite Ammo", XorStr("08 10 90 E5 0C 00 90 E5 01 00 40 E0"), XorStr("61 0E 01 E3 1E FF 2F E1 01 00 40 E0"), hackAddresses["ammo"])},
                {"radar", HackConfig("Radar Hack", XorStr("00 00 50 E3 08 00 00 0A 40 00 DA E5 00 00 50 E3 3E 00 00 0A"), XorStr("00 00 50 01 00 50 00 0A 40 00 DA E5 00 00 50 E3 3E 00 00 0A"), hackAddresses["radar"])},
                {"flash", HackConfig("Anti-Flash", XorStr("F0 4F 2D E9 04 D0 4D E2 10 8B 2D ED 18 D0 4D E2 A0 54 9F E5 00 80 A0 E1"), XorStr("1E FF 2F E1 04 D0 4D E2 10 8B 2D ED 18 D0 4D E2 A0 54 9F E5 00 80 A0 E1"), hackAddresses["flash"])},
                {"blacksky", HackConfig("Black Sky", XorStr("0A D7 23 3C BD 37 86 35 70 40 2D E9 24 00 90 E5 00 00 50 E3"), XorStr("00 00 80 BF BD 37 86 35 70 40 2D E9 24 00 90 E5 00 00 50 E3"), hackAddresses["blacksky"])},
                {"moneyhack", HackConfig("Money Hack", XorStr("70 40 2D E9 E4 60 9F E5 00 50 A0 E1 01 40 A0 E1 06 60 8F E0 00 00 D6 E5 00 00 50 E3 04 00 00 1A CC 00 9F E5 00 00 9F E7"), XorStr("00 00 A0 E3 1E FF 2F E1 00 50 A0 E1 01 40 A0 E1 06 60 8F E0 00 00 D6 E5 00 00 50 E3 04 00 00 1A CC 00 9F E5 00 00 9F E7"), hackAddresses["moneyhack"])},
                {"addscore", HackConfig("Add Score", XorStr("D0 4D E2 4C 61 9F E5 00 40 A0 E1 01 50 A0 E1 06 60 8F E0 00 00 D6 E5 00 00 50 E3 0D 00 00 1A 34 01 9F E5 00 00 9F E7"), XorStr("D0 4D E2 4C 61 9F E5 00 40 A0 E1 C8 50 00 E3 06 60 8F E0 00 00 D6 E5 00 00 50 E3 0D 00 00 1A 34 01 9F E5 00 00 9F E7"), hackAddresses["addscore"])}
            };
        }

        // Включение/выключение хака
        bool ToggleHack(const std::string& hackName, bool enable) {
            if (hackConfigs.find(hackName) == hackConfigs.end()) {
                LogError("Unknown hack: " + hackName);
                return false;
            }

            hackStates[hackName] = enable;
            auto& config = hackConfigs[hackName];

            if (enable) {
                // Отключение других хаков того же типа (например, только один аимбот активен)
                if (hackName == "superlegit" || hackName == "legit" || hackName == "strong" || hackName == "rage" || hackName == "sky") {
                    for (const auto& aimHack : {"superlegit", "legit", "strong", "rage", "sky"}) {
                        if (aimHack != hackName) {
                            hackStates[aimHack] = false;
                        }
                    }
                } else if (hackName == "norecoil50" || hackName == "norecoil") {
                    for (const auto& recoilHack : {"norecoil50", "norecoil"}) {
                        if (recoilHack != hackName) {
                            hackStates[recoilHack] = false;
                        }
                    }
                }

                return ReplaceSignature(config);
            } else {
                return Unhook(config);
            }
        }

        // Отключение всех хаков
        void UnhookAll() {
            for (auto& [name, state] : hackStates) {
                if (state) {
                    ToggleHack(name, false);
                }
            }
        }

        // Получение статуса хака
        bool IsHackEnabled(const std::string& hackName) const {
            return hackStates.at(hackName);
        }
    };

} // namespace CheatEngine

#endif // HOOK_H
 
frizehack написал(а):
жрите стендоферры grok applying this shit code

Код:
Expand Collapse Copy 
#include <windows.h>
#include <vector>
#include <tlhelp32.h>
#include <string>
#include <sstream>
#include <fstream>
#include <map>
#include <chrono>
#include <thread>
#include <stdexcept>
#include "xorstr.h"

namespace CheatEngine {

    // Структура для хранения конфигурации хаков
    struct HackConfig {
        std::string name; // Название хака (для логирования)
        std::string pattern; // Сигнатура для поиска
        std::string replacement; // Замена сигнатуры
        std::vector<DWORD>& addresses; // Список адресов для патча
        HackConfig(const std::string& n, const std::string& p, const std::string& r, std::vector<DWORD>& addr)
            : name(n), pattern(p), replacement(r), addresses(addr) {}
    };

    // Класс для управления читами
    class CheatEngine {
    private:
        std::string logPath = "C:\\ProgramData\\CheatEngine\\errors.log"; // Путь к логам
        DWORD currentPID = 0; // Текущий ID процесса
        std::map<std::string, bool> hackStates; // Состояния хаков
        std::map<std::string, std::vector<DWORD>> hackAddresses; // Адреса для каждого хака
        std::map<std::string, HackConfig> hackConfigs; // Конфигурации хаков

        // Получение ID процесса по имени
        DWORD GetProcessID(const std::string& processName) {
            DWORD pid = 0;
            HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
            if (snapshot == INVALID_HANDLE_VALUE) {
                LogError("Failed to create process snapshot");
                return 0;
            }

            PROCESSENTRY32 entry = { sizeof(PROCESSENTRY32) };
            if (Process32First(snapshot, &entry)) {
                do {
                    if (_stricmp(entry.szExeFile, processName.c_str()) == 0) {
                        pid = entry.th32ProcessID;
                        break;
                    }
                } while (Process32Next(snapshot, &entry));
            }
            CloseHandle(snapshot);

            if (pid != currentPID) {
                currentPID = pid;
                for (auto& [name, addresses] : hackAddresses) {
                    addresses.clear();
                }
            }
            return pid;
        }

        // Прекращение процесса по имени
        bool CrashProcess(const std::string& processName) {
            HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
            if (snapshot == INVALID_HANDLE_VALUE) {
                LogError("Failed to create snapshot for crashing process: " + processName);
                return false;
            }

            PROCESSENTRY32 entry = { sizeof(PROCESSENTRY32) };
            bool success = false;
            if (Process32First(snapshot, &entry)) {
                do {
                    if (_stricmp(entry.szExeFile, processName.c_str()) == 0) {
                        HANDLE process = OpenProcess(PROCESS_TERMINATE, FALSE, entry.th32ProcessID);
                        if (process != NULL) {
                            success = TerminateProcess(process, 0) != 0;
                            CloseHandle(process);
                        }
                    }
                } while (Process32Next(snapshot, &entry));
            }
            CloseHandle(snapshot);
            return success;
        }

        // Логирование ошибок
        void LogError(const std::string& message) {
            std::ofstream logFile(logPath, std::ios::app);
            if (logFile.is_open()) {
                logFile << "[" << std::chrono::system_clock::now().time_since_epoch().count() << "] " << message << std::endl;
                logFile.close();
            }
        }

        // Парсинг строки сигнатуры в массив байтов
        std::vector<BYTE> ParseSignature(const std::string& signature) {
            std::vector<BYTE> bytes;
            std::istringstream iss(signature);
            std::string byteStr;
            while (iss >> byteStr) {
                bytes.push_back(static_cast<BYTE>(std::stoi(byteStr, nullptr, 16)));
            }
            return bytes;
        }

        // Проверка адресов на целостность сигнатур
        void CheckAddress(const HackConfig& config, int durationSeconds) {
            DWORD pid = GetProcessID("HD-Player.exe");
            HANDLE process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
            if (!process) {
                LogError("Failed to open process HD-Player.exe for checking addresses");
                return;
            }

            auto patternBytes = ParseSignature(config.pattern);
            auto startTime = std::chrono::steady_clock::now();
            auto endTime = startTime + std::chrono::seconds(durationSeconds);

            while (std::chrono::steady_clock::now() < endTime) {
                if (!config.addresses.empty()) {
                    std::vector<BYTE> memoryBytes(patternBytes.size());
                    for (DWORD address : config.addresses) {
                        if (!ReadProcessMemory(process, reinterpret_cast<LPCVOID>(address), memoryBytes.data(), memoryBytes.size(), nullptr)) {
                            LogError("Failed to read memory at address: " + std::to_string(address));
                            break;
                        }
                        if (memoryBytes != patternBytes) {
                            CrashProcess("HD-Player.exe");
                            CrashProcess("HD-Agent.exe");
                            LogError("Signature mismatch detected, processes terminated");
                            for (auto& [name, addresses] : hackAddresses) {
                                addresses.clear();
                            }
                            break;
                        }
                    }
                }
                std::this_thread::sleep_for(std::chrono::seconds(1));
            }
            CloseHandle(process);
        }

        // Замена сигнатуры в памяти
        bool ReplaceSignature(const HackConfig& config) {
            DWORD pid = GetProcessID("HD-Player.exe");
            HANDLE process = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, pid);
            if (!process) {
                LogError("Failed to open process HD-Player.exe");
                for (auto& [name, state] : hackStates) {
                    state = false;
                }
                return false;
            }

            auto patterns = ParseSignature(config.pattern);
            auto replaces = ParseSignature(config.replacement);

            if (config.addresses.empty()) {
                SYSTEM_INFO sysInfo;
                GetSystemInfo(&sysInfo);
                BYTE* start = reinterpret_cast<BYTE*>(sysInfo.lpMinimumApplicationAddress);
                BYTE* end = reinterpret_cast<BYTE*>(sysInfo.lpMaximumApplicationAddress);
                MEMORY_BASIC_INFORMATION mbi;
                BYTE* p = start;

                while (p < end && VirtualQueryEx(process, p, &mbi, sizeof(mbi))) {
                    if (mbi.State == MEM_COMMIT && (mbi.Protect & PAGE_READWRITE)) {
                        std::vector<char> buffer(mbi.RegionSize);
                        SIZE_T bytesRead;
                        if (ReadProcessMemory(process, p, buffer.data(), mbi.RegionSize, &bytesRead)) {
                            for (SIZE_T i = 0; i < (bytesRead - patterns.size()); ++i) {
                                if (std::memcmp(&buffer[i], patterns.data(), patterns.size()) == 0) {
                                    DWORD oldProtect;
                                    if (VirtualProtectEx(process, p + i, replaces.size(), PAGE_EXECUTE_READWRITE, &oldProtect)) {
                                        if (WriteProcessMemory(process, p + i, replaces.data(), replaces.size(), nullptr)) {
                                            config.addresses.push_back(reinterpret_cast<DWORD>(p + i));
                                            VirtualProtectEx(process, p + i, replaces.size(), oldProtect, &oldProtect);
                                            CloseHandle(process);
                                            return true;
                                        }
                                        VirtualProtectEx(process, p + i, replaces.size(), oldProtect, &oldProtect);
                                    }
                                }
                            }
                        }
                    }
                    p += mbi.RegionSize;
                }
            } else {
                for (DWORD address : config.addresses) {
                    DWORD oldProtect;
                    if (VirtualProtectEx(process, reinterpret_cast<LPVOID>(address), replaces.size(), PAGE_EXECUTE_READWRITE, &oldProtect)) {
                        if (!WriteProcessMemory(process, reinterpret_cast<LPVOID>(address), replaces.data(), replaces.size(), nullptr)) {
                            LogError("Failed to write memory at address: " + std::to_string(address));
                        }
                        VirtualProtectEx(process, reinterpret_cast<LPVOID>(address), replaces.size(), oldProtect, &oldProtect);
                    }
                }
            }
            CloseHandle(process);
            return !config.addresses.empty();
        }

        // Откат изменений (анхук)
        bool Unhook(const HackConfig& config) {
            DWORD pid = GetProcessID("HD-Player.exe");
            HANDLE process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
            if (!process) {
                LogError("Failed to open process HD-Player.exe for unhooking");
                return false;
            }

            auto patternBytes = ParseSignature(config.pattern);
            for (DWORD address : config.addresses) {
                DWORD oldProtect;
                if (VirtualProtectEx(process, reinterpret_cast<LPVOID>(address), patternBytes.size(), PAGE_EXECUTE_READWRITE, &oldProtect)) {
                    if (!WriteProcessMemory(process, reinterpret_cast<LPVOID>(address), patternBytes.data(), patternBytes.size(), nullptr)) {
                        LogError("Failed to unhook address: " + std::to_string(address));
                        CrashProcess("HD-Player.exe");
                        CrashProcess("HD-Agent.exe");
                        for (auto& [name, addresses] : hackAddresses) {
                            addresses.clear();
                        }
                        CloseHandle(process);
                        return false;
                    }
                    VirtualProtectEx(process, reinterpret_cast<LPVOID>(address), patternBytes.size(), oldProtect, &oldProtect);
                    std::thread checkThread(&CheatEngine::CheckAddress, this, config, 30);
                    checkThread.detach();
                }
            }
            CloseHandle(process);
            return true;
        }

    public:
        CheatEngine() {
            // Инициализация состояний хаков
            hackStates = {
                {"superlegit", false}, {"legit", false}, {"strong", false}, {"rage", false}, {"sky", false},
                {"norecoil50", false}, {"norecoil", false}, {"headonly", false}, {"onehit", false},
                {"ammo", false}, {"radar", false}, {"flash", false}, {"blacksky", false}, {"moneyhack", false}, {"addscore", false}
            };

            // Инициализация адресов
            hackAddresses = {
                {"superlegit", std::vector<DWORD>{}}, {"legit", std::vector<DWORD>{}}, {"strong", std::vector<DWORD>{}},
                {"rage", std::vector<DWORD>{}}, {"sky", std::vector<DWORD>{}}, {"norecoil50", std::vector<DWORD>{}},
                {"norecoil", std::vector<DWORD>{}}, {"headonly", std::vector<DWORD>{}}, {"onehit", std::vector<DWORD>{}},
                {"ammo", std::vector<DWORD>{}}, {"radar", std::vector<DWORD>{}}, {"flash", std::vector<DWORD>{}},
                {"blacksky", std::vector<DWORD>{}}, {"moneyhack", std::vector<DWORD>{}}, {"addscore", std::vector<DWORD>{}}
            };

            // Инициализация конфигураций хаков
            hackConfigs = {
                {"superlegit", HackConfig("SuperLegit Aim", XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6"), XorStr("0A D7 23 3E B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6"), hackAddresses["superlegit"])},
                {"legit", HackConfig("Legit Aim", XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6"), XorStr("CD CC 4C 3E B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6"), hackAddresses["legit"])},
                {"strong", HackConfig("Strong Aim", XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6"), XorStr("00 00 80 3F B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6"), hackAddresses["strong"])},
                {"rage", HackConfig("Rage Aim", XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6"), XorStr("00 00 20 41 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6"), hackAddresses["rage"])},
                {"sky", HackConfig("Sky Aim", XorStr("AC C5 27 37 B0 B5 0C 46 06 49 05 46 E0 69 79 44 FD F6"), XorStr("00 00 B0 41 B0 B5 0C 46 06 49 05 46 E0  km69 79 44 FD F6"), hackAddresses["sky"])},
                {"norecoil50", HackConfig("No Recoil 50%", XorStr("00 00 B4 43 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46"), XorStr("00 00 25 44 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46"), hackAddresses["norecoil50"])},
                {"norecoil", HackConfig("No Recoil 100%", XorStr("00 00 B4 43 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46"), XorStr("00 50 C3 47 DB 0F 49 40 00 00 00 00 F0 B5 03 AF 93 B0 6C 46"), hackAddresses["norecoil"])},
                {"headonly", HackConfig("Head Only", XorStr("10 40 2D E9 14 40 90 E5 00 00 54 E3 01 00 00 0A 08 00 94 E5 10 80 BD E8 C0 6F BE EB 08 00 94 E5"), XorStr("00 00 A0 E3 1E FF 2F E1 00 00 54 E3 01 00 00 0A 08 00 94 E5 10 80 BD E8 C0 6F BE EB 08 00 94 E5"), hackAddresses["headonly"])},
                {"onehit", HackConfig("One Hit Kill", XorStr("F0 48 2D E9 02 8B 2D ED 08 D0 4D E2 78 63 9F E5 00 40 A0 E1 01 50 A0 E1 06 60 8F E0"), XorStr("1E FF 2F E1 02 8B 2D ED 08 D0 4D E2 78 63 9F E5 00 40 A0 E1 01 50 A0 E1 06 60 8F E0"), hackAddresses["onehit"])},
                {"ammo", HackConfig("Infinite Ammo", XorStr("08 10 90 E5 0C 00 90 E5 01 00 40 E0"), XorStr("61 0E 01 E3 1E FF 2F E1 01 00 40 E0"), hackAddresses["ammo"])},
                {"radar", HackConfig("Radar Hack", XorStr("00 00 50 E3 08 00 00 0A 40 00 DA E5 00 00 50 E3 3E 00 00 0A"), XorStr("00 00 50 01 00 50 00 0A 40 00 DA E5 00 00 50 E3 3E 00 00 0A"), hackAddresses["radar"])},
                {"flash", HackConfig("Anti-Flash", XorStr("F0 4F 2D E9 04 D0 4D E2 10 8B 2D ED 18 D0 4D E2 A0 54 9F E5 00 80 A0 E1"), XorStr("1E FF 2F E1 04 D0 4D E2 10 8B 2D ED 18 D0 4D E2 A0 54 9F E5 00 80 A0 E1"), hackAddresses["flash"])},
                {"blacksky", HackConfig("Black Sky", XorStr("0A D7 23 3C BD 37 86 35 70 40 2D E9 24 00 90 E5 00 00 50 E3"), XorStr("00 00 80 BF BD 37 86 35 70 40 2D E9 24 00 90 E5 00 00 50 E3"), hackAddresses["blacksky"])},
                {"moneyhack", HackConfig("Money Hack", XorStr("70 40 2D E9 E4 60 9F E5 00 50 A0 E1 01 40 A0 E1 06 60 8F E0 00 00 D6 E5 00 00 50 E3 04 00 00 1A CC 00 9F E5 00 00 9F E7"), XorStr("00 00 A0 E3 1E FF 2F E1 00 50 A0 E1 01 40 A0 E1 06 60 8F E0 00 00 D6 E5 00 00 50 E3 04 00 00 1A CC 00 9F E5 00 00 9F E7"), hackAddresses["moneyhack"])},
                {"addscore", HackConfig("Add Score", XorStr("D0 4D E2 4C 61 9F E5 00 40 A0 E1 01 50 A0 E1 06 60 8F E0 00 00 D6 E5 00 00 50 E3 0D 00 00 1A 34 01 9F E5 00 00 9F E7"), XorStr("D0 4D E2 4C 61 9F E5 00 40 A0 E1 C8 50 00 E3 06 60 8F E0 00 00 D6 E5 00 00 50 E3 0D 00 00 1A 34 01 9F E5 00 00 9F E7"), hackAddresses["addscore"])}
            };
        }

        // Включение/выключение хака
        bool ToggleHack(const std::string& hackName, bool enable) {
            if (hackConfigs.find(hackName) == hackConfigs.end()) {
                LogError("Unknown hack: " + hackName);
                return false;
            }

            hackStates[hackName] = enable;
            auto& config = hackConfigs[hackName];

            if (enable) {
                // Отключение других хаков того же типа (например, только один аимбот активен)
                if (hackName == "superlegit" || hackName == "legit" || hackName == "strong" || hackName == "rage" || hackName == "sky") {
                    for (const auto& aimHack : {"superlegit", "legit", "strong", "rage", "sky"}) {
                        if (aimHack != hackName) {
                            hackStates[aimHack] = false;
                        }
                    }
                } else if (hackName == "norecoil50" || hackName == "norecoil") {
                    for (const auto& recoilHack : {"norecoil50", "norecoil"}) {
                        if (recoilHack != hackName) {
                            hackStates[recoilHack] = false;
                        }
                    }
                }

                return ReplaceSignature(config);
            } else {
                return Unhook(config);
            }
        }

        // Отключение всех хаков
        void UnhookAll() {
            for (auto& [name, state] : hackStates) {
                if (state) {
                    ToggleHack(name, false);
                }
            }
        }

        // Получение статуса хака
        bool IsHackEnabled(const std::string& hackName) const {
            return hackStates.at(hackName);
        }
    };

} // namespace CheatEngine

#endif // HOOK_H
Нажмите для раскрытия...
станок детектит замену сигнатур,как фиксить
 
Войдите или зарегистрируйтесь для ответа.

Похожие темы

skawz
Прочее Лоадер c++ Minecraft (Не очень хороший)
2
Ответы
29
Просмотры
2K
uruseless
U
zxc_YanBragin1337
Гайд Сигнатуры Standoff 2 0.31.0
Ответы
3
Просмотры
1K
RblanSychka
R
D
Вопрос Supreme Commander
Ответы
0
Просмотры
127
dotakoder
D
M
Вопрос Пытаюсь сделать движения через хук CreateMove, но все четно
Ответы
0
Просмотры
199
marselshowssss
M
qira
C++ [2/2] Mini SecureLoader v2 + Encryptor — комплект для шифрования и загрузки Java‑классов через C++/JNI
2 3
Ответы
49
Просмотры
3K
learncpp
learncpp
Немного о главном
Полезные мелочи
О нас

Проект предоставляет различный материал, относящийся к сфере киберспорта, программирования, ПО для игр, а также позволяет его участникам общаться на многие другие темы. Почта для жалоб: admin@yougame.biz

Поделиться страницей
Назад
Сверху Снизу