Что нового?

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

maxcc
M
Начинающий
Статус
Оффлайн
Регистрация
15 Фев 2023
Сообщения
140
Реакции[?]
0
Поинты[?]
0
hook.h: 
#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.pngnoad
 
vmprotect
nirvanacheats.com
vmprotect
Участник
Статус
Онлайн
Регистрация
4 Дек 2022
Сообщения
796
Реакции[?]
239
Поинты[?]
9K
maxcc написал(а):
hook.h: 
#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
Нажмите для раскрытия...
бля какой же уебищный код это просто пиздец как же это хуево накоженно
 
Hack3r_jopi
ЧВК EB_LAN
Hack3r_jopi
Эксперт
Статус
Оффлайн
Регистрация
26 Янв 2021
Сообщения
1,612
Реакции[?]
528
Поинты[?]
192K
maxcc написал(а):
hook.h: 
#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;
Нажмите для раскрытия...
 
Войдите или зарегистрируйтесь для ответа.
Немного о главном
Полезные мелочи
О нас

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

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