Перейти к содержанию

RadarHack(CS:GO)


Рекомендуемые сообщения

 

Скрытый текст

 

#include <iostream>
#include "ProcMem.h"

using namespace std;


/*do not change*/
const DWORD teamOffset = 0x00F0;
const DWORD healthOffset = 0xFC;
const DWORD EntLoopDist = 0x10;
const DWORD BeSpotted = 0x0939;
/*do not change*/

/*change every update*/
const DWORD PlayerBase = 0x00AA66D4;//LocalPlayer
const DWORD EntityBase = 0x04AC9154;//EntityList
const DWORD crosshairOffset = 0x0000AA70;//CrossHairID
/*change every update*/

void Radared() {
    
    ProcMem Mem;
    Mem.Process("csgo.exe");
    DWORD ClientDLL = Mem.Module("client.dll");

    DWORD LocalPlayer = Mem.Read<DWORD>(ClientDLL + PlayerBase);
    int LocalTeam = Mem.Read<int>(LocalPlayer + teamOffset);
    
    for (int i = 1; i < 65;i++){
        DWORD opPlayer = Mem.Read<int>(ClientDLL + EntityBase + (i-1)*EntLoopDist);
        DWORD opTeam = Mem.Read<int>(opPlayer + teamOffset);
        
        if (opTeam != LocalTeam && opPlayer != 0) {
            Mem.Write(opPlayer + BeSpotted,1);

        }
            

    }
}


int main() {
    while (TRUE) Radared();
}

 

 

Скрытый текст

 

#include "ProcMem.h"

using namespace std;

#pragma region Misc Functions

ProcMem::ProcMem() {

}

ProcMem::~ProcMem() {
    CloseHandle(hProcess);
}


int ProcMem::chSizeOfArray(char *chArray) {


    for (int iLength = 1; iLength < MAX_PATH; iLength++)
        if (chArray[iLength] == '*')
            return iLength;

    cout << "\nLENGTH: Failed To Read Length Of Array\n";
    return 0;
}


int ProcMem::iSizeOfArray(int *iArray) {


    for (int iLength = 1; iLength < MAX_PATH; iLength++)
        if (iArray[iLength] == '*')
            return iLength;

    cout << "\nLENGTH: Failed To Read Length Of Array\n";
    return 0;
}


bool ProcMem::iFind(int *iAry, int iVal) {

    for (int i = 0; i < 64; i++)
        if (iVal == iAry && iVal != 0)
            return true;

    return false;
}

#pragma endregion

#pragma region Memory Functions


void ProcMem::Process(char* ProcessName) {


    HANDLE hPID = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
    PROCESSENTRY32 ProcEntry;
    ProcEntry.dwSize = sizeof(ProcEntry);


    do
        if (!strcmp(ProcEntry.szExeFile, ProcessName))
        {


            dwPID = ProcEntry.th32ProcessID;
            CloseHandle(hPID);


            hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID);
            return;
        }
    while (Process32Next(hPID, &ProcEntry));

    cout << "\nCould not find the process csgo.exe...\n\n";
    system("pause");
    exit(0);
}


void ProcMem::Patch(DWORD dwAddress, char *Patch_Bts, char *Default_Bts) {


    int iSize = chSizeOfArray(Default_Bts);


    if (!bPOn)
        for (int i = 0; i < iSize; i++)
            Read<BYTE>(dwAddress + i, Patch_Bts);
    else
        for (int i = 0; i < iSize; i++)
            Read<BYTE>(dwAddress + i, Default_Bts);

    bPOn = !bPOn;
}

DWORD ProcMem::AOB_Scan(DWORD dwAddress, DWORD dwEnd, char *Bytes) {


    int iBytesToRead = 0, iTmp = 0;
    int length = chSizeOfArray(Bytes);
    bool bTmp = false;


    if (Bytes[0] == '?')
    {
        for (; iBytesToRead < MAX_PATH; iBytesToRead++)
            if (Bytes[iBytesToRead] != '?')
            {
                iTmp = (iBytesToRead + 1);
                break;
            }
    }


    for (; dwAddress < dwEnd; dwAddress++)
    {
        if (iBytesToRead == length)
            return dwAddress - iBytesToRead;

        if (Read<BYTE>(dwAddress) == Bytes[iBytesToRead] || (bTmp && Bytes[iBytesToRead] == '?'))
        {
            iBytesToRead++;
            bTmp = true;
        }
        else
        {
            iBytesToRead = iTmp;
            bTmp = false;
        }
    }

    cout << "\nAOB_SCAN: Failed To Find Byte Pattern\n\n";
    return 0;
}


DWORD ProcMem::Module(LPSTR ModuleName) {


    HANDLE hModule = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwPID);
    MODULEENTRY32 mEntry;
    mEntry.dwSize = sizeof(mEntry);


    do
        if (!strcmp(mEntry.szModule, ModuleName))
        {
            CloseHandle(hModule);
            return (DWORD)mEntry.modBaseAddr;
        }
    while (Module32Next(hModule, &mEntry));

    cout << "\nCould not attach to Client.dll..\n\n";
    return 0;
}

#pragma endregion

 

 

Скрытый текст

 

