Official site anti-cheat Ultra Core Protector

Home Download F.A.Q. Addons Monitor Forum Support Advertise English version site UCP Anti-Cheat  Russian version site UCP Anti-Cheat
Ultra Core Protector - is the client-server anti-cheat freeware, for server protection from unscrupulous players.

Abilities Supported games  
Half-Life
Condition Zero
Counter-Strike 1.6
Day of Defeat
Adrenaline Gamer
Team Fortress Classic
Counter-Strike Source
MU Online
Ragnarok Online
Half-Life 2 Deathmatch
Adrenaline Gamer 2
Team Fortress 2
External base for conter strike : global offensive

So I decided to write a little project for those who are starting off and don’t quite know where to go. It consists of memory classes which sets everything up so you can read and write memory as you wish. Offsets are also provided… There are ways of getting the offset instead of hardcoding them, but i’ll leave that up to you to discover..

#include "SDK.h"

namespace SDK
{

int DOPROC::ReadInt(HANDLE Process, DWORD address) {
int value;
ReadProcessMemory(Process, (PBYTE*)(address), &value, sizeof(int), 0);
return value;
}

float DOPROC::ReadFloat(HANDLE Process, DWORD address) {
float value;
ReadProcessMemory(Process, (PBYTE*)(address), &value, sizeof(float), 0);
return value;
}

DWORD DOPROC::ReadDWORD(HANDLE Process, DWORD address) {
DWORD value;
ReadProcessMemory(Process, (PBYTE*)(address), &value, sizeof(DWORD), 0);
return value;
}

SDK::Vector3D DOPROC::ReadVector(HANDLE Process, DWORD address) {
SDK::Vector3D value;
ReadProcessMemory(Process, (PBYTE*)(address), &value.x, sizeof(float), 0);
ReadProcessMemory(Process, (PBYTE*)(address + 0x4), &value.z, sizeof(float), 0);
ReadProcessMemory(Process, (PBYTE*)(address + 0x8), &value.y, sizeof(float), 0);
return value;
}

void DOPROC::WriteFloat(HANDLE Process, DWORD address, float value) {
WriteProcessMemory(Process, (PBYTE*)(address), &value, sizeof(float), 0);
}

void DOPROC::WriteInt(HANDLE Process, DWORD address, int value) {
WriteProcessMemory(Process, (PBYTE*)(address), &value, sizeof(int), 0);
}
}

#include
#include "SDK.h"

//////////////////////
/// MAIN FUNCTIONS ///
//////////////////////

SDK::GTPROC GETPROCESS;
SDK::DOPROC DOPROCESS;

DWORD g_pLocalPlayer;
DWORD g_pEntityList;

DWORD oEntityList = 0x4A8D1AC;
DWORD oLocalPlayer = 0xAAFD7C;
DWORD oVecOrigin = 0x134;

HANDLE g_dwProc;
DWORD g_dwClient;

void Setup() {
printf("CS:GOs\n\n[Getting Addresses]\n\n");
g_dwProc = GETPROCESS.GetProcess("csgo.exe");
g_dwClient = GETPROCESS.GetModule("client.dll");
g_pLocalPlayer = DOPROCESS.ReadDWORD(g_dwProc, g_dwClient + oLocalPlayer);
printf("-Playerbase: %lu\n", g_pLocalPlayer);
printf("\n[Ready]");
}

int main() {
Setup();
while (true) {

//Removes Flash By OverWriting Alpha
if(DOPROCESS.ReadFloat(g_dwProc, g_pLocalPlayer + 0xA2F4) != 0.f)
DOPROCESS.WriteFloat(g_dwProc, g_pLocalPlayer + 0xA2F4, 25.f);
}
return 0;
}

#include "SDK.h"

PROCESSENTRY32 gameProcess;

namespace SDK
{
DWORD GTPROC::FindProcessName(const char *__ProcessName, PROCESSENTRY32 *pEntry)
{
PROCESSENTRY32 __ProcessEntry;
__ProcessEntry.dwSize = sizeof(PROCESSENTRY32);
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hSnapshot == INVALID_HANDLE_VALUE) return 0; if (!Process32First(hSnapshot, &__ProcessEntry))
{
CloseHandle(hSnapshot);
return 0;
}
do {
if (!_strcmpi(__ProcessEntry.szExeFile, __ProcessName))
{
memcpy((void *)pEntry, (void *)&__ProcessEntry, sizeof(PROCESSENTRY32));
CloseHandle(hSnapshot);
return __ProcessEntry.th32ProcessID;
}
} while (Process32Next(hSnapshot, &__ProcessEntry));
CloseHandle(hSnapshot);
return 0;
}

DWORD GTPROC::getThreadByProcess(DWORD __DwordProcess)
{
THREADENTRY32 __ThreadEntry;
__ThreadEntry.dwSize = sizeof(THREADENTRY32);
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
if (hSnapshot == INVALID_HANDLE_VALUE) return 0;

if (!Thread32First(hSnapshot, &__ThreadEntry)) { CloseHandle(hSnapshot); return 0; }

do {
if (__ThreadEntry.th32OwnerProcessID == __DwordProcess)
{
CloseHandle(hSnapshot);
return __ThreadEntry.th32ThreadID;
}
} while (Thread32Next(hSnapshot, &__ThreadEntry));
CloseHandle(hSnapshot);
return 0;
}

DWORD GTPROC::GetModuleNamePointer(LPSTR LPSTRModuleName, DWORD __DwordProcessId)
{
MODULEENTRY32 lpModuleEntry = { 0 };
HANDLE hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, __DwordProcessId);
if (!hSnapShot)
return NULL;
lpModuleEntry.dwSize = sizeof(lpModuleEntry);
BOOL __RunModule = Module32First(hSnapShot, &lpModuleEntry);
while (__RunModule)
{
if (!strcmp(lpModuleEntry.szModule, LPSTRModuleName))
{
CloseHandle(hSnapShot);
return (DWORD)lpModuleEntry.modBaseAddr;
}
__RunModule = Module32Next(hSnapShot, &lpModuleEntry);
}
CloseHandle(hSnapShot);
return NULL;
}

void GTPROC::runSetDebugPrivs()
{
HANDLE __HandleProcess = GetCurrentProcess(), __HandleToken;
TOKEN_PRIVILEGES priv;
LUID __LUID;
OpenProcessToken(__HandleProcess, TOKEN_ADJUST_PRIVILEGES, &__HandleToken);
LookupPrivilegeValue(0, "seDebugPrivilege", &__LUID);
priv.PrivilegeCount = 1;
priv.Privileges[0].Luid = __LUID;
priv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
AdjustTokenPrivileges(__HandleToken, false, &priv, 0, 0, 0);
CloseHandle(__HandleToken);
CloseHandle(__HandleProcess);
}

HANDLE GTPROC::GetProcess(const char* processname)
{

runSetDebugPrivs();
while (!FindProcessName(processname, &gameProcess)) Sleep(12);
while (!(getThreadByProcess(gameProcess.th32ProcessID))) Sleep(12);
HANDLE HandleProcess = OpenProcess(PROCESS_ALL_ACCESS, false, gameProcess.th32ProcessID);
return HandleProcess;

}

DWORD GTPROC::GetModule(const char* modulename)
{
DWORD dw_module = 0x0;
while (dw_module == 0x0) dw_module = GetModuleNamePointer((LPSTR)modulename, gameProcess.th32ProcessID);
return dw_module;
}
}

All sources here github.com/iBambooFox/ext_base/tree/master/ext_base