#ifndef PROCMEM_H
#define PROCMEM_H

#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <iostream>
#include <TlHelp32.h>
#include <string>
#include <sstream>

class ProcMem {
protected:


public:

    DWORD *base; //Stores Module Base Address
    DWORD Proc_ID; //Varible to store Process ID
    HANDLE hProcess;
    DWORD dwPID, dwProtection, dwCaveAddress;


    BOOL bPOn, bIOn, bProt;

public:


    ProcMem();
    ~ProcMem();
    int chSizeOfArray(char *chArray);
    int iSizeOfArray(int *iArray);
    bool iFind(int *iAry, int iVal);

#pragma region TEMPLATE MEMORY FUNCTIONS

    template <class cData>
    cData Read(DWORD dwAddress)
    {
        cData cRead;
        ReadProcessMemory(hProcess, (LPVOID)dwAddress, &cRead, sizeof(cData), NULL);
        return cRead;
    }


    template <class cData>
    cData Read(DWORD dwAddress, char *Offset, BOOL Type)
    {

        int iSize = iSizeOfArray(Offset) - 1;
        dwAddress = Read<DWORD>(dwAddress);


        for (int i = 0; i < iSize; i++)
            dwAddress = Read<DWORD>(dwAddress + Offset);

        if (!Type)
            return dwAddress + Offset[iSize];
        else
            return Read<cData>(dwAddress + Offset[iSize]);
    }


    template <class cData>
    void Read(DWORD dwAddress, cData Value)
    {
        ReadProcessMemory(hProcess, (LPVOID)dwAddress, &Value, sizeof(cData), NULL);
    }


    template <class cData>
    void Read(DWORD dwAddress, char *Offset, cData Value)
    {
        Read<cData>(Read<cData>(dwAddress, Offset, false), Value);
    }


    virtual void Process(char* ProcessName);
    virtual void Patch(DWORD dwAddress, char *chPatch_Bts, char *chDefault_Bts);
    virtual DWORD AOB_Scan(DWORD dwAddress, DWORD dwEnd, char *chPattern);
    virtual DWORD Module(LPSTR ModuleName);

    //WRITE MEMORY
    template <class cData>

    cData Write(DWORD(Address), cData B ){
        try {
            if (Proc_ID > 0) {
                WriteProcessMemory(hProcess, (LPVOID)(Address), &B, sizeof(B), NULL);
                return B;
            }
            else {
                throw 1; //Throw Error Number / Defined In Catch
            }
        } // Try End
        catch (int error) {
            cout << "error " << GetLastError() << endl;
        } //Catch End

        return 0;
    } //Write End
#pragma endregion

};
#endif

 

 

1 спойлер - код

2 спойлер - procmem.cpp

3 спойлер - procmem.h

 

cout <<  "i: " << i << " OP: " << opPlayer << " OPTEAM: " << opTeam << " Spotted: " << Mem.Read<int>(opPlayer + BeSpotted) << endl;

С помощью такой трассировки проверял m_bSpotted , изменялась переменная только когда я смотрел на игрока , как только отворачивался , игрок пропадал на радаре.

В header в catch записал cout на вывод номера ошибки , выводит ошибку 299 , что не так?

Изменено пользователем Dzirt
Ссылка на комментарий
Поделиться на другие сайты

заметил ошибку и в записи в память теперь Mem.Write(ClientDLL + EntityBase + (i - 1)*EntLoopDist + BeSpotted,1); , но все еще ничего не происходит

Изменено пользователем Dzirt
Ссылка на комментарий
Поделиться на другие сайты

Это была не ошибка , вообщем финальный код под спойлером 

 

Скрытый текст

#include <iostream>
#include "ProcMem.h"

using namespace std;


/*do not change*/
const DWORD teamOffset = 0x00F0;
const DWORD healthOffset = 0xFC;
const DWORD EntLoopDist = 0x10;
const DWORD BeSpotted = 0x0939;
/*do not change*/

/*change every update*/
const DWORD PlayerBase = 0x00AA66D4;//LocalPlayer
const DWORD EntityBase = 0x04AC9154;//EntityList
const DWORD crosshairOffset = 0x0000AA70;//CrossHairID
/*change every update*/



void Radared() {
	
	ProcMem Mem;
	Mem.Process("csgo.exe");
	DWORD ClientDLL = Mem.Module("client.dll");

	DWORD LocalPlayer = Mem.Read<DWORD>(ClientDLL + PlayerBase);
	int LocalTeam = Mem.Read<int>(LocalPlayer + teamOffset);

	for (int i = 1; i < 65;i++) {
		DWORD opPlayer = Mem.Read<int>(ClientDLL + EntityBase + (i-1) * 0x10);
		DWORD opTeam = Mem.Read<int>(opPlayer + teamOffset);

		if (opTeam != LocalTeam && opPlayer != 0) {
			Mem.Write(opPlayer + BeSpotted,1);
		}
	}
}


int main() {
	while (TRUE) Radared();
}

 

 

Ссылка на комментарий
Поделиться на другие сайты

×
×
  • Создать...

Важная информация

Находясь на нашем сайте, Вы автоматически соглашаетесь соблюдать наши Условия использования.